kpt-tmr-group/module/backend/pasture_sync_service.go

package backend

import (
	"context"
	"errors"
	"kpt-tmr-group/model"
	"kpt-tmr-group/pkg/xerr"
	operationPb "kpt-tmr-group/proto/go/backend/operation"
	"math"
	"net/http"

	"gorm.io/gorm"
)

const (
	FeedCategory       = "feed"
	FeedCategoryDelete = "feed_delete"
	CowCategory        = "cow"
	CowCategoryDelete  = "cow_delete"
)

func (s *StoreEntry) CategorySyncData(ctx context.Context, req *operationPb.CategorySyncRequest) error {
	pastureDetail, err := s.GetGroupPastureListById(ctx, int64(req.PastureId))
	if err != nil {
		return xerr.WithStack(err)
	}
	switch req.KeyWord {
	case FeedCategory:
		history := &model.ForageCategory{}
		if err = s.DB.Model(new(model.ForageCategory)).
			Where("pasture_id = ?", req.PastureId).
			Where("data_id = ?", req.Id).
			Where("data_source = ? ", operationPb.DataSource_FROM_PASTURE).
			First(history).Error; err != nil {
			if !errors.Is(err, gorm.ErrRecordNotFound) {
				return xerr.WithStack(err)
			}
		}
		if history.IsShow == operationPb.IsShow_OK && history.Id > 0 {
			if err = s.DB.Model(new(model.ForageCategory)).Where("id = ?", history.Id).Updates(map[string]interface{}{
				"number":      req.Number,
				"is_show":     req.IsShow,
				"parent_id":   req.ParentId,
				"parent_name": req.ParentName,
				"name":        req.Name,
			}).Error; err != nil {
				return xerr.WithStack(err)
			}
		}

		newFeedData := model.NewPastureForageCategory(req, pastureDetail)
		if err = s.DB.Model(new(model.ForageCategory)).Create(newFeedData).Error; err != nil {
			return xerr.WithStack(err)
		}
	case CowCategory:
		history := &model.CattleCategory{}
		if err = s.DB.Model(new(model.CattleCategory)).
			Where("pasture_id = ?", req.PastureId).
			Where("data_id = ?", req.Id).
			Where("data_source = ? ", operationPb.DataSource_FROM_PASTURE).
			First(history).Error; err != nil {
			if !errors.Is(err, gorm.ErrRecordNotFound) {
				return xerr.WithStack(err)
			}
		}
		if history.IsShow == operationPb.IsShow_OK && history.Id > 0 {
			if err = s.DB.Model(new(model.CattleCategory)).Where("id = ?", history.Id).Updates(map[string]interface{}{
				"number":      req.Number,
				"is_show":     req.IsShow,
				"parent_id":   req.ParentId,
				"parent_name": req.ParentName,
				"name":        req.Name,
			}).Error; err != nil {
				return xerr.WithStack(err)
			}
		}
		newCattleData := model.NewPastureCattleCategory(req, pastureDetail)
		if err = s.DB.Model(new(model.CattleCategory)).Create(newCattleData).Error; err != nil {
			return xerr.WithStack(err)
		}
	}

	return nil
}

func (s *StoreEntry) CategoryDeleteData(ctx context.Context, req *operationPb.CategoryDeleteRequest) error {
	var modelValue interface{}
	switch req.KeyWord {
	case FeedCategoryDelete:
		modelValue = new(model.ForageCategory)
	case CowCategoryDelete:
		modelValue = new(model.CattleCategory)
	}
	if modelValue == nil {
		return nil
	}

	if err := s.DB.Model(modelValue).Where("data_id = ?", req.DataId).
		Where("pasture_id = ?", req.PastureId).Where("data_source = ?", operationPb.DataSource_FROM_PASTURE).
		Updates(map[string]interface{}{
			"is_delete": operationPb.IsShow_OK,
		}).Error; err != nil {
		return xerr.WithStack(err)
	}
	return nil
}

func (s *StoreEntry) FeedFormulaSyncData(ctx context.Context, req *operationPb.FeedFormulaSyncRequest) error {
	groupPastureList, err := s.DataSyncGroupPastureList(ctx)
	if err != nil {
		return xerr.WithStack(err)
	}

	var (
		ok           bool
		groupPasture *model.GroupPasture
	)
	for _, pastureDetail := range groupPastureList {
		if pastureDetail.Id != int64(req.PastureId) {
			continue
		}
		groupPasture = pastureDetail
		ok = true
	}

	if ok {
		total := 0
		page := 1
		pageSize := 100
		for i := 0; i <= total; i++ {
			body := &model.FeedFormulaListRequest{
				PastureId: req.PastureId,
				Page:      int32(page),
				PageSize:  int32(pageSize),
			}
			response := &model.FeedFormulaListResponse{}
			if _, err = s.PastureHttpClient(ctx, model.FeedFormulaListAsyncUrl, int64(req.PastureId), body, response); err != nil {
				return xerr.WithStack(err)
			}

			if response.Code != http.StatusOK {
				return xerr.Customf("%s", response.Msg)
			}
			if response.Data.Total > 0 {
				total = int(math.Ceil(float64(response.Data.Total) / float64(pageSize)))
			}

			if err = s.FeedFormulaInsert(ctx, groupPasture, response.Data.List); err != nil {
				return xerr.WithStack(err)
			}

		}

	}
	return nil
}

func (s *StoreEntry) FeedFormulaInsert(ctx context.Context, groupPasture *model.GroupPasture, list []*model.FeedTemplate) error {
	res := make([]*model.FeedFormula, 0)
	for _, data := range list {
		res = append(res, &model.FeedFormula{
			Name:               data.TName,
			Colour:             data.TColor,
			EncodeNumber:       data.TCode,
			CattleCategoryId:   operationPb.CattleCategoryParent_Kind(data.CCid),
			CattleCategoryName: data.CCName,
			FormulaTypeId:      data.FTTypeId,
			FormulaTypeName:    data.FTType,
			DataSourceId:       operationPb.DataSource_FROM_PASTURE,
			DataSourceName:     "牧场同步",
			Remarks:            data.Remark,
			Version:            data.Version,
			PastureId:          groupPasture.PastureId,
			PastureName:        groupPasture.Name,
			IsShow:             operationPb.IsShow_Kind(data.Enable),
			IsModify:           operationPb.IsShow_Kind(data.IsModify),
			IsDelete:           operationPb.IsShow_OK,
		})
	}
	if err := s.DB.Model(new(model.FeedFormula)).Create(res).Error; err != nil {
		return xerr.WithStack(err)
	}
	return nil
}