kpt-pasture/module/backend/indicators.go

package backend

import (
	"context"
	"fmt"
	"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()
	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

}

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

	pastureId := userModel.AppPasture.Id
	eventSaleList := make([]*model.EventSale, 0)
	pref := s.DB.Table(fmt.Sprintf("%s AS a", new(model.EventSale).TableName())).
		Select("a.id,a.dealer_name,a.sale_kind,a.sale_price,a.sale_all_weight,a.sale_all_amount,sale_cow_count,a.sale_at,a.remarks").
		Joins(fmt.Sprintf("JOIN %s AS b on b.sale_id = a.id", new(model.EventSaleCow).TableName())).
		Where("a.pasture_id = ?", pastureId).
		Where("a.sale_at BETWEEN ? AND ?", req.StartAt, req.EndAt)

	if req.BatchNumber != "" {
		pref.Where("b.batch_number = ?", req.BatchNumber)
	}

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

	if req.CowKind > pasturePb.CowKind_Invalid {
		pref.Where("b.cow_kind = ?", req.CowKind)
	}

	if err = pref.
		Limit(int(pagination.PageSize)).
		Offset(int(pagination.PageOffset)).
		Group("a.id").
		Find(&eventSaleList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	result := &pasturePb.AlreadySalesReportResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &pasturePb.AlreadySalesReportData{
			List:     make([]*pasturePb.AlreadySalesReport, 0),
			Total:    0,
			PageSize: pagination.PageSize,
			Page:     pagination.Page,
		},
	}

	if len(eventSaleList) <= 0 {
		return result, nil
	}

	saleIds := make([]int64, 0)
	eventSaleMap := make(map[int64]*model.EventSale)
	for _, v := range eventSaleList {
		saleIds = append(saleIds, v.Id)
		eventSaleMap[v.Id] = v
	}

	eventSaleCowList := make([]*model.EventSaleCow, 0)
	if err = s.DB.Model(new(model.EventSaleCow)).
		Where("sale_id IN ?", saleIds).
		Where("pasture_id = ?", pastureId).
		Find(&eventSaleCowList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	cowIds := make([]int64, 0)
	for _, v := range eventSaleCowList {
		cowIds = append(cowIds, v.CowId)
	}

	cowList := make([]*model.Cow, 0)
	if err = s.DB.Model(new(model.Cow)).
		Where("id IN ?", cowIds).
		Where("pasture_id = ?", pastureId).
		Find(&cowList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	cowMap := make(map[int64]*model.Cow)
	for _, v := range cowList {
		cowMap[v.Id] = v
	}

	sourceMap := s.CowSourceMap()
	cowKindMap := s.CowKindMap()
	result.Data.Total = int32(len(eventSaleCowList))
	result.Data.List = model.EventSaleCowSlice(eventSaleCowList).ToPB(eventSaleMap, cowKindMap, cowMap, sourceMap)
	return result, nil
}

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

	pastureId := userModel.AppPasture.Id
	cowList := make([]*model.Cow, 0)
	var count int64
	pref := s.DB.Model(new(model.Cow)).
		Where("pasture_id = ?", pastureId).
		Where("current_weight BETWEEN ? AND ?", req.WeightStart*1000, req.WeightEnd*1000)

	if req.BatchNumber != "" {
		pref.Where("batch_number = ?", req.BatchNumber)
	}

	if req.CowKind > pasturePb.CowKind_Invalid {
		pref.Where("cow_kind = ?", req.CowKind)
	}

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

	if err = pref.Count(&count).
		Limit(int(pagination.PageSize)).
		Offset(int(pagination.PageOffset)).
		Find(&cowList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	result := &pasturePb.CanSalesReportResponse{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &pasturePb.CanSalesReportData{
			List:     make([]*pasturePb.CanSalesReport, 0),
			Total:    0,
			PageSize: pagination.PageSize,
			Page:     pagination.Page,
		},
	}

	if len(cowList) <= 0 {
		return result, nil
	}
	cowKindMap := s.CowKindMap()
	result.Data.Total = int32(count)
	result.Data.List = model.CowSlice(cowList).CanSaleToPB(cowKindMap)
	return result, nil
}