aice/controllers/services/InviteListDirService.go

package services

import (
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"io/ioutil"
	"net/http"
	"net/url"
	"strconv"
	"think-go/models"

	"github.com/beego/beego/v2/client/orm"
)

type InviteListDirService struct{}

// InviteListInfo represents the invite list information
type InviteListInfo struct {
	InviteListDirId int    `json:"invite_list_dir_id"`
	ParentId        string `json:"parent_id"`
	UserId          string `json:"user_id"`
	Username        string `json:"username"`
	PromoteName     string `json:"promote_name"`
	Sales           string `json:"sales"`
	TeamSales       string `json:"team_sales"`
	TodayTeamSales  string `json:"today_team_sales"`
	UserBv          string `json:"user_bv"`
	SubStatus       string `json:"sub_status"`
	CTime           int64  `json:"c_time"`
	IsYes           int    `json:"is_yes"`
}

// GetInviteList retrieves invite list information by user_id
func (s *InviteListDirService) GetInviteList(userId string) (*InviteListInfo, error) {
	if userId == "" {
		return nil, errors.New("user_id is required")
	}

	o := orm.NewOrm()
	record := &models.InviteList{UserId: userId}
	err := o.Read(record, "UserId")
	if err != nil {
		if err == orm.ErrNoRows {
			return nil, errors.New("invite list record not found")
		}
		return nil, err
	}

	return &InviteListInfo{
		InviteListDirId: record.InviteListDirId,
		ParentId:        record.ParentId,
		UserId:          record.UserId,
		Username:        record.Username,
		PromoteName:     record.PromoteName,
		Sales:           record.Sales,
		TeamSales:       record.TeamSales,
		TodayTeamSales:  record.TodayTeamSales,
		UserBv:          record.UserBv,
		SubStatus:       record.SubStatus,
		CTime:           record.CTime,
		IsYes:           record.IsYes,
	}, nil
}

type ExternalInviteResponse struct {
	Code int `json:"code"`
	Data struct {
		InviteAmount int `json:"invite_amount"`
		List         []struct {
			CTime          int64  `json:"c_time"`
			UserID         string `json:"userid"`
			Username       string `json:"username"`
			PromoteName    string `json:"promote_name"`
			Sales          string `json:"sales"`
			TeamSales      string `json:"team_sales"`
			TodayTeamSales string `json:"today_team_sales"`
			UserBV         string `json:"user_bv"`
			SubStatus      int    `json:"sub_status"`
		} `json:"list"`
		Count int `json:"count"`
	} `json:"data"`
}

func (s *InviteListDirService) GoRequestNetInfo(userId string) {
	svc := &InviteListDirService{}
	// 2. 准备外部接口的请求参数（x-www-form-urlencoded）
	data := url.Values{}
	data.Set("limit", strconv.Itoa(1000))
	data.Set("page", strconv.Itoa(1))
	data.Set("userid", userId)

	// 3. 构造 HTTP 请求
	externalURL := "https://app-api.aiceanglobal1.com/api/v1/reward/inviteListDir" // 替换为真实地址
	req, err := http.NewRequest("POST", externalURL, bytes.NewBufferString(data.Encode()))
	if err != nil {

		return
	}

	// 4. 设置 Headers
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
	// 假设 Authorization 是 Bearer token，从配置或环境变量获取
	req.Header.Set("Authorization", "Bearer 590d13fe9d0ea64df44c00c02ce8dd23")
	// 外部接口需要的 userid header（可能和 body 中的 userid 不同，按需设置）
	req.Header.Set("userid", "04a0d628189644a1b918f14cde664610")

	// 5. 发送请求
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {

		fmt.Println("errrr:", err)
		return
	}
	defer resp.Body.Close()

	// 6. 读取响应体
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {

		return
	}

	// 7. 解析 JSON
	var externalResp ExternalInviteResponse
	if err := json.Unmarshal(body, &externalResp); err != nil {

		return
	}

	if err == nil {

		// 遍历列表
		for _, item := range externalResp.Data.List {
			// 取 count
			info := &InviteListInfo{
				ParentId:       userId,
				UserId:         item.UserID,
				Username:       item.Username,
				PromoteName:    item.PromoteName,
				Sales:          item.Sales,
				TeamSales:      item.TeamSales,
				TodayTeamSales: item.TodayTeamSales,
				UserBv:         item.UserBV,
				SubStatus:      strconv.Itoa(item.SubStatus),
				CTime:          item.CTime,
				IsYes:          0,
			}

			err := svc.CreateInviteList(info)
			if err != nil {
				return
			}
		}

	} else {
		fmt.Printf("JSON 序列化失败: %v\n", err)
	}

}
func (s *InviteListDirService) GetInviteListByIsYes() ([]InviteListInfo, error) {

	query := make(map[string]string)
	query["is_yes"] = strconv.Itoa(0)
	fields := []string{"InviteListDirId", "ParentId", "UserId", "Username", "PromoteName", "Sales", "TeamSales", "TodayTeamSales", "UserBv", "SubStatus", "CTime", "IsYes"}
	sortby := []string{"InviteListDirId"}
	order := []string{"desc"}

	ml, err := models.GetAllInviteList(query, fields, sortby, order, 0, 100)
	if err != nil {
		return nil, err
	}

	//fmt.Printf("ml------:", ml)
	result := make([]InviteListInfo, 0, len(ml))

	for _, item := range ml {
		// 断言 item 是 map[string]interface{}
		m, ok := item.(map[string]interface{})
		if !ok {
			// 类型不匹配，跳过或记录错误
			continue
		}

		// 从 map 中安全提取字段（注意字段名与 JSON 标签一致）
		info := InviteListInfo{
			InviteListDirId: getInt(m, "InviteListDirId"), // 根据实际字段名调整
			ParentId:        getString(m, "ParentId"),
			UserId:          getString(m, "UserId"),
			Username:        getString(m, "Username"),
			PromoteName:     getString(m, "PromoteName"),
			Sales:           getString(m, "Sales"),
			TeamSales:       getString(m, "TeamSales"),
			TodayTeamSales:  getString(m, "TodayTeamSales"),
			UserBv:          getString(m, "UserBv"),
			SubStatus:       getString(m, "SubStatus"),
			CTime:           getInt64(m, "CTime"),
			IsYes:           getInt(m, "IsYes"),
		}
		result = append(result, info)
	}

	return result, err
}

// CreateInviteList creates a new invite list record
func (s *InviteListDirService) CreateInviteList(info *InviteListInfo) error {
	if info.UserId == "" {
		return errors.New("user_id is required")
	}

	// Check if record already exists
	o := orm.NewOrm()
	record := &models.InviteList{UserId: info.UserId}
	err := o.Read(record, "UserId")
	if err == nil {
		return errors.New("invite list record already exists")
	}

	record = &models.InviteList{
		ParentId:       info.ParentId,
		UserId:         info.UserId,
		Username:       info.Username,
		PromoteName:    info.PromoteName,
		Sales:          info.Sales,
		TeamSales:      info.TeamSales,
		TodayTeamSales: info.TodayTeamSales,
		UserBv:         info.UserBv,
		SubStatus:      info.SubStatus,
		CTime:          info.CTime,
		IsYes:          info.IsYes,
	}

	_, err = models.AddInviteList(record)
	return err
}

// UpdateInviteList updates an existing invite list record
func (s *InviteListDirService) UpdateInviteList(info *InviteListInfo) error {
	if info.UserId == "" {
		return errors.New("user_id is required")
	}

	o := orm.NewOrm()
	record := &models.InviteList{UserId: info.UserId}
	err := o.Read(record, "UserId")
	if err != nil {
		if err == orm.ErrNoRows {
			return errors.New("invite list record not found")
		}
		return err
	}

	// Update fields
	record.ParentId = info.ParentId
	record.Username = info.Username
	record.PromoteName = info.PromoteName
	record.Sales = info.Sales
	record.TeamSales = info.TeamSales
	record.TodayTeamSales = info.TodayTeamSales
	record.UserBv = info.UserBv
	record.SubStatus = info.SubStatus
	record.CTime = info.CTime
	record.IsYes = info.IsYes

	return models.UpdateInviteListById(record)
}

// GetAllInviteLists retrieves all invite list records with pagination
func (s *InviteListDirService) GetAllInviteLists(offset, limit int64) ([]InviteListInfo, int64, error) {
	query := make(map[string]string)
	fields := []string{"InviteListDirId", "ParentId", "UserId", "Username", "PromoteName", "Sales", "TeamSales", "TodayTeamSales", "UserBv", "SubStatus", "CTime", "IsYes"}
	sortby := []string{"InviteListDirId"}
	order := []string{"desc"}

	ml, err := models.GetAllInviteList(query, fields, sortby, order, offset, limit)
	if err != nil {
		return nil, 0, err
	}

	result := make([]InviteListInfo, 0, len(ml))
	for _, item := range ml {
		if record, ok := item.(models.InviteList); ok {
			result = append(result, InviteListInfo{
				InviteListDirId: record.InviteListDirId,
				ParentId:        record.ParentId,
				UserId:          record.UserId,
				Username:        record.Username,
				PromoteName:     record.PromoteName,
				Sales:           record.Sales,
				TeamSales:       record.TeamSales,
				TodayTeamSales:  record.TodayTeamSales,
				UserBv:          record.UserBv,
				SubStatus:       record.SubStatus,
				CTime:           record.CTime,
				IsYes:           record.IsYes,
			})
		}
	}

	// Get total count
	o := orm.NewOrm()
	count, err := o.QueryTable(new(models.InviteList)).Count()
	if err != nil {
		return result, 0, err
	}

	return result, count, nil
}

// DeleteInviteList deletes an invite list record by user_id
func (s *InviteListDirService) DeleteInviteList(userId string) error {
	if userId == "" {
		return errors.New("user_id is required")
	}

	o := orm.NewOrm()
	record := &models.InviteList{UserId: userId}
	err := o.Read(record, "UserId")
	if err != nil {
		if err == orm.ErrNoRows {
			return errors.New("invite list record not found")
		}
		return err
	}

	return models.DeleteInviteList(record.InviteListDirId)
}

// 从 map 中安全获取 string 值
func getString(m map[string]interface{}, key string) string {
	if v, ok := m[key]; ok {
		if s, ok := v.(string); ok {
			return s
		}
	}
	return ""
}

// 从 map 中安全获取 int 值（兼容 float64）
func getInt(m map[string]interface{}, key string) int {
	if v, ok := m[key]; ok {
		switch val := v.(type) {
		case int:
			return val
		case float64:
			return int(val)
		case int64:
			return int(val)
		}
	}
	return 0
}

// 从 map 中安全获取 int64 值（兼容 float64）
func getInt64(m map[string]interface{}, key string) int64 {
	if v, ok := m[key]; ok {
		switch val := v.(type) {
		case int64:
			return val
		case float64:
			return int64(val)
		case int:
			return int64(val)
		}
	}
	return 0
}