kpt-tmr-group/http/handler/pasture/forage_list.go

package pasture

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"
	"time"

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

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

	if err := valid.ValidateStruct(&req,
		valid.Field(&req.Name, valid.Required),
		valid.Field(&req.CategoryId, valid.Required),
		valid.Field(&req.UniqueEncode, valid.Required),
		valid.Field(&req.ForageSourceId, valid.Required),
		valid.Field(&req.ForageSourceName, valid.Required),
		//valid.Field(&req.PlanTypeId, valid.Required, valid.Min(0), valid.Max(2)),
		valid.Field(&req.PlanTypeName, valid.Required),
		valid.Field(&req.MaterialType, valid.Required),
		//valid.Field(&req.JumpWeight, valid.Required, valid.Min(0), valid.Max(50)),
	); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if err := middleware.BackendOperation(c).OpsService.CreateForage(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 EditForage(c *gin.Context) {
	var req operationPb.AddForageRequest
	if err := ginutil.BindProto(c, &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.CategoryId, valid.Required),
		valid.Field(&req.CategoryName, valid.Required),
		valid.Field(&req.UniqueEncode, valid.Required),
		valid.Field(&req.ForageSourceId, valid.Required),
		valid.Field(&req.MaterialType, valid.Required),
	); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if err := middleware.BackendOperation(c).OpsService.EditForage(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 SearchForageList(c *gin.Context) {
	req := &operationPb.SearchForageListRequest{}
	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.SearchForageList(c, req)
	if err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	ginutil.JSONResp(c, res)
}

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

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

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

// SmallMaterial 小料字段是否展示
func SmallMaterial(c *gin.Context) {
	var req operationPb.SmallMaterialRequest
	if err := ginutil.BindProto(c, &req); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}
	res, err := middleware.BackendOperation(c).OpsService.SmallMaterial(c, &req)
	if err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	c.JSON(http.StatusOK, res)
}

// SearchForageEnumList 饲料列表公共枚举
func SearchForageEnumList(c *gin.Context) {
	res := middleware.BackendOperation(c).OpsService.ForageEnumList(c)
	ginutil.JSONResp(c, res)
}

func DeleteForageList(c *gin.Context) {
	ids := make([]int64, 0)
	if err := c.BindJSON(&ids); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if len(ids) <= 0 {
		apierr.AbortBadRequest(c, http.StatusBadRequest, xerr.Custom("参数错误"))
		return
	}

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

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

	if err := valid.ValidateStruct(&req,
		valid.Field(&req.ForageId, 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.IsShowForage(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 ExcelImportForage(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.ExcelImportForage(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 ExcelExportForage(c *gin.Context) {
	req := &operationPb.SearchForageListRequest{}
	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)),
	}

	buffer, err := middleware.BackendOperation(c).OpsService.ExcelExportForage(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 ExcelTemplateForage(c *gin.Context) {

	buffer, err := middleware.BackendOperation(c).OpsService.ExcelTemplateForage(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},
	})
}