package backend

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"kpt-pasture/model"
	"net/http"
	"strings"

	"gitee.com/xuyiping_admin/pkg/xerr"
	"gorm.io/gorm"

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

func (s *StoreEntry) SearchBarnList(ctx context.Context, req *pasturePb.SearchNameRequest, pagination *pasturePb.PaginationModel) (*pasturePb.SearchBarnResponse, error) {
	penList := make([]*model.Pen, 0)
	var count int64 = 0

	pref := s.DB.Model(new(model.Pen)).Where("is_delete = ?", pasturePb.IsShow_Ok)
	if req.Name != "" {
		pref.Where("name like ?", fmt.Sprintf("%s%s%s", "%", req.Name, "%"))
	}

	if err := pref.Order("id desc").Count(&count).Limit(int(pagination.PageSize)).Offset(int(pagination.PageOffset)).
		Find(&penList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	configBarnTypeList := make([]*model.ConfigPenType, 0)
	if err := s.DB.Model(new(model.ConfigPenType)).Find(&configBarnTypeList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	return &pasturePb.SearchBarnResponse{
		Code:    http.StatusOK,
		Message: "ok",
		Data: &pasturePb.SearchBarnData{
			List:     model.PenSlice(penList).ToPB(configBarnTypeList),
			Total:    int32(count),
			PageSize: pagination.PageSize,
			Page:     pagination.Page,
		},
	}, nil
}

func (s *StoreEntry) CreateOrUpdateBarn(ctx context.Context, req *pasturePb.SearchBarnList) error {
	if req.Id > 0 {
		barn := &model.Pen{Id: int64(req.Id)}
		if err := s.DB.Model(&model.Pen{}).First(barn).Error; err != nil {
			if !errors.Is(err, gorm.ErrRecordNotFound) {
				return xerr.WithStack(err)
			}
		}
	}

	if err := s.DB.Model(&model.Pen{}).Where(map[string]interface{}{
		"id": req.Id,
	}).Assign(map[string]interface{}{
		"name":               req.Name,
		"remarks":            req.Remarks,
		"pen_type":           req.BarnTypeId,
		"lengths":            req.Lengths,
		"widths":             req.Widths,
		"doctrinal_capacity": req.DoctrinalCapacity,
		"bed_number":         req.BedNumber,
		"neck_number":        req.NeckNumber,
		"is_delete":          pasturePb.IsShow_Ok,
		"is_show":            pasturePb.IsShow_Ok,
	}).FirstOrCreate(&model.Pen{}).Error; err != nil {
		return xerr.WithStack(err)
	}
	return nil
}

func (s *StoreEntry) SearchBarnTypeList(ctx context.Context, req *pasturePb.SearchNameRequest, pagination *pasturePb.PaginationModel) (*pasturePb.SearchBaseConfigResponse, error) {
	barnTypeList := make([]*model.ConfigPenType, 0)
	var count int64 = 0

	pref := s.DB.Model(new(model.ConfigPenType))
	if req.Name != "" {
		pref.Where("name like ?", fmt.Sprintf("%s%s%s", "%", req.Name, "%"))
	}

	if err := pref.Order("id desc").Count(&count).Limit(int(pagination.PageSize)).Offset(int(pagination.PageOffset)).
		Find(&barnTypeList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	return &pasturePb.SearchBaseConfigResponse{
		Code:    http.StatusOK,
		Message: "ok",
		Data: &pasturePb.SearchBaseConfigData{
			List:     model.ConfigBarnTypeSlice(barnTypeList).ToPB(),
			Total:    int32(count),
			PageSize: pagination.PageSize,
			Page:     pagination.Page,
		},
	}, nil
}

func (s *StoreEntry) CreateOrUpdateBarnType(ctx context.Context, req *pasturePb.SearchBaseConfigList) error {
	if req.Id > 0 {
		barn := &model.ConfigPenType{Id: int64(req.Id)}
		if err := s.DB.Model(&model.ConfigPenType{}).First(barn).Error; err != nil {
			if !errors.Is(err, gorm.ErrRecordNotFound) {
				return xerr.WithStack(err)
			}
		}
	}

	if err := s.DB.Model(&model.ConfigPenType{}).Where(map[string]interface{}{
		"id": req.Id,
	}).Assign(map[string]interface{}{
		"name":    req.Name,
		"remarks": req.Remarks,
		"is_show": pasturePb.IsShow_Ok,
	}).FirstOrCreate(&model.ConfigPenType{}).Error; err != nil {
		return xerr.WithStack(err)
	}
	return nil
}

func (s *StoreEntry) SearchBreedStatusList(ctx context.Context, req *pasturePb.SearchNameRequest, pagination *pasturePb.PaginationModel) (*pasturePb.SearchBaseConfigResponse, error) {
	breedStatusList := make([]*model.ConfigBreedStatus, 0)
	var count int64 = 0

	pref := s.DB.Model(new(model.ConfigBreedStatus))
	if req.Name != "" {
		pref.Where("name like ?", fmt.Sprintf("%s%s%s", "%", req.Name, "%"))
	}

	if err := pref.Order("id desc").Count(&count).Limit(int(pagination.PageSize)).Offset(int(pagination.PageOffset)).
		Find(&breedStatusList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	return &pasturePb.SearchBaseConfigResponse{
		Code:    http.StatusOK,
		Message: "ok",
		Data: &pasturePb.SearchBaseConfigData{
			List:     model.ConfigBreedStatusSlice(breedStatusList).ToPB(),
			Total:    int32(count),
			PageSize: pagination.PageSize,
			Page:     pagination.Page,
		},
	}, nil
}

func (s *StoreEntry) CreateOrUpdateBreedStatus(ctx context.Context, req *pasturePb.SearchBaseConfigList) error {
	if req.Id > 0 {
		barn := &model.ConfigBreedStatus{Id: int64(req.Id)}
		if err := s.DB.Model(&model.ConfigBreedStatus{}).First(barn).Error; err != nil {
			if !errors.Is(err, gorm.ErrRecordNotFound) {
				return xerr.WithStack(err)
			}
		}
	}

	if err := s.DB.Model(&model.ConfigBreedStatus{}).Where(map[string]interface{}{
		"id": req.Id,
	}).Assign(map[string]interface{}{
		"name":    req.Name,
		"remarks": req.Remarks,
		"is_show": pasturePb.IsShow_Ok,
	}).FirstOrCreate(&model.ConfigBreedStatus{}).Error; err != nil {
		return xerr.WithStack(err)
	}
	return nil
}

func (s *StoreEntry) SearchCowKindList(ctx context.Context, req *pasturePb.SearchNameRequest, pagination *pasturePb.PaginationModel) (*pasturePb.SearchBaseConfigResponse, error) {
	configCowKindList := make([]*model.ConfigCowKind, 0)
	var count int64 = 0

	pref := s.DB.Model(new(model.ConfigCowKind))
	if req.Name != "" {
		pref.Where("name like ?", fmt.Sprintf("%s%s%s", "%", req.Name, "%"))
	}

	if err := pref.Order("id desc").Count(&count).Limit(int(pagination.PageSize)).Offset(int(pagination.PageOffset)).
		Find(&configCowKindList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	return &pasturePb.SearchBaseConfigResponse{
		Code:    http.StatusOK,
		Message: "ok",
		Data: &pasturePb.SearchBaseConfigData{
			List:     model.ConfigCowKindSlice(configCowKindList).ToPB(),
			Total:    int32(count),
			PageSize: pagination.PageSize,
			Page:     pagination.Page,
		},
	}, nil
}

func (s *StoreEntry) CreateOrUpdateCowKind(ctx context.Context, req *pasturePb.SearchBaseConfigList) error {
	if req.Id > 0 {
		barn := &model.ConfigCowKind{Id: int64(req.Id)}
		if err := s.DB.Model(&model.ConfigCowKind{}).First(barn).Error; err != nil {
			if !errors.Is(err, gorm.ErrRecordNotFound) {
				return xerr.WithStack(err)
			}
		}
	}

	if err := s.DB.Model(&model.ConfigCowKind{}).Where(map[string]interface{}{
		"id": req.Id,
	}).Assign(map[string]interface{}{
		"name":    req.Name,
		"remarks": req.Remarks,
		"is_show": pasturePb.IsShow_Ok,
	}).FirstOrCreate(&model.ConfigCowKind{}).Error; err != nil {
		return xerr.WithStack(err)
	}
	return nil
}

func (s *StoreEntry) SearchCowStatusList(ctx context.Context, req *pasturePb.SearchNameRequest, pagination *pasturePb.PaginationModel) (*pasturePb.SearchBaseConfigResponse, error) {
	configCowStatusList := make([]*model.ConfigCowStatus, 0)
	var count int64 = 0

	pref := s.DB.Model(new(model.ConfigCowStatus))
	if req.Name != "" {
		pref.Where("name like ?", fmt.Sprintf("%s%s%s", "%", req.Name, "%"))
	}

	if err := pref.Order("id desc").Count(&count).Limit(int(pagination.PageSize)).Offset(int(pagination.PageOffset)).
		Find(&configCowStatusList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	return &pasturePb.SearchBaseConfigResponse{
		Code:    http.StatusOK,
		Message: "ok",
		Data: &pasturePb.SearchBaseConfigData{
			List:     model.ConfigCowStatusSlice(configCowStatusList).ToPB(),
			Total:    int32(count),
			PageSize: pagination.PageSize,
			Page:     pagination.Page,
		},
	}, nil
}

func (s *StoreEntry) CreateOrUpdateCowStatus(ctx context.Context, req *pasturePb.SearchBaseConfigList) error {
	if req.Id > 0 {
		barn := &model.ConfigCowStatus{Id: int64(req.Id)}
		if err := s.DB.Model(&model.ConfigCowStatus{}).First(barn).Error; err != nil {
			if !errors.Is(err, gorm.ErrRecordNotFound) {
				return xerr.WithStack(err)
			}
		}
	}

	if err := s.DB.Model(&model.ConfigCowStatus{}).Where(map[string]interface{}{
		"id": req.Id,
	}).Assign(map[string]interface{}{
		"name":    req.Name,
		"remarks": req.Remarks,
		"is_show": pasturePb.IsShow_Ok,
	}).FirstOrCreate(&model.ConfigCowStatus{}).Error; err != nil {
		return xerr.WithStack(err)
	}
	return nil
}

func (s *StoreEntry) SearchCowTypeList(ctx context.Context, req *pasturePb.SearchNameRequest, pagination *pasturePb.PaginationModel) (*pasturePb.SearchBaseConfigResponse, error) {
	configCowTypeList := make([]*model.ConfigCowType, 0)
	var count int64 = 0

	pref := s.DB.Model(new(model.ConfigCowType))
	if req.Name != "" {
		pref.Where("name like ?", fmt.Sprintf("%s%s%s", "%", req.Name, "%"))
	}

	if err := pref.Order("id desc").Count(&count).Limit(int(pagination.PageSize)).Offset(int(pagination.PageOffset)).
		Find(&configCowTypeList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	return &pasturePb.SearchBaseConfigResponse{
		Code:    http.StatusOK,
		Message: "ok",
		Data: &pasturePb.SearchBaseConfigData{
			List:     model.ConfigCowTypeSlice(configCowTypeList).ToPB(),
			Total:    int32(count),
			PageSize: pagination.PageSize,
			Page:     pagination.Page,
		},
	}, nil
}

func (s *StoreEntry) CreateOrUpdateCowType(ctx context.Context, req *pasturePb.SearchBaseConfigList) error {
	if req.Id > 0 {
		barn := &model.ConfigCowType{Id: int64(req.Id)}
		if err := s.DB.Model(&model.ConfigCowType{}).First(barn).Error; err != nil {
			if !errors.Is(err, gorm.ErrRecordNotFound) {
				return xerr.WithStack(err)
			}
		}
	}

	if err := s.DB.Model(&model.ConfigCowType{}).Where(map[string]interface{}{
		"id": req.Id,
	}).Assign(map[string]interface{}{
		"name":    req.Name,
		"remarks": req.Remarks,
		"is_show": pasturePb.IsShow_Ok,
	}).FirstOrCreate(&model.ConfigCowType{}).Error; err != nil {
		return xerr.WithStack(err)
	}
	return nil
}

func (s *StoreEntry) SearchTransferPenReasonList(ctx context.Context, req *pasturePb.SearchNameRequest, pagination *pasturePb.PaginationModel) (*pasturePb.SearchBaseConfigResponse, error) {
	configTransferPenReasonList := make([]*model.ConfigTransferPenReason, 0)
	var count int64 = 0

	pref := s.DB.Model(new(model.ConfigTransferPenReason))
	if req.Name != "" {
		pref.Where("name like ?", fmt.Sprintf("%s%s%s", "%", req.Name, "%"))
	}

	if err := pref.Order("id desc").Count(&count).Limit(int(pagination.PageSize)).Offset(int(pagination.PageOffset)).
		Find(&configTransferPenReasonList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	return &pasturePb.SearchBaseConfigResponse{
		Code:    http.StatusOK,
		Message: "ok",
		Data: &pasturePb.SearchBaseConfigData{
			List:     model.ConfigTransferPenReasonSlice(configTransferPenReasonList).ToPB(),
			Total:    int32(count),
			PageSize: pagination.PageSize,
			Page:     pagination.Page,
		},
	}, nil
}

func (s *StoreEntry) CreateOrUpdateTransferPenReason(ctx context.Context, req *pasturePb.SearchBaseConfigList) error {
	if req.Id > 0 {
		barn := &model.ConfigTransferPenReason{Id: int64(req.Id)}
		if err := s.DB.Model(&model.ConfigTransferPenReason{}).First(barn).Error; err != nil {
			if !errors.Is(err, gorm.ErrRecordNotFound) {
				return xerr.WithStack(err)
			}
		}
	}

	if err := s.DB.Model(&model.ConfigTransferPenReason{}).Where(map[string]interface{}{
		"id": req.Id,
	}).Assign(map[string]interface{}{
		"name":    req.Name,
		"remarks": req.Remarks,
		"is_show": pasturePb.IsShow_Ok,
	}).FirstOrCreate(&model.ConfigTransferPenReason{}).Error; err != nil {
		return xerr.WithStack(err)
	}
	return nil
}

func (s *StoreEntry) SearchCowSourceList(ctx context.Context, req *pasturePb.SearchNameRequest, pagination *pasturePb.PaginationModel) (*pasturePb.SearchBaseConfigResponse, error) {
	configCowSourceList := make([]*model.ConfigCowSource, 0)
	var count int64 = 0

	pref := s.DB.Model(new(model.ConfigCowSource))
	if req.Name != "" {
		pref.Where("name like ?", fmt.Sprintf("%s%s%s", "%", req.Name, "%"))
	}

	if err := pref.Order("id desc").Count(&count).Limit(int(pagination.PageSize)).Offset(int(pagination.PageOffset)).
		Find(&configCowSourceList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	return &pasturePb.SearchBaseConfigResponse{
		Code:    http.StatusOK,
		Message: "ok",
		Data: &pasturePb.SearchBaseConfigData{
			List:     model.ConfigCowSourceSlice(configCowSourceList).ToPB(),
			Total:    int32(count),
			PageSize: pagination.PageSize,
			Page:     pagination.Page,
		},
	}, nil
}

func (s *StoreEntry) CreateOrUpdateCowSource(ctx context.Context, req *pasturePb.SearchBaseConfigList) error {
	if req.Id > 0 {
		barn := &model.ConfigCowSource{Id: int64(req.Id)}
		if err := s.DB.Model(&model.ConfigCowSource{}).First(barn).Error; err != nil {
			if !errors.Is(err, gorm.ErrRecordNotFound) {
				return xerr.WithStack(err)
			}
		}
	}

	if err := s.DB.Model(&model.ConfigCowSource{}).Where(map[string]interface{}{
		"id": req.Id,
	}).Assign(map[string]interface{}{
		"name":    req.Name,
		"remarks": req.Remarks,
		"is_show": pasturePb.IsShow_Ok,
	}).FirstOrCreate(&model.ConfigCowSource{}).Error; err != nil {
		return xerr.WithStack(err)
	}
	return nil
}

func (s *StoreEntry) CreateOrUpdateSemeTime(ctx context.Context, req *pasturePb.SemeTimeRequest) error {
	currentUser, _ := s.GetCurrentSystemUser(ctx)
	if err := s.DB.Transaction(func(tx *gorm.DB) error {
		semeTime := model.NewEventSemeTime(currentUser, req)
		semeTimeFlow := model.NewEventSemeTimeFlow(semeTime.Id, req)
		if req.Form.Id > 0 {
			if err := tx.Model(new(model.EventSemeTime)).Where("id = ?", req.Form.Id).Updates(semeTime).Error; err != nil {
				return xerr.WithStack(err)
			}
			if err := tx.Model(new(model.EventSemeTimeFlow)).Where("seme_time_id = ?", req.Form.Id).Updates(semeTimeFlow).Error; err != nil {
				return xerr.WithStack(err)
			}
		} else {
			if err := tx.Create(&semeTime).Error; err != nil {
				return xerr.WithStack(err)
			}
			if err := tx.Create(&semeTimeFlow).Error; err != nil {
				return xerr.WithStack(err)
			}
		}

		return nil
	}); err != nil {
		return xerr.WithStack(err)
	}
	return nil
}

func (s *StoreEntry) SearchSemeTimeList(ctx context.Context, req *pasturePb.SearchNameRequest, pagination *pasturePb.PaginationModel) (*pasturePb.SemeTimeEventResponse, error) {
	semeTimeList := make([]*model.EventSemeTime, 0)
	var count int64 = 0
	pref := s.DB.Model(new(model.EventSemeTime)).
		Where("is_delete = ?", pasturePb.IsShow_Ok)
	if req.Name != "" {
		pref.Where("name like ?", fmt.Sprintf("%s%s%s", "%", req.Name, "%"))
	}

	if err := pref.Order("id desc").Count(&count).Limit(int(pagination.PageSize)).Offset(int(pagination.PageOffset)).
		Find(&semeTimeList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	weekMap := s.WeekMap()
	cowTypeMap := s.CowTypeMap()
	systemUser, _ := s.SystemUserList(ctx)
	return &pasturePb.SemeTimeEventResponse{
		Code:    http.StatusOK,
		Message: "ok",
		Data: &pasturePb.SearchSemeTimeData{
			List:     model.EventSemeTimeSlice(semeTimeList).ToPB(weekMap, cowTypeMap, systemUser),
			Total:    int32(count),
			PageSize: pagination.PageSize,
			Page:     pagination.Page,
		},
	}, nil
}

func (s *StoreEntry) SemeTimeDetail(ctx context.Context, semeTimeId int64) (*pasturePb.SemeTimeDetailResponse, error) {
	semeTime := &model.EventSemeTime{Id: semeTimeId}
	if err := s.DB.Model(new(model.EventSemeTime)).
		Where("is_delete = ?", pasturePb.IsShow_Ok).First(semeTime).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	semeTimeFlow := &model.EventSemeTimeFlow{}
	if err := s.DB.Model(new(model.EventSemeTimeFlow)).Where("seme_time_id = ?", semeTimeId).
		First(&semeTimeFlow).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	graph := &pasturePb.SemeTimeGraphData{}
	if err := json.Unmarshal([]byte(semeTimeFlow.OriginalFlowData), graph); err != nil {
		return nil, xerr.WithStack(err)
	}

	return &pasturePb.SemeTimeDetailResponse{
		Code:    http.StatusOK,
		Message: "ok",
		Data: &pasturePb.SemeTimeRequest{
			Form: &pasturePb.SemeTimeFormData{
				Id:             int32(semeTime.Id),
				Name:           semeTime.Name,
				WeekType:       semeTime.WeekType,
				PostpartumDays: semeTime.PostpartumDays,
				CowType:        semeTime.CowType,
				Remarks:        semeTime.Remarks,
			},
			Graph: graph,
		},
	}, nil
}

func (s *StoreEntry) SearchDiseaseList(ctx context.Context, req *pasturePb.SearchDiseaseRequest, pagination *pasturePb.PaginationModel) (*pasturePb.SearchDiseaseResponse, error) {
	diseaseList := make([]*model.Disease, 0)
	var count int64 = 0

	pref := s.DB.Model(new(model.Disease))
	if req.Name != "" {
		pref.Where("name like ?", fmt.Sprintf("%s%s%s", "%", req.Name, "%"))
	}

	if req.DiseaseTypeId > 0 {
		pref.Where("disease_type = ?", req.DiseaseTypeId)
	}

	if err := pref.Order("id desc").Count(&count).Limit(int(pagination.PageSize)).Offset(int(pagination.PageOffset)).
		Find(&diseaseList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	systemUserList, _ := s.SystemUserList(ctx)
	diseaseTypeList, _ := s.DiseaseTypeList(ctx)

	return &pasturePb.SearchDiseaseResponse{
		Code:    http.StatusOK,
		Message: "ok",
		Data: &pasturePb.SearchDiseaseData{
			List:     model.DiseaseSlice(diseaseList).ToPB(systemUserList, diseaseTypeList),
			Total:    int32(count),
			PageSize: pagination.PageSize,
			Page:     pagination.Page,
		},
	}, nil
}

func (s *StoreEntry) CreateOrUpdateDisease(ctx context.Context, req *pasturePb.SearchDiseaseList) error {
	currUser, _ := s.GetCurrentSystemUser(ctx)

	if req.Id > 0 {
		barn := &model.Disease{Id: int64(req.Id)}
		if err := s.DB.Model(&model.Disease{}).First(barn).Error; err != nil {
			if !errors.Is(err, gorm.ErrRecordNotFound) {
				return xerr.WithStack(err)
			}
		}
	}
	if err := s.DB.Model(&model.Disease{}).Where(map[string]interface{}{
		"id": req.Id,
	}).Assign(map[string]interface{}{
		"disease_type": req.DiseaseTypeId,
		"name":         req.Name,
		"symptoms":     strings.Join(req.Symptoms, "|"),
		"remarks":      req.Remarks,
		"is_show":      pasturePb.IsShow_Ok,
		"operation_id": currUser.Id,
	}).FirstOrCreate(&model.Disease{}).Error; err != nil {
		return xerr.WithStack(err)
	}
	return nil
}

func (s *StoreEntry) SearchDiseaseTypeList(ctx context.Context, req *pasturePb.SearchNameRequest, pagination *pasturePb.PaginationModel) (*pasturePb.SearchBaseConfigResponse, error) {
	diseaseTypeList := make([]*model.ConfigDiseaseType, 0)
	var count int64 = 0

	pref := s.DB.Model(new(model.ConfigDiseaseType))
	if req.Name != "" {
		pref.Where("name like ?", fmt.Sprintf("%s%s%s", "%", req.Name, "%"))
	}

	if err := pref.Order("id desc").Count(&count).Limit(int(pagination.PageSize)).Offset(int(pagination.PageOffset)).
		Find(&diseaseTypeList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	return &pasturePb.SearchBaseConfigResponse{
		Code:    http.StatusOK,
		Message: "ok",
		Data: &pasturePb.SearchBaseConfigData{
			List:     model.ConfigDiseaseTypeSlice(diseaseTypeList).ToPB(),
			Total:    int32(count),
			PageSize: pagination.PageSize,
			Page:     pagination.Page,
		},
	}, nil
}

func (s *StoreEntry) CreateOrUpdateDiseaseType(ctx context.Context, req *pasturePb.SearchBaseConfigList) error {
	if req.Id > 0 {
		barn := &model.ConfigDiseaseType{Id: int64(req.Id)}
		if err := s.DB.Model(&model.ConfigDiseaseType{}).First(barn).Error; err != nil {
			if !errors.Is(err, gorm.ErrRecordNotFound) {
				return xerr.WithStack(err)
			}
		}
	}

	if err := s.DB.Model(&model.ConfigDiseaseType{}).Where(map[string]interface{}{
		"id": req.Id,
	}).Assign(map[string]interface{}{
		"name":    req.Name,
		"remarks": req.Remarks,
		"is_show": pasturePb.IsShow_Ok,
	}).FirstOrCreate(&model.ConfigDiseaseType{}).Error; err != nil {
		return xerr.WithStack(err)
	}
	return nil
}