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

package backend

import (
	"context"
	"encoding/json"
	"fmt"
	"kpt-tmr-group/model"
	"kpt-tmr-group/pkg/logger/zaplog"
	"kpt-tmr-group/pkg/xerr"
	operationPb "kpt-tmr-group/proto/go/backend/operation"
	"net/http"
	"strconv"
	"strings"

	"go.uber.org/zap"
)

type PastureClientHandler func(ctx context.Context, pastureId int64, body interface{}) error

// type eventHandler func(ev map[string]interface{}, openID string, appID string, enterpriseID int, cts int64, conn redis.Conn) error

// PastureDetailById 获取指定牧场详情
func (s *StoreEntry) PastureDetailById(ctx context.Context, pastureId int64) (*model.GroupPasture, error) {
	result := &model.GroupPasture{Id: pastureId}
	if err := s.DB.Where("is_delete = ? and is_show = ?", operationPb.IsShow_OK, operationPb.IsShow_OK).First(result).Error; err != nil {
		return nil, xerr.WithStack(err)
	}
	return result, nil
}

func (s *StoreEntry) PastureHttpClient(ctx context.Context, apiUrl string, pastureId int64, body, response interface{}) error {
	pastureDetail, err := s.PastureDetailById(ctx, pastureId)
	if err != nil {
		zaplog.Error("SearchFormulaEstimateList", zap.Any("Err", err), zap.Int64("pastureId", pastureId))
		return xerr.Customf("该牧场数据错误,Err:%s", err)
	}

	pastureClient := model.NewPastureClient(pastureDetail)
	url := fmt.Sprintf("%s/%s", pastureDetail.Domain, apiUrl)

	result, err := pastureClient.DoPost(url, body)
	if err != nil {
		return xerr.WithStack(err)
	}

	zaplog.Info("PastureHttpClient", zap.String("url", url), zap.Any("request", body), zap.String("response", string(result)))
	if err = json.Unmarshal(result, response); err != nil {
		return xerr.WithStack(err)
	}
	return nil

}

// SearchFormulaEstimateList 配方评估
func (s *StoreEntry) SearchFormulaEstimateList(ctx context.Context, req *operationPb.SearchFormulaEstimateRequest) (*model.PastureCommonResponse, error) {
	body := &model.PastureCommonRequest{
		Name:       req.ApiName,
		Page:       req.Pagination.Page,
		Offset:     req.Pagination.PageOffset,
		PageCount:  req.Pagination.PageSize,
		ReturnType: "Map",
		ParamMaps: &model.FormulaEstimateParams{
			PastureId: fmt.Sprintf("%d", req.PastureId),
			StartTime: req.StartTime,
			StopTime:  req.EndTime,
			Search:    fmt.Sprintf("%d", req.SearchType),
			TempletId: fmt.Sprintf("%d", req.TemplateId),
			Barid:     fmt.Sprintf("%d", req.BarnId),
		},
	}
	response := &model.PastureCommonResponse{Data: &model.PastureCommonData{}}
	if err := s.PastureHttpClient(ctx, model.UrlDataByName, int64(req.PastureId), body, response); err != nil {
		return nil, xerr.WithStack(err)
	}
	return response, nil
}

// SearchInventoryStatistics 库存管理-库存统计
func (s *StoreEntry) SearchInventoryStatistics(ctx context.Context, req *operationPb.SearchInventoryStatisticsRequest) (*model.PastureCommonResponse, error) {
	body := &model.PastureCommonRequest{
		Name:       req.ApiName,
		Page:       req.Pagination.Page,
		Offset:     req.Pagination.PageOffset,
		PageCount:  req.Pagination.PageSize,
		ReturnType: "Map",
		ParamMaps: &model.InventoryStatisticsParams{
			PastureId: fmt.Sprintf("%d", req.PastureId),
			StartTime: req.StartTime,
			StopTime:  req.EndTime,
			FeedName:  req.FeedName,
		},
	}
	response := &model.PastureCommonResponse{
		Data: &model.PastureCommonData{
			List: make([]*model.InventoryStatisticsList, 0),
		},
	}
	if err := s.PastureHttpClient(ctx, model.UrlDataByName, int64(req.PastureId), body, response); err != nil {
		return nil, xerr.WithStack(err)
	}
	return response, nil
}

// SearchUserMaterialsStatistics 库存管理-用料分析
func (s *StoreEntry) SearchUserMaterialsStatistics(ctx context.Context, req *operationPb.SearchUserMaterialsStatisticsRequest) (*model.PastureCommonResponse, error) {
	body := &model.PastureCommonRequest{
		Name:       req.ApiName,
		Page:       req.Pagination.Page,
		Offset:     req.Pagination.PageOffset,
		PageCount:  req.Pagination.PageSize,
		ReturnType: "Map",
		Checked:    req.ErrorCheck,
		ParamMaps: &model.UserMaterialsStatisticsParams{
			PastureId: fmt.Sprintf("%d", req.PastureId),
			StartTime: req.StartTime,
			StopTime:  req.EndTime,
			FeedName:  req.FeedName,
			Typea:     fmt.Sprintf("%d", req.TypeCheck),
		},
	}
	response := &model.PastureCommonResponse{Data: &model.PastureCommonData{}}
	if err := s.PastureHttpClient(ctx, model.UrlReportForm, int64(req.PastureId), body, response); err != nil {
		return nil, xerr.WithStack(err)
	}
	return response, nil
}

// SearchPriceStatistics 库存管理-价格分析
func (s *StoreEntry) SearchPriceStatistics(ctx context.Context, req *operationPb.SearchPriceStatisticsRequest) (*model.PastureCommonResponse, error) {
	body := &model.PastureCommonRequest{
		Name:       req.ApiName,
		Page:       req.Pagination.Page,
		Offset:     req.Pagination.PageOffset,
		PageCount:  req.Pagination.PageSize,
		ReturnType: "Map",
		ParamMaps: &model.PriceStatisticsParams{
			PastureId: fmt.Sprintf("%d", req.PastureId),
			StartTime: req.StartTime,
			StopTime:  req.EndTime,
			FeedName:  req.FeedName,
		},
	}
	response := &model.PastureCommonResponse{Data: &model.PastureCommonData{}}
	if err := s.PastureHttpClient(ctx, model.UrlReportForm, int64(req.PastureId), body, response); err != nil {
		return nil, xerr.WithStack(err)
	}
	return response, nil
}

// SearchFeedStatistics 饲喂效率-效率统计
func (s *StoreEntry) SearchFeedStatistics(ctx context.Context, req *operationPb.SearchFeedStatisticsRequest) (*model.PastureCommonResponse, error) {
	body := &model.PastureCommonRequest{
		Name:       req.ApiName,
		Page:       req.Pagination.Page,
		Offset:     req.Pagination.PageOffset,
		PageCount:  req.Pagination.PageSize,
		ReturnType: "Map",
		ParamMaps: &model.FeedStatisticsParams{
			PastureId: fmt.Sprintf("%d", req.PastureId),
			StartTime: req.StartTime,
			StopTime:  req.StartTime,
			Date:      req.StartTime,
			FeedTName: req.FormulaTemplate,
			BarName:   req.BarnName,
			CowClass:  req.CattleCategoryName,
			Times:     fmt.Sprintf("%d", req.ClassNumber),
		},
	}
	response := &model.PastureCommonResponse{Data: &model.PastureCommonData{}}
	if err := s.PastureHttpClient(ctx, model.UrlDataByName, int64(req.PastureId), body, response); err != nil {
		return nil, xerr.WithStack(err)
	}
	return response, nil
}

// FeedChartStatistics 饲喂效率图表分析
func (s *StoreEntry) FeedChartStatistics(ctx context.Context, req *operationPb.FeedChartStatisticsRequest) (*model.PastureCommonResponse, error) {
	body := &model.FeedChartParams{
		ParamMaps: &model.ParamMaps{
			PastureId: fmt.Sprintf("%d", req.PastureId),
			StartTime: req.StartTime,
			StopTime:  req.StartTime,
			Status:    req.Status,
		},
	}
	url, ok := model.UrlChart[req.ApiType]
	if !ok {
		return nil, xerr.Customf("错误的接口类型:%s", req.ApiType)
	}
	response := &model.PastureCommonResponse{Data: &model.PastureCommonData{}}
	if err := s.PastureHttpClient(ctx, url, int64(req.PastureId), body, response); err != nil {
		return nil, xerr.WithStack(err)
	}
	return response, nil
}

// CowsAnalysis 饲喂效率-牛群评估
func (s *StoreEntry) CowsAnalysis(ctx context.Context, req *operationPb.CowsAnalysisRequest) (*model.PastureCommonResponse, error) {
	body := &model.PastureCommonRequest{
		Name:       req.ApiName,
		Page:       req.Pagination.Page,
		Offset:     req.Pagination.PageOffset,
		PageCount:  req.Pagination.PageSize,
		ReturnType: "Map",
		ParamMaps: &model.MixFeedStatisticsParams{
			PastureId: fmt.Sprintf("%d", req.PastureId),
			StartTime: req.StartTime,
			StopTime:  req.StartTime,
		},
	}
	response := &model.PastureCommonResponse{Data: &model.PastureCommonData{}}
	if err := s.PastureHttpClient(ctx, model.UrlDataByName, int64(req.PastureId), body, response); err != nil {
		return nil, xerr.WithStack(err)
	}
	return response, nil
}

// SearchAccuracyAggStatistics 准确性分析-汇总分析
func (s *StoreEntry) SearchAccuracyAggStatistics(ctx context.Context, req *operationPb.AccuracyAggStatisticsRequest) (*model.PastureCommonResponse, error) {
	body := &model.FeedChartParams{
		ParamMaps: &model.AccuracyAggParams{
			PastureId: fmt.Sprintf("%d", req.PastureId),
			StartTime: req.StartTime,
			StopTime:  req.EndTime,
			FName:     req.Fname,
			Sort:      req.Sort,
			Status:    req.Status,
			Times:     req.Times,
			Genre:     req.Genre,
			IsDate:    req.Isdate,
			Hlwc1:     req.Hlwc1,
			Hlwc2:     req.Hlwc2,
			Hlzq1:     req.Hlzq1,
			Hlzq2:     req.Hlzq2,
			Hlzql1:    req.Hlzql1,
			Hlzql2:    req.Hlzql2,
			Slwc1:     req.Slwc1,
			Slwc2:     req.Slwc2,
			Slzq1:     req.Slzq1,
			Slzq2:     req.Slzq2,
			Slzql1:    req.Slzql1,
			Slzql2:    req.Slzql2,
			Error:     req.IsError,
		},
	}
	response := &model.PastureCommonResponse{Data: &model.PastureCommonData{}}
	if err := s.PastureHttpClient(ctx, model.UrlSummary, int64(req.PastureId), body, response); err != nil {
		return nil, xerr.WithStack(err)
	}
	return response, nil
}

// SearchMixFeedStatistics 准确性分析-混料统计
func (s *StoreEntry) SearchMixFeedStatistics(ctx context.Context, req *operationPb.MixFeedStatisticsRequest) (*model.PastureCommonResponse, error) {
	times := ""
	if req.ClassNumber > 0 {
		times = fmt.Sprintf("%d", req.ClassNumber)
	}
	body := &model.PastureCommonRequest{
		Name:       req.ApiName,
		Page:       req.Pagination.Page,
		Offset:     req.Pagination.PageOffset,
		PageCount:  req.Pagination.PageSize,
		ReturnType: "Map",
		ParamMaps: &model.MixFeedStatisticsParams{
			PastureId:   fmt.Sprintf("%d", req.PastureId),
			StartTime:   req.StartTime,
			StopTime:    req.StartTime,
			TmrTName:    req.EquipmentName,
			ProjName:    req.TrainNumber,
			Times:       times,
			ButtonType:  req.ButtonType,
			TempletName: req.FormulationName,
			Isuse:       req.IsUse,
			Hlwc1:       req.Hlwc1,
			Hlwc2:       req.Hlwc2,
			Hlzq1:       req.Hlzq1,
			Hlzq2:       req.Hlzq2,
			Hlzql1:      req.Hlzql1,
			Hlzql2:      req.Hlzql2,
			Error:       req.IsError,
		},
	}
	response := &model.PastureCommonResponse{Data: &model.PastureCommonData{}}
	if err := s.PastureHttpClient(ctx, model.UrlDataByName, int64(req.PastureId), body, response); err != nil {
		return nil, xerr.WithStack(err)
	}
	return response, nil
}

// SearchSprinkleStatistics 准确性分析-撒料统计
func (s *StoreEntry) SearchSprinkleStatistics(ctx context.Context, req *operationPb.SprinkleStatisticsRequest) (*model.PastureCommonResponse, error) {
	times := ""
	if req.ClassNumber > 0 {
		times = fmt.Sprintf("%d", req.ClassNumber)
	}
	body := &model.PastureCommonRequest{
		Name:       req.ApiName,
		Page:       req.Pagination.Page,
		Offset:     req.Pagination.PageOffset,
		PageCount:  req.Pagination.PageSize,
		ReturnType: "Map",
		ParamMaps: &model.SprinkleStatisticsParams{
			PastureId:   fmt.Sprintf("%d", req.PastureId),
			StartTime:   req.StartTime,
			StopTime:    req.StartTime,
			TmrTName:    req.EquipmentName,
			ProjName:    req.TrainNumber,
			Times:       times,
			ButtonType:  req.ButtonType,
			TempletName: req.FormulationName,
			Isuse:       req.IsUse,
			Fname:       req.BarnName,
			Slwc1:       req.Slwc1,
			Slwc2:       req.Slwc2,
			Slzq2:       req.Slzq2,
			Slzq1:       req.Slzq1,
			Slzql1:      req.Slzql1,
			Slzql2:      req.Slzql2,
			Error:       req.IsError,
		},
	}
	response := &model.PastureCommonResponse{Data: &model.PastureCommonData{}}
	if err := s.PastureHttpClient(ctx, model.UrlDataByName, int64(req.PastureId), body, response); err != nil {
		return nil, xerr.WithStack(err)
	}
	return response, nil
}

// SearchProcessAnalysis 过程分析
func (s *StoreEntry) SearchProcessAnalysis(ctx context.Context, req *operationPb.ProcessAnalysisRequest) (*model.PastureCommonResponse, error) {
	body := &model.PastureCommonRequest{
		Name:       req.ApiName,
		Page:       req.Pagination.Page,
		Offset:     req.Pagination.PageOffset,
		PageCount:  req.Pagination.PageSize,
		ReturnType: "Map",
		ParamMaps: &model.ProcessAnalysisParams{
			PastureId:   fmt.Sprintf("%d", req.PastureId),
			StartTime:   req.StartTime,
			StopTime:    req.StartTime,
			TmrTName:    req.TmrName,
			IsCompleted: "",
			LpPlanType:  fmt.Sprintf("%d", req.PlanType),
			FClassId:    req.MixFeedType,
			Hlzq1:       req.Hlzq1,
			Hlzq2:       req.Hlzq2,
			Hlwc1:       req.Hlwc1,
			Hlwc2:       req.Hlwc2,
			Slwc1:       req.Slwc1,
			Slwc2:       req.Slwc2,
			Slzq2:       req.Slzq2,
			Slzq1:       req.Slzq1,
			Error:       req.ErrorRange,
		},
	}
	response := &model.PastureCommonResponse{Data: &model.PastureCommonData{}}
	if err := s.PastureHttpClient(ctx, model.UrlProcess, int64(req.PastureId), body, response); err != nil {
		return nil, xerr.WithStack(err)
	}
	return response, nil
}

func (s *StoreEntry) SearchAnalysisAccuracy(ctx context.Context, req *operationPb.SearchAnalysisAccuracyRequest) (*model.SearchAnalysisAccuracyResponse, error) {

	dataList := &model.CommonValueRatio{
		MaxValue:    "",
		MiddleValue: "",
		MinValue:    "",
		PastureName: make([]string, 0),
		DateDay:     make([]string, 0),
		DataList:    make([][]string, 0),
		PastureIds:  make([]int32, 0),
	}
	res := &model.SearchAnalysisAccuracyResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &model.AnalysisAccuracyData{
			Chart: &model.Chart{
				MixedFodderAccurateRatio:    dataList,
				MixedFodderCorrectRatio:     dataList,
				SprinkleFodderAccurateRatio: dataList,
				SprinkleFodderCorrectRatio:  dataList,
			},
			Table: &model.Table{
				TitleList: make([]*model.TableList, 0),
				DataList:  make([]*interface{}, 0),
			},
		},
	}
	res.Data.Table.TitleList = append(res.Data.Table.TitleList, &model.TableList{
		Name:  "title",
		Value: "牧场",
	})

	analysisAccuracy := make([]*model.OptionsAnalysisAccuracy, 0)
	pref := s.DB.Model(new(model.AnalysisAccuracy))
	if req.EndDate != "" && req.StartDate != "" {
		pref.Where("date_day BETWEEN ? AND ?", req.StartDate, req.EndDate)
	}

	if req.CattleParentCategoryId > 0 {
		pref.Where("cattle_parent_category_id = ?", req.CattleParentCategoryId)
	}
	if req.FeedFormulaId > 0 {
		pref.Where("feed_formula_id = ?", req.FeedFormulaId)
	}

	if len(req.PastureIds) > 0 {
		pref.Where("pasture_id IN ?", req.PastureIds)
	}

	if err := pref.Select("pasture_id,pasture_name,date_day,sum(iweight) as all_iweight,sum(lweight) as all_lweight,sum(oweight) as all_oweight,sum(actual_weight_minus) as all_actual_weight_minus,sum(allow_ratio) as all_allow_ratio,sum(alweight) as all_alweight").
		Group("pasture_id,pasture_name,date_day").Order("pasture_name,date_day").Find(&analysisAccuracy).Debug().Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	mixedFodderAccurateRatio := make([]float64, 0)
	mapPastureName := make(map[string]bool, 0)
	mapDateDay := make(map[string]bool, 0)
	mapRatio := make(map[string]bool, 0)
	tableList := make([]*model.TableList, 0)
	for k, v := range analysisAccuracy {
		if _, ok := mapPastureName[v.PastureName]; !ok {
			res.Data.Chart.MixedFodderAccurateRatio.PastureName = append(res.Data.Chart.MixedFodderAccurateRatio.PastureName, v.PastureName)
			res.Data.Chart.MixedFodderAccurateRatio.PastureIds = append(res.Data.Chart.MixedFodderAccurateRatio.PastureIds, int32(v.PastureId))
			mapPastureName[v.PastureName] = true
		}

		dataDayFormat := strings.TrimRight(v.DateDay, "T00:00:00+08:00")
		if _, ok := mapDateDay[v.DateDay]; !ok {
			res.Data.Chart.MixedFodderAccurateRatio.DateDay = append(res.Data.Chart.MixedFodderAccurateRatio.DateDay, dataDayFormat)
			mapDateDay[v.DateDay] = true
		}

		valueRatio1 := float64(v.AllIweight/v.AllLweight) / 100.0
		if _, ok := mapRatio[v.DateDay]; !ok {
			valueRatio := make([]string, 0)
			for _, a := range analysisAccuracy {
				if a.DateDay == v.DateDay {
					valueRatio = append(valueRatio, strconv.FormatFloat(float64(a.AllIweight/a.AllLweight)/100.0, 'f', 2, 64))
				}
			}
			res.Data.Chart.MixedFodderAccurateRatio.DataList = append(res.Data.Chart.MixedFodderAccurateRatio.DataList, valueRatio)
			mapRatio[v.DateDay] = true
			tableList = append(tableList, &model.TableList{
				Name:  fmt.Sprintf("date%d", k),
				Value: dataDayFormat,
			})
		}
		mixedFodderAccurateRatio = append(mixedFodderAccurateRatio, valueRatio1)
	}

	mixedFodderAccurateRatioMaxValue, mixedFodderAccurateRatioMiddleValue, mixedFodderAccurateRatioMinValue := calculateRatio(mixedFodderAccurateRatio)
	res.Data.Chart.MixedFodderAccurateRatio.MaxValue = strconv.FormatFloat(mixedFodderAccurateRatioMaxValue, 'f', 2, 64)
	res.Data.Chart.MixedFodderAccurateRatio.MiddleValue = strconv.FormatFloat(mixedFodderAccurateRatioMiddleValue, 'f', 2, 64)
	res.Data.Chart.MixedFodderAccurateRatio.MinValue = strconv.FormatFloat(mixedFodderAccurateRatioMinValue, 'f', 2, 64)

	res.Data.Table.TitleList = append(res.Data.Table.TitleList, tableList...)

	return res, nil
}

func calculateRatio(res []float64) (float64, float64, float64) {
	var maxValue, middleValue, minValue, allValue float64 = 0, 0, 0, 0
	for _, v := range res {
		if v > maxValue {
			maxValue = v
		}
		if v <= maxValue {
			minValue = v
		}

		allValue += v
	}
	middleValue = allValue / float64(len(res))
	return maxValue, middleValue, minValue
}