kpt-pasture/model/event_sale.go

package model

import (
	"strings"
	"time"

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

type EventSale struct {
	Id               int64                     `json:"id"`
	PastureId        int64                     `json:"pastureId"`
	DealerId         int32                     `json:"dealerId"`
	DealerName       string                    `json:"dealerName"`
	SalePrice        float64                   `json:"salePrice"`
	SaleAllWeight    int32                     `json:"saleAllWeight"`
	SaleAllAmount    int64                     `json:"saleAllAmount"`
	SaleCowCount     int32                     `json:"saleCowCount"`
	SaleKind         pasturePb.SalesType_Kind  `json:"saleKind"`
	OutReasonsKind   pasturePb.OutReasons_Kind `json:"outReasonsKind"`
	OutReasonsName   string                    `json:"outReasonsName"`
	SaleAt           int64                     `json:"saleAt"`
	SaleTicker       string                    `json:"saleTicker"`
	QuarantineReport string                    `json:"quarantineReport"`
	Remarks          string                    `json:"remarks"`
	OperationId      int64                     `json:"operationId"`
	OperationName    string                    `json:"operationName"`
	MessageId        int64                     `json:"messageId"`
	MessageName      string                    `json:"messageName"`
	CreatedAt        int64                     `json:"createdAt"`
	UpdatedAt        int64                     `json:"updatedAt"`
}

func (e *EventSale) TableName() string {
	return "event_sale"
}

func NewEventSale(pastureId int64, dealerInfo *SaleDealer, req *pasturePb.EventCowSale, operationUser, currUser *SystemUser) *EventSale {
	return &EventSale{
		PastureId:        pastureId,
		DealerId:         dealerInfo.Id,
		DealerName:       dealerInfo.Name,
		SalePrice:        float64(req.SalePrice),
		SaleAllWeight:    int32(req.SaleAllWeight * 1000),
		SaleAllAmount:    int64(req.SaleAllPrice * 100),
		SaleCowCount:     int32(len(req.EarNumbers)),
		SaleKind:         req.SalesType,
		OutReasonsKind:   req.OutReasonsKind,
		OutReasonsName:   req.OutReasonsName,
		SaleAt:           int64(req.SaleAt),
		SaleTicker:       strings.Join(req.SaleTicket, ","),
		QuarantineReport: strings.Join(req.QuarantineReport, ","),
		Remarks:          req.Remarks,
		OperationId:      operationUser.Id,
		OperationName:    operationUser.Name,
		MessageId:        currUser.Id,
		MessageName:      currUser.Name,
	}
}

type EventSaleSlice []*EventSale

func (e EventSaleSlice) ToPB(eventSaleCarMap map[int64][]*EventSaleCar, eventSaleCowMap map[int64][]*EventSaleCow) []*pasturePb.EventCowSale {
	res := make([]*pasturePb.EventCowSale, len(e))
	for i, v := range e {
		saleVehicleItems := make([]*pasturePb.SaleVehicleItem, 0)
		if eventSaleCarItems, ok := eventSaleCarMap[v.Id]; ok {
			for _, item := range eventSaleCarItems {
				es, weighbridgePhotos, vehiclePhotos := make([]string, 0), make([]string, 0), make([]string, 0)
				if item.EarNumbers != "" {
					es = strings.Split(item.EarNumbers, ",")
				}
				if item.WeighbridgePhotos != "" {
					weighbridgePhotos = strings.Split(item.WeighbridgePhotos, ",")
				}
				if item.CarPhotos != "" {
					vehiclePhotos = strings.Split(item.CarPhotos, ",")
				}
				saleVehicleItem := &pasturePb.SaleVehicleItem{
					CarNumber:         item.CarNumber,
					CowCount:          item.CowCount,
					CowWeight:         float32(item.CowWeight) / 1000,
					OutboundTicket:    item.OutboundTicket,
					WeighbridgePhotos: weighbridgePhotos,
					VehiclePhotos:     vehiclePhotos,
					EarNumbers:        es,
				}
				saleVehicleItems = append(saleVehicleItems, saleVehicleItem)
			}
		}

		earNumbers := make([]string, 0)
		saleCount := int32(0)
		if cowList, ok := eventSaleCowMap[v.Id]; ok {
			for _, cow := range cowList {
				earNumbers = append(earNumbers, cow.EarNumber)
				saleCount++
			}
		}

		res[i] = &pasturePb.EventCowSale{
			DealerId:         v.DealerId,
			DealerName:       v.DealerName,
			SaleAt:           int32(v.SaleAt),
			EarNumbers:       earNumbers,
			SalesType:        v.SaleKind,
			OutReasonsKind:   v.OutReasonsKind,
			OutReasonsName:   v.OutReasonsName,
			SaleAllWeight:    float32(v.SaleAllWeight) / 1000,
			SaleAllPrice:     float32(v.SaleAllAmount) / 100,
			SalePrice:        float32(v.SalePrice),
			OperationId:      int32(v.OperationId),
			OperationName:    v.OperationName,
			Remarks:          v.Remarks,
			SaleTicket:       strings.Split(v.SaleTicker, ","),
			QuarantineReport: strings.Split(v.QuarantineReport, ","),
			SaleVehicleItems: saleVehicleItems,
			SaleCount:        saleCount,
		}
	}
	return res
}

func (e EventSaleSlice) ToPB2(monthRang []string) *pasturePb.OutNumber {
	res := &pasturePb.OutNumber{
		Month:  monthRang,
		Number: make([]int32, 0),
		Name:   "近6个月的出栏量 ",
	}
	for i, m := range monthRang {
		for _, v := range e {
			month := time.Unix(v.SaleAt, 0).Format(LayoutMonth)
			if month == m {
				res.Number[i] += v.SaleCowCount
			}
		}
	}
	return res
}

type EventSaleModel struct {
	CowList          []*Cow
	SalesType        pasturePb.SalesType_Kind
	SaleAt           int64
	EventSaleCarList []*EventSaleCar
	EventSaleCowList []*EventSaleCow
	NeckRingList     []*NeckRing
	EventCowLog      []*EventCowLog
}