kpt-pasture/model/same_time.go

package model

import (
	"encoding/json"
	"sort"
	"strings"

	"gitee.com/xuyiping_admin/pkg/logger/zaplog"
	"go.uber.org/zap"

	pasturePb "gitee.com/xuyiping_admin/go_proto/proto/go/backend/cow"
)

const WeekTypeSeparator = "|"

type SameTime struct {
	Id                  int64                          `json:"id"`
	PastureId           int64                          `json:"pastureId"`
	Name                string                         `json:"name"`
	WeekType            string                         `json:"weekType"`
	CowType             pasturePb.SameTimeCowType_Kind `json:"cowType"`
	IsShow              pasturePb.IsShow_Kind          `json:"isShow"`
	PostpartumDaysStart int32                          `json:"postpartumDaysStart"`
	PostpartumDaysEnd   int32                          `json:"postpartumDaysEnd"`
	CollateNodes        string                         `json:"collateNodes"`
	Remarks             string                         `json:"remarks"`
	OperationId         int64                          `json:"operationId"`
	CreatedAt           int64                          `json:"createdAt"`
	UpdatedAt           int64                          `json:"updatedAt"`
}

func (e *SameTime) TableName() string {
	return "same_time"
}

func NewSameTime(pastureId int64, currentUser *SystemUser, req *pasturePb.SearchSameTimeList) *SameTime {
	var collateNodes []byte
	if len(req.CollateNodes) > 0 {
		collateNodes, _ = json.Marshal(req.CollateNodes)
	}
	weekType := ""
	if len(req.WeekType) > 0 {
		sort.Slice(req.WeekType, func(i, j int) bool {
			return req.WeekType[i] < req.WeekType[j]
		})

		for _, v := range req.WeekType {
			weekType += v.String() + WeekTypeSeparator
		}
	}
	if len(weekType) > 0 {
		weekType = weekType[:len(weekType)-1]
	}
	return &SameTime{
		PastureId:           pastureId,
		Name:                req.Name,
		WeekType:            weekType,
		CowType:             req.CowType,
		IsShow:              pasturePb.IsShow_Ok,
		PostpartumDaysStart: req.PostpartumDaysStart,
		PostpartumDaysEnd:   req.PostpartumDaysEnd,
		CollateNodes:        string(collateNodes),
		Remarks:             req.Remarks,
		OperationId:         currentUser.Id,
	}
}

type SameTimeSlice []*SameTime

func (e SameTimeSlice) ToPB(
	weekMap map[pasturePb.Week_Kind]string,
	sameTimeCowTypeMap map[pasturePb.SameTimeCowType_Kind]string,
	systemUserList []*SystemUser,
) []*pasturePb.SearchSameTimeList {
	res := make([]*pasturePb.SearchSameTimeList, len(e))
	for i, v := range e {
		operationName := ""
		for _, u := range systemUserList {
			if u.Id != v.OperationId {
				continue
			}
			operationName = u.Name
		}

		collectionNodes := make([]*pasturePb.CollateNode, 0)
		if err := json.Unmarshal([]byte(v.CollateNodes), &collectionNodes); err != nil {
			zaplog.Error("json.Unmarshal SameTimeSlice.ToPB error", zap.Any("err", err))
		}

		weekType := make([]pasturePb.Week_Kind, 0)
		weekName := ""
		for _, w := range strings.Split(v.WeekType, WeekTypeSeparator) {
			wt := pasturePb.Week_Kind(pasturePb.Week_Kind_value[w])
			weekType = append(weekType, wt)
			weekName += weekMap[wt] + WeekTypeSeparator
		}

		if len(weekName) > 0 {
			weekName = weekName[:len(weekName)-1]
		}

		res[i] = &pasturePb.SearchSameTimeList{
			Id:                  int32(v.Id),
			Name:                v.Name,
			WeekType:            weekType,
			WeekName:            weekName,
			CowType:             v.CowType,
			CowTypeName:         sameTimeCowTypeMap[v.CowType],
			IsShow:              v.IsShow,
			PostpartumDaysStart: v.PostpartumDaysStart,
			PostpartumDaysEnd:   v.PostpartumDaysEnd,
			CollateNodes:        collectionNodes,
			Remarks:             v.Remarks,
			OperationId:         int32(v.OperationId),
			OperationName:       operationName,
			CreatedAt:           int32(v.CreatedAt),
			UpdatedAt:           int32(v.UpdatedAt),
		}
	}
	return res
}