tmrgo/service/group/group.go

package group

import (
	"encoding/json"
	"fmt"
	"sort"
	"strings"
	"time"
	"tmr-watch/models"
	"tmr-watch/module"
	"tmr-watch/pkg/util"
)

// DistributeFeedFormulaService 饲料配方下发牧场端
func DistributeFeedFormulaService(req *models.PastureBodyRequest) error {
	if len(req.Body) <= 0 {
		return nil
	}

	feedTemplateList := make([]*models.FeedTemplate, 0)
	for _, b := range req.Body {
		feedTemplateList = append(feedTemplateList, &models.FeedTemplate{
			PastureId:    req.PastureId,
			TCode:        b.EncodeNumber,
			TName:        b.Name,
			TColor:       b.Colour,
			CCid:         int64(b.CattleCategoryId),
			CCName:       b.CattleCategoryName,
			FTType:       b.FormulaTypeName,
			FTTypeId:     b.FormulaTypeId,
			Source:       "集团下发",
			Remark:       b.Remarks,
			Enable:       1,
			Version:      b.Version,
			SaveTime:     time.Now().Format("2006-01-02 15:04:05"),
			IsIssue:      0,
			IssueVersion: 0,
			IssueId:      0,
			IsModify:     b.IsModify,
		})
	}
	return module.DistributeFeedFormula(feedTemplateList)
}

func FeedFormulaIsModifyService(req *models.PastureFeedFormulaIsModifyRequest) error {
	return module.FeedFormulaIsModify(req)
}

// AnalysisAccuracyService 首页准确率分析
func AnalysisAccuracyService(req *models.AnalysisAccuracyRequest) (*models.AnalysisAccuracyResponse, error) {
	response := &models.AnalysisAccuracyResponse{
		MixedFodderAccurateRatio:    make([]*models.PastureAnalysisAccuracyDataValue, 0),
		MixedFodderCorrectRatio:     make([]*models.PastureAnalysisAccuracyDataValue, 0),
		SprinkleFodderAccurateRatio: make([]*models.PastureAnalysisAccuracyDataValue, 0),
		SprinkleFodderCorrectRatio:  make([]*models.PastureAnalysisAccuracyDataValue, 0),
	}

	// 混料准确率
	mixedFodderDataList, err := module.MixedFodderData(req)
	if err != nil {
		return nil, err
	}

	// 撒料准确率
	sprinkleFodderDataList, err := module.SprinkleFodderData(req)
	if err != nil {
		return nil, err
	}
	// 混料正确率
	mixedFodderCorrectDataList, err := module.MixedFodderCorrectData(req)
	if err != nil {
		return nil, err
	}

	// 撒料正确率
	sprinkleFodderCorrectDataList, err := module.SprinkleFodderCorrectData(req)

	a, _ := json.Marshal(mixedFodderCorrectDataList)
	fmt.Println("====mixedFodderCorrectDataList===", string(a))
	b, _ := json.Marshal(sprinkleFodderCorrectDataList)
	fmt.Println("====mixedFodderCorrectDataList===", string(b))

	timeList := util.TimeBetween(req.StartDate, req.EndDate)
	for _, dayTime := range timeList {
		var mixedInfo, sprinkleInfo, mixedCorrectInfo, sprinkleCorrectInfo bool
		for _, mixed := range mixedFodderDataList {
			myDate := mixed.Date.Format(util.LayoutDateFormat)
			if myDate != dayTime {
				continue
			}
			// 混料准确率
			var mixedFodderAccurateRatio float64 = 0
			if mixed.Lweight > 0 && mixed.ActualWeightMinus > 0 {
				if mixed.Lweight > mixed.ActualWeightMinus {
					mixedFodderAccurateRatio = mixed.ActualWeightMinus / mixed.Lweight * 100
				} else {
					mixedFodderAccurateRatio = mixed.Lweight / mixed.ActualWeightMinus * 100
				}
			}
			mixedValue := &models.PastureAnalysisAccuracyDataValue{
				DayTime: dayTime,
				Ratio:   mixedFodderAccurateRatio,
			}
			response.MixedFodderAccurateRatio = append(response.MixedFodderAccurateRatio, mixedValue)
			mixedInfo = true
		}
		if !mixedInfo {
			noInfo := &models.PastureAnalysisAccuracyDataValue{
				DayTime: dayTime,
				Ratio:   0,
			}
			response.MixedFodderAccurateRatio = append(response.MixedFodderAccurateRatio, noInfo)
		}

		for _, sprinkle := range sprinkleFodderDataList {
			myDate := sprinkle.Date.Format(util.LayoutDateFormat)
			if myDate != dayTime {
				continue
			}
			// 撒料准确率
			var sprinkleFodderAccurateRatio float64 = 0
			if sprinkle.Lweight > 0 && sprinkle.ActualWeightMinus > 0 {
				if sprinkle.Lweight > sprinkle.ActualWeightMinus {
					sprinkleFodderAccurateRatio = sprinkle.ActualWeightMinus / sprinkle.Lweight * 100
				} else {
					sprinkleFodderAccurateRatio = sprinkle.Lweight / sprinkle.ActualWeightMinus * 100
				}
			}
			sprinkleValue := &models.PastureAnalysisAccuracyDataValue{
				DayTime: dayTime,
				Ratio:   sprinkleFodderAccurateRatio,
			}
			response.SprinkleFodderAccurateRatio = append(response.SprinkleFodderAccurateRatio, sprinkleValue)
			sprinkleInfo = true
		}
		if !sprinkleInfo {
			noInfo := &models.PastureAnalysisAccuracyDataValue{
				DayTime: dayTime,
				Ratio:   0,
			}
			response.SprinkleFodderAccurateRatio = append(response.SprinkleFodderAccurateRatio, noInfo)
		}

		for _, mixedFodder := range mixedFodderCorrectDataList {
			myDate := strings.ReplaceAll(mixedFodder.Date, "T00:00:00+08:00", "")
			if myDate != dayTime {
				continue
			}

			if mixedFodder.MixedCorrectNumber == 0 || mixedFodder.UseMixedFodderOptionNumber == 0 {
				response.MixedFodderCorrectRatio = append(response.MixedFodderCorrectRatio, &models.PastureAnalysisAccuracyDataValue{
					DayTime: dayTime,
					Ratio:   0,
				})
			} else {
				response.MixedFodderCorrectRatio = append(response.MixedFodderCorrectRatio, &models.PastureAnalysisAccuracyDataValue{
					DayTime: dayTime,
					Ratio:   float64(mixedFodder.MixedCorrectNumber) / float64(mixedFodder.UseMixedFodderOptionNumber) * 100,
				})
			}
			mixedCorrectInfo = true
		}
		if !mixedCorrectInfo {
			response.MixedFodderCorrectRatio = append(response.MixedFodderCorrectRatio, &models.PastureAnalysisAccuracyDataValue{
				DayTime: dayTime,
				Ratio:   0,
			})
		}

		for _, sprinkle := range sprinkleFodderCorrectDataList {
			myDateStr, _ := time.ParseInLocation(time.RFC3339, sprinkle.Date, time.Local)
			myDate := myDateStr.Format("2006-01-02")
			if myDate != dayTime {
				continue
			}

			if sprinkle.SprinkleCorrectNumber == 0 || sprinkle.UseSprinkleOptionNumber == 0 {
				fmt.Println("====UseSprinkleOptionNumber=001==")
				fmt.Println("====SprinkleCorrectNumber===", sprinkle.SprinkleCorrectNumber)
				fmt.Println("====UseSprinkleOptionNumber===", sprinkle.UseSprinkleOptionNumber)
				response.SprinkleFodderCorrectRatio = append(response.SprinkleFodderCorrectRatio, &models.PastureAnalysisAccuracyDataValue{
					DayTime: dayTime,
					Ratio:   0,
				})
			} else {
				fmt.Println("====UseSprinkleOptionNumber=002==")
				fmt.Println("====SprinkleCorrectNumber===", sprinkle.SprinkleCorrectNumber)
				fmt.Println("====UseSprinkleOptionNumber===", sprinkle.UseSprinkleOptionNumber)
				response.SprinkleFodderCorrectRatio = append(response.SprinkleFodderCorrectRatio, &models.PastureAnalysisAccuracyDataValue{
					DayTime: dayTime,
					Ratio:   float64(sprinkle.SprinkleCorrectNumber) / float64(sprinkle.UseSprinkleOptionNumber) * 100,
				})
			}
			sprinkleCorrectInfo = true
		}
		if !sprinkleCorrectInfo {
			response.SprinkleFodderCorrectRatio = append(response.SprinkleFodderCorrectRatio, &models.PastureAnalysisAccuracyDataValue{
				DayTime: dayTime,
				Ratio:   0,
			})
		}
	}

	return response, nil
}

// ProcessAnalysisService 过程分析
func ProcessAnalysisService(req *models.AnalysisAccuracyRequest) (*models.ProcessAnalysisResponse, error) {
	response := &models.ProcessAnalysisResponse{
		AddFeedTime:  &models.ProcessAnalysisDataValue{},
		SprinkleTime: &models.ProcessAnalysisDataValue{},
		StirTime:     &models.ProcessAnalysisDataValue{},
	}

	processDataList, err := module.ProcessAnalysisData(req)
	if err != nil {
		return nil, err
	}

	addFeedList := make([]int, 0)
	sprinkleFeedList := make([]int, 0)
	stirDelayList := make([]int, 0)
	for _, v := range processDataList {
		addFeedList = append(addFeedList, util.TimeParseToMinutes(v.ExecProcessTime))
		sprinkleFeedList = append(sprinkleFeedList, util.TimeParseToMinutes(v.L2ProcessTime))
		stirDelayList = append(stirDelayList, v.ExecStirDelay)
	}

	if len(addFeedList) > 0 {
		sort.Ints(addFeedList)
		response.AddFeedTime.MaxValue = fmt.Sprintf("%.2f", float64(addFeedList[len(addFeedList)-1])/60)
		response.AddFeedTime.UpMiddleValue = fmt.Sprintf("%.2f", util.Median(addFeedList[len(addFeedList)/2+1:])/60)
		response.AddFeedTime.MiddleValue = fmt.Sprintf("%.2f", util.Median(addFeedList)/60)
		response.AddFeedTime.DownMiddleValue = fmt.Sprintf("%.2f", util.Median(addFeedList[0:len(addFeedList)/2])/60)
		response.AddFeedTime.MinValue = fmt.Sprintf("%.2f", float64(addFeedList[0])/60)
	}

	if len(sprinkleFeedList) > 0 {
		sort.Ints(sprinkleFeedList)
		response.SprinkleTime.MaxValue = fmt.Sprintf("%.2f", float64(sprinkleFeedList[len(sprinkleFeedList)-1])/60)
		response.SprinkleTime.UpMiddleValue = fmt.Sprintf("%.2f", util.Median(sprinkleFeedList[len(sprinkleFeedList)/2+1:])/60)
		response.SprinkleTime.MiddleValue = fmt.Sprintf("%.2f", util.Median(sprinkleFeedList)/60)
		response.SprinkleTime.DownMiddleValue = fmt.Sprintf("%.2f", util.Median(sprinkleFeedList[0:len(sprinkleFeedList)/2])/60)
		response.SprinkleTime.MinValue = fmt.Sprintf("%.2f", float64(sprinkleFeedList[0])/60)
	}

	if len(stirDelayList) > 0 {
		sort.Ints(stirDelayList)
		response.StirTime.MaxValue = fmt.Sprintf("%d", stirDelayList[len(stirDelayList)-1])
		response.StirTime.UpMiddleValue = fmt.Sprintf("%.2f", util.Median(stirDelayList[len(stirDelayList)/2+1:]))
		response.StirTime.MiddleValue = fmt.Sprintf("%.2f", util.Median(stirDelayList))
		response.StirTime.DownMiddleValue = fmt.Sprintf("%.2f", util.Median(stirDelayList[0:len(stirDelayList)/2]))
		response.StirTime.MinValue = fmt.Sprintf("%d", stirDelayList[0])
	}
	return response, nil
}

// SprinkleStatisticsService 撒料统计
func SprinkleStatisticsService(req *models.SprinkleStatisticsRequest) ([]*models.SprinkleStatisticsDataList, error) {
	sprinkleDataList, err := module.SprinkleStatistics(req)
	if err != nil {
		return nil, err
	}
	return sprinkleDataList, nil
}

func AccountDistributionService(req *models.AccountDistributionRequest) error {
	return module.AccountDistribution(req)
}

func ForageCategoryDistributeService(req *models.CategoryRequest) error {
	feedClass := &models.FeedClass{
		PastureId:        int64(req.PastureId),
		FCCode:           req.Number,
		FCName:           req.Name,
		Enable:           req.IsShow,
		BigFeedClassId:   req.ParentId,
		BigFeedClassName: req.ParentName,
		GroupId:          int64(req.GroupId),
	}
	return module.ForageCategoryDistribute(feedClass)
}

func CattleCategoryDistributeService(req *models.CategoryRequest) error {
	cowClass := &models.CowClass{
		PastureId:  int64(req.PastureId),
		ClassCode:  req.Number,
		ClassName:  req.Name,
		Enable:     req.IsShow,
		ParentId:   req.ParentId,
		ParentName: req.ParentName,
		GroupId:    int64(req.GroupId),
	}
	return module.CattleCategoryDistribute(cowClass)
}

func CategoryDeleteService(keyWord string, req *models.CategoryDeleteRequest) error {
	switch keyWord {
	case "feed_delete":
		return module.ForageCategoryDelete(int64(req.PastureId), int64(req.GroupId))
	case "cow_delete":
		return module.CowCategoryDelete(int64(req.PastureId), int64(req.GroupId))
	}
	return nil
}