saasapi/cmd/saastool/exp_get.go

package main

import (
	"flag"
	"fmt"
	"net/http"
	"slices"
	"strconv"
	"strings"

	"git.algo.com.cn/public/saasapi"
	"git.algo.com.cn/public/saasapi/pkg/saashttp"
	"google.golang.org/protobuf/encoding/protojson"
)

type getExpParams struct {
	saasHttp      *saashttp.SaasClient
	bucketIDs     []uint32
	beginDay      uint64
	endDay        uint64
	target        string
	advertiserIDs []uint64
	groupBy       []string
	totalFlag     bool
	extFields     []string
}

func RunExpGet(args ...string) error {
	fs := flag.NewFlagSet("get", flag.ExitOnError)
	cfgFile := paramConfig(fs)
	beginDay := paramWhereBeginDay(fs)
	endDay := paramWhereEndDay(fs)
	bucketIDs := paramWhereBucketIds(fs)
	target := paramWhereTarget(fs)
	advertiserIDs := paramWhereAdvertiserId(fs)
	groupBy := paramGroupBy(fs)
	totalFlag := paramTotalFlag(fs)
	extFields := paramExtFields(fs)

	if err := fs.Parse(args); err != nil {
		return fmt.Errorf("Command line parse error: %w", err)
	}

	if fs.NArg() > 0 {
		fs.PrintDefaults()
		return nil
	}

	bucketIDsNumSlice := []uint32{}
	if *bucketIDs != "" {
		expIDsSlice := strings.Split(*bucketIDs, ",")
		for _, id := range expIDsSlice {
			idNum, err := strconv.ParseUint(id, 10, 32)
			if err != nil {
				return fmt.Errorf("Expid parse error. value: %v. %w", id, err)
			}

			if idNum == 0 || idNum > 10 {
				return fmt.Errorf("Expid range error.")
			}
			bucketIDsNumSlice = append(bucketIDsNumSlice, uint32(idNum))
		}
	}

	if *beginDay < 20250101 || *beginDay > 21001231 || *endDay < 20250101 || *endDay > 21001231 {
		fs.PrintDefaults()
		return fmt.Errorf("Begin/End day error.")
	}

	if *target == "" {
		fs.PrintDefaults()
		return fmt.Errorf("Target error.")
	}

	uidNumSlice := []uint64{}
	if *advertiserIDs != "" {
		uidSlice := strings.Split(*advertiserIDs, ",")
		for _, id := range uidSlice {
			idNum, err := strconv.ParseUint(id, 10, 64)
			if err != nil {
				return fmt.Errorf("Advertiser id parse error. value: %v. %w", id, err)
			}

			if idNum == 0 {
				return fmt.Errorf("Advertiser id error.")
			}
			uidNumSlice = append(uidNumSlice, idNum)
		}
	}

	groupBySlice := []string{}
	if *groupBy != "" {
		validGroupBy := map[string]bool{"advertiser_id": true, "user_weight_factor": true}
		groupBySlice = strings.Split(*groupBy, ",")
		for _, group := range groupBySlice {
			if !validGroupBy[group] {
				return fmt.Errorf("Group by error. group: %v", group)
			}
		}
	}

	extFieldsSlice := []string{}
	if *extFields != "" {
		extFieldsSlice = strings.Split(*extFields, ",")
		if slices.Contains(extFieldsSlice, "") {
			return fmt.Errorf("Ext field error.")
		}
	}

	cfg, err := LoadConfigFile(*cfgFile)
	if err != nil {
		return fmt.Errorf("LoadConfigFile error: %w", err)
	}

	getExpParams := getExpParams{
		saasHttp: &saashttp.SaasClient{
			Client:  &http.Client{},
			ApiUrls: saashttp.InitAPIUrl(&cfg.ApiUrls),
			Auth:    &cfg.Auth,
		},
		bucketIDs:     bucketIDsNumSlice,
		beginDay:      *beginDay,
		endDay:        *endDay,
		target:        *target,
		advertiserIDs: uidNumSlice,
		groupBy:       groupBySlice,
		totalFlag:     *totalFlag,
		extFields:     extFieldsSlice,
	}
	return doExpGet(getExpParams)
}

func doExpGet(getExpParams getExpParams) error {

	totalFlag := uint32(0)
	if getExpParams.totalFlag {
		totalFlag = 1
	}

	saasReq := &saasapi.SaasReq{
		Cmd: &saasapi.SaasReq_ExpGet{
			ExpGet: &saasapi.ExpGet{
				WhereBucketId:     getExpParams.bucketIDs,
				WhereBeginDay:     getExpParams.beginDay,
				WhereEndDay:       getExpParams.endDay,
				WhereTarget:       getExpParams.target,
				WhereAdvertiserId: getExpParams.advertiserIDs,
				GroupBy:           getExpParams.groupBy,
				TotalFlag:         totalFlag,
				ExtFields:         getExpParams.extFields,
			},
		},
	}

	res, err := getExpParams.saasHttp.ExpGet(saasReq)
	if err != nil {
		return fmt.Errorf("Submit Command error: %w", err)
	}

	if res.Code != saasapi.ErrorCode_SUCC {
		return fmt.Errorf("Command failed. code:%v, status:%v", res.Code, res.Status)
	}

	getExpRes := res.GetExpGetRes()

	fmt.Printf("exp res: %v\n", protojson.Format(getExpRes))
	return nil
}