kpt-pasture/module/backend/indicators.go

package backend

import (
	"context"
	"kpt-pasture/model"
	"kpt-pasture/util"
	"net/http"

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

func (s *StoreEntry) IndicatorsComparison(ctx context.Context, req *pasturePb.IndicatorsComparisonRequest) (*model.IndicatorsComparisonResponse, error) {
	userModel, err := s.GetUserModel(ctx)
	if err != nil {
		return nil, xerr.WithStack(err)
	}

	indicatorsDataList := make([]*model.IndicatorsData, 0)
	pref := s.DB.Model(new(model.IndicatorsData)).
		Where("pasture_id = ?", userModel.AppPasture.Id)

	dataRange, err := util.GetMonthsBetween(req.DateList[0], req.DateList[1])
	if err != nil {
		return nil, xerr.WithStack(err)
	}
	pref.Where("date IN (?)", dataRange)

	if req.CategoryKind > 0 {
		pref.Where("category_type = ?", req.CategoryKind)
	}

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

	if err = pref.Order("date,kind").Find(&indicatorsDataList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	indicatorsDetailsMap, kinds, err := s.GetIndicatorsDetailsMap(ctx)

	if req.CategoryKind > 0 {
		if len(req.KindList) <= 0 {
			kinds = kinds[:0]
		}
		for _, v := range indicatorsDetailsMap {
			if v.CategoryType != req.CategoryKind {
				delete(indicatorsDetailsMap, v.Kind)
			} else {
				kinds = append(kinds, v.Kind)
			}
		}
	}

	if len(req.KindList) > 0 {
		kinds = req.KindList
	}

	if err != nil {
		return nil, xerr.WithStack(err)
	}
	return &model.IndicatorsComparisonResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: model.IndicatorsDataSlice(indicatorsDataList).ToPB(dataRange, kinds, indicatorsDetailsMap),
	}, nil
}

func (s *StoreEntry) GetIndicatorsDetailsMap(ctx context.Context) (map[string]*model.IndicatorsDetails, []string, error) {
	indicatorsDetails := make(map[string]*model.IndicatorsDetails)
	indicatorsDetailsList, err := s.FindIndicatorsDetailsList(ctx)
	if err != nil {
		return nil, nil, xerr.WithStack(err)
	}
	kinds := make([]string, 0)
	for _, v := range indicatorsDetailsList {
		indicatorsDetails[v.Kind] = v
		kinds = append(kinds, v.Kind)
	}
	return indicatorsDetails, kinds, err
}

func (s *StoreEntry) GetIndicatorsDataByDate(pastureId int64, Kind, date string) (*model.IndicatorsData, error) {
	res := &model.IndicatorsData{}
	if err := s.DB.Model(new(model.IndicatorsData)).
		Where("pasture_id = ?", pastureId).
		Where("kind = ?", Kind).
		Where("date = ?", date).
		First(&res).Error; err != nil {
		return nil, xerr.WithStack(err)
	}
	return res, nil
}

func (s *StoreEntry) LongTermInfertility(ctx context.Context, req *pasturePb.LongTermInfertilityRequest, pagination *pasturePb.PaginationModel) (*pasturePb.LongTermInfertilityResponse, error) {
	userModel, err := s.GetUserModel(ctx)
	if err != nil {
		return nil, xerr.WithStack(err)
	}

	cowList := make([]*model.Cow, 0)
	pref := s.DB.Model(new(model.Cow)).
		Where("pasture_id = ?", userModel.AppPasture.Id).
		Where("calving_age > ?", req.CalvingAge).
		Where("breed_status != ?", pasturePb.BreedStatus_Pregnant)

	if req.EarNumber != "" {
		pref.Where("ear_number = ?", req.EarNumber)
	}

	if req.PenId > 0 {
		pref.Where("pen_id = ?", req.PenId)
	}

	var count int64
	if err = pref.Model(new(model.Cow)).
		Order("id desc").
		Count(&count).Limit(int(pagination.PageSize)).
		Offset(int(pagination.PageOffset)).
		Find(&cowList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	breedStatusMap := s.CowBreedStatusMap()
	return &pasturePb.LongTermInfertilityResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &pasturePb.LongTermInfertilityData{
			List:     model.CowSlice(cowList).LongTermInfertilityToPB(breedStatusMap),
			Total:    int32(count),
			PageSize: pagination.PageSize,
			Page:     pagination.Page,
		},
	}, nil

}