kpt-tmr-group/http/handler/feed/feed_formula.go

package feed

import (
	"fmt"
	"kpt-tmr-group/http/middleware"
	"kpt-tmr-group/pkg/apierr"
	"kpt-tmr-group/pkg/ginutil"
	"kpt-tmr-group/pkg/valid"
	"kpt-tmr-group/pkg/xerr"
	operationPb "kpt-tmr-group/proto/go/backend/operation"
	"mime/multipart"
	"net/http"
	"path"
	"strconv"
	"time"

	"github.com/gin-gonic/gin"
)

func AddFeedFormula(c *gin.Context) {
	var req operationPb.AddFeedFormulaRequest
	if err := c.BindJSON(&req); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if err := valid.ValidateStruct(&req,
		valid.Field(&req.Name, valid.Required),
		valid.Field(&req.EncodeNumber, valid.Required, valid.Length(1, 30)),
		valid.Field(&req.Colour, valid.Required),
		valid.Field(&req.CattleCategoryId, valid.Required, valid.Min(1)),
		valid.Field(&req.CattleCategoryName, valid.Required),
		valid.Field(&req.FormulaTypeId, valid.Required, valid.Min(1)),
		valid.Field(&req.FormulaTypeName, valid.Required),
		valid.Field(&req.DataSourceId, valid.Required, valid.Min(1)),
		valid.Field(&req.DataSourceName, valid.Required),
		valid.Field(&req.IsShow, valid.Required, valid.Min(1), valid.Max(2)),
		valid.Field(&req.IsModify, valid.Required, valid.Min(1), valid.Max(2)),
	); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if err := middleware.BackendOperation(c).OpsService.CreateFeedFormula(c, &req); err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	ginutil.JSONResp(c, &operationPb.CommonOK{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &operationPb.Success{Success: true},
	})
}

// EditFeedFormula 编辑配方
func EditFeedFormula(c *gin.Context) {
	var req operationPb.AddFeedFormulaRequest
	if err := c.BindJSON(&req); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if err := valid.ValidateStruct(&req,
		valid.Field(&req.Id, valid.Required, valid.Min(1)),
		valid.Field(&req.Name, valid.Required),
		valid.Field(&req.EncodeNumber, valid.Required, valid.Length(1, 30)),
		valid.Field(&req.Colour, valid.Required),
		valid.Field(&req.CattleCategoryId, valid.Required, valid.Min(1)),
		valid.Field(&req.CattleCategoryName, valid.Required),
		valid.Field(&req.FormulaTypeId, valid.Required, valid.Min(1)),
		valid.Field(&req.FormulaTypeName, valid.Required),
		valid.Field(&req.DataSourceId, valid.Required, valid.Min(1)),
		valid.Field(&req.DataSourceName, valid.Required),
		valid.Field(&req.IsShow, valid.Required, valid.Min(1), valid.Max(2)),
		valid.Field(&req.IsModify, valid.Required, valid.Min(1), valid.Max(2)),
	); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if err := middleware.BackendOperation(c).OpsService.EditFeedFormula(c, &req); err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	ginutil.JSONResp(c, &operationPb.CommonOK{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &operationPb.Success{Success: true},
	})
}

// AddFeedByFeedFormula 配方添加饲料
func AddFeedByFeedFormula(c *gin.Context) {
	var req operationPb.GroupAddFeedFormulaDetail
	if err := c.BindJSON(&req); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	for _, v := range req.List {
		if err := valid.ValidateStruct(&req,
			valid.Field(&req.FeedFormulaId, valid.Required, valid.Min(1)),
			valid.Field(&v.ForageId, valid.Required, valid.Min(1)),
			valid.Field(&v.ForageName, valid.Required, valid.Length(1, 30)),
			valid.Field(&v.Weight, valid.Required, valid.Min(1)),
			valid.Field(&v.Sort, valid.Required, valid.Min(1)),
		); err != nil {
			apierr.AbortBadRequest(c, http.StatusBadRequest, err)
			return
		}
	}

	if err := middleware.BackendOperation(c).OpsService.AddFeedByFeedFormula(c, &req); err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	ginutil.JSONResp(c, &operationPb.CommonOK{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &operationPb.Success{Success: true},
	})
}

// DetailBySort 配方详情排序
func DetailBySort(c *gin.Context) {
	var req operationPb.GroupAddFeedFormulaDetail
	if err := c.BindJSON(&req); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	for _, v := range req.List {
		if err := valid.ValidateStruct(&req,
			valid.Field(&req.FeedFormulaId, valid.Required, valid.Min(1)),
			valid.Field(&v.ForageId, valid.Required, valid.Min(1)),
			valid.Field(&v.ForageName, valid.Required, valid.Length(1, 30)),
			valid.Field(&v.Weight, valid.Required, valid.Min(1)),
			valid.Field(&v.Sort, valid.Required, valid.Min(1)),
		); err != nil {
			apierr.AbortBadRequest(c, http.StatusBadRequest, err)
			return
		}
	}

	if err := middleware.BackendOperation(c).OpsService.FeedFormulaDetailBySort(c, &req); err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	ginutil.JSONResp(c, &operationPb.CommonOK{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &operationPb.Success{Success: true},
	})
}

// DetailDelete 删除配方饲料
func DetailDelete(c *gin.Context) {
	var req operationPb.GroupAddFeedFormulaDetail
	if err := c.BindJSON(&req); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	for _, v := range req.List {
		if err := valid.ValidateStruct(&req,
			valid.Field(&req.FeedFormulaId, valid.Required, valid.Min(1)),
			valid.Field(&v.ForageId, valid.Required, valid.Min(1)),
			valid.Field(&v.ForageName, valid.Required, valid.Length(1, 30)),
			valid.Field(&v.Weight, valid.Required, valid.Min(1)),
			valid.Field(&v.Sort, valid.Required, valid.Min(1)),
		); err != nil {
			apierr.AbortBadRequest(c, http.StatusBadRequest, err)
			return
		}
	}

	if err := middleware.BackendOperation(c).OpsService.FeedFormulaDetailDelete(c, &req); err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	ginutil.JSONResp(c, &operationPb.CommonOK{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &operationPb.Success{Success: true},
	})
}

// MixedFeedFormula 合并预混料
func MixedFeedFormula(c *gin.Context) {
	var req operationPb.MixedFeedFormulaRequest
	if err := c.BindJSON(&req); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if err := valid.ValidateStruct(&req,
		valid.Field(&req.Name, valid.Required),
		valid.Field(&req.Colour, valid.Required),
		valid.Field(&req.CattleCategoryId, valid.Required),
		valid.Field(&req.CattleCategoryName, valid.Required),
		valid.Field(&req.FormulaTypeId, valid.Required),
		valid.Field(&req.FormulaTypeName, valid.Required),
		valid.Field(&req.DataSourceId, valid.Required),
	); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if err := middleware.BackendOperation(c).OpsService.MixedFeedFormula(c, &req); err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	ginutil.JSONResp(c, &operationPb.CommonOK{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &operationPb.Success{Success: true},
	})
}

func SearchFeedFormulaList(c *gin.Context) {
	req := &operationPb.SearchFeedFormulaRequest{}
	if err := ginutil.BindProto(c, req); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	req.Pagination = &operationPb.PaginationModel{
		Page:       int32(c.GetInt(middleware.Page)),
		PageSize:   int32(c.GetInt(middleware.PageSize)),
		PageOffset: int32(c.GetInt(middleware.PageOffset)),
	}

	res, err := middleware.BackendOperation(c).OpsService.SearchFeedFormulaList(c, req)
	if err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	ginutil.JSONResp(c, res)
}

func SearchFeedFormulaByForageList(c *gin.Context) {
	req := &operationPb.SearchFeedFormulaRequest{}
	if err := ginutil.BindProto(c, req); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	req.Pagination = &operationPb.PaginationModel{
		Page:       int32(c.GetInt(middleware.Page)),
		PageSize:   int32(c.GetInt(middleware.PageSize)),
		PageOffset: int32(c.GetInt(middleware.PageOffset)),
	}

	res, err := middleware.BackendOperation(c).OpsService.SearchFeedFormulaList(c, req)
	if err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	ginutil.JSONResp(c, res)
}

func DeleteFeedFormula(c *gin.Context) {
	feedFormulaIdStr := c.Param("feed_formula_id")
	feedFormulaId, _ := strconv.Atoi(feedFormulaIdStr)

	if err := valid.Validate(feedFormulaId, valid.Required, valid.Min(1)); err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}

	if err := middleware.BackendOperation(c).OpsService.DeleteFeedFormula(c, int64(feedFormulaId)); err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	ginutil.JSONResp(c, &operationPb.CommonOK{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &operationPb.Success{Success: true},
	})
}

func IsShowModifyFeedFormula(c *gin.Context) {
	var req operationPb.IsShowModifyFeedFormula
	if err := c.BindJSON(&req); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if err := valid.ValidateStruct(&req,
		valid.Field(&req.FeedFormulaId, valid.Required, valid.Min(1)),
		valid.Field(&req.IsShow, valid.Required, valid.Min(1), valid.Max(2)),
	); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if err := middleware.BackendOperation(c).OpsService.IsShowFeedFormula(c, &req); err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	ginutil.JSONResp(c, &operationPb.CommonOK{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &operationPb.Success{Success: true},
	})
}

func ExcelImportFeedFormula(c *gin.Context) {
	file, err := func(c *gin.Context) (multipart.File, error) {
		if c.ContentType() != "multipart/form-data" {
			return nil, xerr.Custom("invalid Content-Type")
		}
		if c.Request.Body == nil || int(c.Request.ContentLength) <= 0 {
			return nil, xerr.Custom("invalid body")
		}

		file, fileHeader, err := c.Request.FormFile("file")
		if err != nil {
			return nil, xerr.WithStack(err)
		}

		fileSuffix := path.Ext(path.Base(fileHeader.Filename))
		if fileSuffix != ".xlsx" {
			return nil, xerr.Custom("invalid file suffix")
		}

		return file, nil
	}(c)

	if err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if err = middleware.BackendOperation(c).OpsService.ExcelImportFeedFormula(c, file); err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	ginutil.JSONResp(c, &operationPb.CommonOK{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &operationPb.Success{Success: true},
	})
}

func ExcelExportFeedFormula(c *gin.Context) {
	req := &operationPb.SearchFeedFormulaRequest{}
	if err := c.BindJSON(req); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	req.Pagination = &operationPb.PaginationModel{
		Page:       int32(c.GetInt(middleware.Page)),
		PageSize:   int32(c.GetInt(middleware.PageSize)),
		PageOffset: int32(c.GetInt(middleware.PageOffset)),
	}

	buffer, err := middleware.BackendOperation(c).OpsService.ExcelExportFeedFormula(c, req)
	if err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}

	c.Header("Content-Type", "application/octet-stream")
	c.Header("Content-Disposition", "attachment; filename="+(fmt.Sprintf("饲料表 %s.xlsx", time.Now().Format("200601021504"))))
	if _, err = c.Writer.Write(buffer.Bytes()); err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}

	ginutil.JSONResp(c, &operationPb.CommonOK{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &operationPb.Success{Success: true},
	})
}

func ExcelTemplateFeedFormula(c *gin.Context) {
	buffer, err := middleware.BackendOperation(c).OpsService.ExcelTemplateFeedFormula(c)
	if err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}

	c.Header("Content-Type", "application/octet-stream")
	c.Header("Content-Disposition", "attachment; filename="+(fmt.Sprintf("饲料表 %s.xlsx", time.Now().Format("200601021504"))))
	if _, err = c.Writer.Write(buffer.Bytes()); err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}

	ginutil.JSONResp(c, &operationPb.CommonOK{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &operationPb.Success{Success: true},
	})
}

func EncodeNumber(c *gin.Context) {
	ginutil.JSONResp(c, &operationPb.UniqueID{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &operationPb.UniqueID_UniqueData{EncodeNumber: middleware.BackendOperation(c).OpsService.EncodeNumber(c)},
	})
}

// DistributeFeedFormula 饲料配方下发
func DistributeFeedFormula(c *gin.Context) {
	req := &operationPb.DistributeFeedFormulaRequest{}
	if err := ginutil.BindProto(c, req); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if err := middleware.BackendOperation(c).OpsService.DistributeFeedFormula(c, req); err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}

	ginutil.JSONResp(c, &operationPb.CommonOK{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &operationPb.Success{Success: true},
	})
}

// CancelDistributeFeedFormula 取消配方下发
func CancelDistributeFeedFormula(c *gin.Context) {
	req := &operationPb.DistributeFeedFormulaRequest{}
	if err := ginutil.BindProto(c, req); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if err := middleware.BackendOperation(c).OpsService.CancelDistributeFeedFormula(c, req); err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}

	ginutil.JSONResp(c, &operationPb.CommonOK{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &operationPb.Success{Success: true},
	})
}

// EditRecordFeedFormula 配方修改记录
func EditRecordFeedFormula(c *gin.Context) {
	var req operationPb.EditRecodeFeedFormulaRequest
	if err := ginutil.BindProto(c, &req); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if err := valid.ValidateStruct(&req,
		valid.Field(&req.PastureId, valid.Required, valid.Min(1)),
		valid.Field(&req.StartTime, valid.Required, valid.Min(1), valid.Max(time.Now().Unix())),
		valid.Field(&req.EndTime, valid.Required, valid.Min(1), valid.Max(time.Now().Unix())),
	); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if list, err := middleware.BackendOperation(c).OpsService.EditRecodeFeedFormula(c, &req); err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	} else {
		ginutil.JSONResp(c, list)
	}
}

// Usage 配方使用情况
func Usage(c *gin.Context) {
	var req operationPb.FeedFormulaUsageRequest
	if err := ginutil.BindProto(c, &req); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if err := valid.ValidateStruct(&req,
		valid.Field(&req.FeedFormulaId, valid.Required, valid.Min(1)),
		valid.Field(&req.StartTime, valid.Required),
		valid.Field(&req.EndTime, valid.Required),
	); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if res, err := middleware.BackendOperation(c).OpsService.FeedFormulaUsage(c, &req); err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	} else {
		ginutil.JSONResp(c, res)
	}
}