kpt-pasture/http/handler/pasture/pasture.go

package pasture

import (
	"kpt-pasture/http/middleware"
	"net/http"
	"strconv"

	pasturePb "gitee.com/xuyiping_admin/go_proto/proto/go/backend/cow"
	operationPb "gitee.com/xuyiping_admin/go_proto/proto/go/backend/operation"
	"gitee.com/xuyiping_admin/pkg/apierr"
	"gitee.com/xuyiping_admin/pkg/ginutil"
	"gitee.com/xuyiping_admin/pkg/valid"
	"gitee.com/xuyiping_admin/pkg/valid/is"
	"gitee.com/xuyiping_admin/pkg/xerr"
	"github.com/gin-gonic/gin"
)

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

	pagination := &pasturePb.PaginationModel{
		Page:       int32(c.GetInt(middleware.Page)),
		PageSize:   int32(c.GetInt(middleware.PageSize)),
		PageOffset: int32(c.GetInt(middleware.PageOffset)),
	}

	res, err := middleware.Dependency(c).StoreEventHub.OpsService.SearchDiseaseList(c, &req, pagination)
	if err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	ginutil.JSONResp(c, res)
}

func CreatedOrUpdateDisease(c *gin.Context) {
	var req pasturePb.SearchDiseaseList
	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.DiseaseTypeId, valid.Required),
	); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if err := middleware.BackendOperation(c).OpsService.CreateOrUpdateDisease(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 SearchDiseaseTypeList(c *gin.Context) {
	var req pasturePb.SearchNameRequest
	if err := ginutil.BindProto(c, &req); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	pagination := &pasturePb.PaginationModel{
		Page:       int32(c.GetInt(middleware.Page)),
		PageSize:   int32(c.GetInt(middleware.PageSize)),
		PageOffset: int32(c.GetInt(middleware.PageOffset)),
	}

	res, err := middleware.Dependency(c).StoreEventHub.OpsService.SearchDiseaseTypeList(c, &req, pagination)
	if err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	ginutil.JSONResp(c, res)
}

func CreatedOrUpdateDiseaseType(c *gin.Context) {
	var req pasturePb.SearchBaseConfigList
	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),
	); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if err := middleware.BackendOperation(c).OpsService.CreateOrUpdateDiseaseType(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 SearchPrescriptionList(c *gin.Context) {
	var req pasturePb.SearchPrescriptionRequest
	if err := ginutil.BindProto(c, &req); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	pagination := &pasturePb.PaginationModel{
		Page:       int32(c.GetInt(middleware.Page)),
		PageSize:   int32(c.GetInt(middleware.PageSize)),
		PageOffset: int32(c.GetInt(middleware.PageOffset)),
	}

	res, err := middleware.Dependency(c).StoreEventHub.OpsService.SearchPrescriptionList(c, &req, pagination)
	if err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	ginutil.JSONResp(c, res)
}

func CreatedOrUpdatePrescription(c *gin.Context) {
	var req pasturePb.PrescriptionRequest
	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.DrugsList, valid.Required),
	); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if err := middleware.BackendOperation(c).OpsService.CreateOrUpdatePrescription(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 PrescriptionDetail(c *gin.Context) {
	idStr := c.Param("id")
	id, _ := strconv.ParseInt(idStr, 10, 64)
	if err := valid.Validate(id, valid.Required); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	res, err := middleware.BackendOperation(c).OpsService.PrescriptionDetail(c, id)
	if err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}

	ginutil.JSONResp(c, res)
}

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

	pagination := &pasturePb.PaginationModel{
		Page:       int32(c.GetInt(middleware.Page)),
		PageSize:   int32(c.GetInt(middleware.PageSize)),
		PageOffset: int32(c.GetInt(middleware.PageOffset)),
	}

	res, err := middleware.Dependency(c).StoreEventHub.OpsService.ImmunizationSetList(c, &req, pagination)
	if err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	ginutil.JSONResp(c, res)
}

func CreatedOrUpdateImmunization(c *gin.Context) {
	var req pasturePb.ImmunizationRequest
	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.Conditions, valid.Required),
		valid.Field(&req.Value, valid.Required),
	); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if err := middleware.BackendOperation(c).OpsService.CreatedOrUpdateImmunization(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 ImmunizationIsShow(c *gin.Context) {
	immunizationIdStr := c.Param("id")
	immunizationId, _ := strconv.Atoi(immunizationIdStr)

	if err := valid.Validate(immunizationId, valid.Required, valid.Min(1)); err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	if err := middleware.Dependency(c).StoreEventHub.OpsService.ImmunizationIsShow(c, int64(immunizationId)); err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	ginutil.JSONResp(c, &operationPb.CommonOK{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &operationPb.Success{Success: true},
	})
}

// SameTimeCreatedOrUpdate 同期策略添加或者更新
func SameTimeCreatedOrUpdate(c *gin.Context) {
	var req pasturePb.SearchSameTimeList
	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.CowType, valid.Required),
		valid.Field(&req.WeekType, valid.Required),
		valid.Field(&req.PostpartumDaysStart, valid.Required),
		valid.Field(&req.PostpartumDaysEnd, valid.Required),
		valid.Field(&req.CollateNodes, valid.Required),
	); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if req.PostpartumDaysStart > req.PostpartumDaysEnd {
		apierr.AbortBadRequest(c, http.StatusBadRequest, xerr.New("开始天数不能大于结束天数"))
		return
	}

	if len(req.CollateNodes) < 0 {
		apierr.AbortBadRequest(c, http.StatusBadRequest, xerr.New("错误的同期策略数据"))
		return
	}

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

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

// SameTimeList 同步策略列表
func SameTimeList(c *gin.Context) {
	var req pasturePb.SearchNameRequest
	if err := ginutil.BindProto(c, &req); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	pagination := &pasturePb.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.SearchSameTimeList(c, &req, pagination)
	if err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	ginutil.JSONResp(c, res)
}

func SameTimeIsShow(c *gin.Context) {
	sameTimeIdStr := c.Param("id")
	sameTimeId, _ := strconv.Atoi(sameTimeIdStr)

	if err := valid.Validate(sameTimeId, valid.Required, valid.Min(1)); err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	if err := middleware.BackendOperation(c).OpsService.SameTimeIsShow(c, int64(sameTimeId)); err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	ginutil.JSONResp(c, &operationPb.CommonOK{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &operationPb.Success{Success: true},
	})
}

func SystemBasicList(c *gin.Context) {
	res, err := middleware.BackendOperation(c).OpsService.SystemBasicList(c)
	if err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	ginutil.JSONResp(c, res)
}

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

	if err := valid.ValidateStruct(&req,
		valid.Field(&req.Item, valid.Required, valid.Each(valid.By(func(value interface{}) error {
			s := value.(pasturePb.BaseDataConfig)
			return valid.ValidateStruct(&s,
				valid.Field(&s.Id, valid.Required),
				valid.Field(&s.Name, valid.Required),
			)
		}))),
	); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

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

func SaleDealerCreateOrUpdate(c *gin.Context) {
	var req pasturePb.DealerItem
	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.Phone, valid.Required, is.E164),
		valid.Field(&req.Contacts, valid.Required),
	); err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}

	if err := middleware.BackendOperation(c).OpsService.CreateOrUpdateDealer(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 SaleDealerList(c *gin.Context) {
	var req pasturePb.SearchNameRequest
	if err := ginutil.BindProto(c, &req); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

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

func SaleDealerIsShow(c *gin.Context) {
	dealerIdStr := c.Param("id")
	dealerId, _ := strconv.Atoi(dealerIdStr)

	if err := valid.Validate(dealerId, valid.Required, valid.Min(1)); err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	if err := middleware.BackendOperation(c).OpsService.DeleteDealer(c, int64(dealerId)); err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	ginutil.JSONResp(c, &operationPb.CommonOK{
		Code: http.StatusOK,
		Msg:  "ok",
		Data: &operationPb.Success{Success: true},
	})
}