kami_gateway/internal/models/road/road_info.go

package road

import (
	"context"
	"gateway/internal/otelTrace"

	"time"

	"github.com/beego/beego/v2/client/orm"
	"go.uber.org/zap"
)

type RoadInfo struct {
	Id              int
	Status          string
	RoadName        string
	RoadUid         string
	Remark          string
	ProductName     string
	ProductUid      string
	PayType         string
	BasicFee        float64
	SettleFee       float64
	TotalLimit      float64
	TodayLimit      float64
	SingleMinLimit  float64
	SingleMaxLimit  float64
	StarHour        int
	EndHour         int
	Params          string
	TodayIncome     float64
	TotalIncome     float64
	TodayProfit     float64
	TotalProfit     float64
	Balance         float64
	RequestAll      int
	RequestSuccess  int
	TransactionType string

	TodayRequestAll     int `json:"TodayRequestAll"`
	TodayRequestSuccess int

	ProductCode string

	CreateTime time.Time
	UpdateTime time.Time

	PaymentHtml string
}

const ROAD_INFO = "road_info"

func GetRoadInfoByRoadUid(ctx context.Context, roadUid string) RoadInfo {
	o := orm.NewOrm()
	var roadInfo RoadInfo
	_, err := o.QueryTable(ROAD_INFO).Exclude("status", "delete").Filter("road_uid", roadUid).Limit(1).All(&roadInfo)
	if err != nil {
		otelTrace.Logger.WithContext(ctx).Error("get road info by road uid fail: ", zap.Error(err))
	}
	return roadInfo
}

func GetRoadInfoByProductCode(ctx context.Context, productCode string) RoadInfo {
	o := orm.NewOrm()
	var roadInfo RoadInfo
	err := o.QueryTable(ROAD_INFO).Exclude("status", "delete").
		Filter("product_code", productCode).
		One(&roadInfo)
	if err != nil {
		otelTrace.Logger.WithContext(ctx).Error("get road info by road uid fail: ", zap.Error(err))
	}
	return roadInfo
}

func GetRoadInfosByRoadUids(ctx context.Context, roadUids []string) []RoadInfo {
	o := orm.NewOrm()
	var roadInfoList []RoadInfo
	_, err := o.QueryTable(ROAD_INFO).Filter("road_uid__in", roadUids).OrderBy("update_time").All(&roadInfoList)
	if err != nil {
		otelTrace.Logger.WithContext(ctx).Error("get roadInfos by roadUids fail: ", zap.Error(err))
	}
	return roadInfoList
}

func GetRoadInfoByName(ctx context.Context, roadName string) RoadInfo {
	o := orm.NewOrm()
	var roadInfo RoadInfo
	_, err := o.QueryTable(ROAD_INFO).Exclude("status", "delete").Filter("road_name", roadName).Limit(1).All(&roadInfo)
	if err != nil {
		otelTrace.Logger.WithContext(ctx).Error("get road info by name fail: ", zap.Error(err))
	}
	return roadInfo
}

func GetRoadLenByMap(ctx context.Context, params map[string]string) int {
	o := orm.NewOrm()
	qs := o.QueryTable(ROAD_INFO)
	for k, v := range params {
		if len(v) > 0 {
			qs = qs.Filter(k, v)
		}
	}
	cnt, err := qs.Exclude("status", "delete").Limit(-1).Count()
	if err != nil {
		otelTrace.Logger.WithContext(ctx).Error("get road len by map fail: ", zap.Error(err))
	}
	return int(cnt)
}

func GetRoadInfoByMap(ctx context.Context, params map[string]string, displayCount, offset int) []RoadInfo {
	o := orm.NewOrm()
	var roadInfoList []RoadInfo
	qs := o.QueryTable(ROAD_INFO)
	for k, v := range params {
		if len(v) > 0 {
			qs = qs.Filter(k, v)
		}
	}

	_, err := qs.Exclude("status", "delete").Limit(displayCount, offset).OrderBy("-update_time").All(&roadInfoList)
	if err != nil {
		otelTrace.Logger.WithContext(ctx).Error("get road info by map fail: ", zap.Error(err))
	}
	return roadInfoList
}

func GetAllRoad(ctx context.Context, params map[string]string) []RoadInfo {
	o := orm.NewOrm()
	var roadInfoList []RoadInfo
	qs := o.QueryTable(ROAD_INFO)
	for k, v := range params {
		if len(v) > 0 {
			qs = qs.Filter(k, v)
		}
	}
	_, err := qs.Limit(-1).All(&roadInfoList)
	if err != nil {
		otelTrace.Logger.WithContext(ctx).Error("get all road fail: ", zap.Error(err))
	}
	return roadInfoList
}

func InsertRoadInfo(ctx context.Context, roadInfo RoadInfo) bool {
	o := orm.NewOrm()
	_, err := o.Insert(&roadInfo)
	if err != nil {
		otelTrace.Logger.WithContext(ctx).Error("insert road info fail: ", zap.Error(err))
		return false
	}
	return true
}

func RoadInfoExistByRoadUid(roadUid string) bool {
	o := orm.NewOrm()
	exist := o.QueryTable(ROAD_INFO).Filter("status", "active").Filter("road_uid", roadUid).Exist()

	return exist
}

func UpdateRoadInfo(ctx context.Context, roadInfo RoadInfo) bool {
	o := orm.NewOrm()
	_, err := o.Update(&roadInfo)
	if err != nil {
		otelTrace.Logger.WithContext(ctx).Error("update road info fail: ", zap.Error(err))
		return false
	}
	return true
}

func DeleteRoadByRoadUid(ctx context.Context, roadUid string) bool {
	o := orm.NewOrm()
	_, err := o.QueryTable(ROAD_INFO).Filter("road_uid", roadUid).Delete()
	if err != nil {
		otelTrace.Logger.WithContext(ctx).Error("delete road by road uid fail: ", zap.Error(err))
		return false
	}
	return true
}