kpt-pasture/module/backend/sql.go

package backend

import (
	"context"
	"errors"
	"fmt"
	"kpt-pasture/model"
	"strings"

	"github.com/nicksnyder/go-i18n/v2/i18n"

	"gitee.com/xuyiping_admin/pkg/logger/zaplog"
	"go.uber.org/zap"

	operationPb "gitee.com/xuyiping_admin/go_proto/proto/go/backend/operation"

	pasturePb "gitee.com/xuyiping_admin/go_proto/proto/go/backend/cow"
	"gitee.com/xuyiping_admin/pkg/xerr"
	"gorm.io/gorm"
)

func (s *StoreEntry) GetUserModel(ctx context.Context) (*model.UserModel, error) {
	systemUser, err := s.GetCurrentSystemUser(ctx)
	if err != nil {
		return nil, xerr.WithStack(err)
	}
	appPasture, err := s.GetCurrentFarmInfo(ctx)
	if err != nil {
		return nil, xerr.WithStack(err)
	}

	i18nTemplate, err := s.GetCurrentUserLanguage(ctx)
	if err != nil {
		return nil, xerr.WithStack(err)
	}

	systemUserPastureIds := strings.Split(systemUser.PastureIds, ",")
	if len(systemUserPastureIds) == 0 {
		message, _ := i18nTemplate.Localize(&i18n.LocalizeConfig{
			MessageID: "auth.unPasture",
		})
		return nil, xerr.Custom(message)
	}

	var info bool
	for _, v := range systemUserPastureIds {
		if v == fmt.Sprintf("%d", appPasture.Id) {
			info = true
		}
	}

	if !info {
		message, _ := i18nTemplate.Localize(&i18n.LocalizeConfig{
			MessageID: "auth.unPasture",
		})
		return nil, xerr.Custom(message)
	}

	return &model.UserModel{
		SystemUser:      systemUser,
		AppPasture:      appPasture,
		LanguageContent: i18nTemplate,
	}, nil
}

func (s *StoreEntry) GetCurrentSystemUser(ctx context.Context) (*model.SystemUser, error) {
	// 解析token
	userName, err := s.GetCurrentUserName(ctx)
	if err != nil {
		return nil, xerr.WithStack(err)
	}
	// 根据用户token获取用户数据
	systemUser := &model.SystemUser{Name: userName}
	if err = s.DB.Model(new(model.SystemUser)).
		Where("name = ?", userName).
		First(systemUser).Error; err != nil {
		zaplog.Error("GetCurrentSystemUser", zap.Any("err", err), zap.Any("userName", userName))

		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, xerr.Custom("当前登录用户数据不存在")
		} else {
			return nil, xerr.Custom("用户登录信息有误，请退出重新登录")
		}
	}
	if systemUser.IsDelete != pasturePb.IsShow_Ok {
		return nil, xerr.Custom("当前用户数据已经删除")
	}
	if systemUser.IsShow != pasturePb.IsShow_Ok {
		return nil, xerr.Custom("当前用户已禁用")
	}
	return systemUser, nil
}

func (s *StoreEntry) GetSystemUserDepthRole(ctx context.Context, pastureId, userId int64) (*model.SystemUserDepthRole, error) {
	systemUserDepthRole := &model.SystemUserDepthRole{}
	if err := s.DB.Model(new(model.SystemUserDepthRole)).
		Where("pasture_id = ?", pastureId).
		Where("user_id = ?", userId).
		First(&systemUserDepthRole).Error; err != nil {
		zaplog.Error("GetSystemUserDepthRole", zap.Any("err", err), zap.Any("pastureId", pastureId), zap.Any("userId", userId))

		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, xerr.Custom("当前用户未绑定角色数据，请重新绑定！")
		} else {
			return nil, xerr.Custom("用户信息有误")
		}
	}

	return systemUserDepthRole, nil
}

func (s *StoreEntry) GetCurrentFarmInfo(ctx context.Context) (*model.AppPastureList, error) {
	farmId := s.GetFarmId(ctx)
	if farmId == "" {
		return nil, xerr.Custom("请选择牧场信息")
	}
	appPasture, err := s.FindPastureByFarmId(ctx, farmId)
	if err != nil {
		return nil, xerr.WithStack(err)
	}
	return appPasture, nil
}

// GetCurrentUserName 获取当前用户名
func (s *StoreEntry) GetCurrentUserName(ctx context.Context) (string, error) {
	userNameInter := ctx.Value(CurrentUserName)
	if userNameInter == nil {
		return "", xerr.Customf("cannot userName")
	}

	if userName, ok := userNameInter.(string); ok {
		return userName, nil
	} else {
		return "", xerr.Customf("waring userName")
	}
}

// GetCurrentUserLanguage 获取用户系统语言
func (s *StoreEntry) GetCurrentUserLanguage(ctx context.Context) (*i18n.Localizer, error) {
	lg := ctx.Value(LanguageContent)
	if lg == nil {
		return nil, xerr.Customf("language error")
	}
	lag, ok := lg.(*i18n.Localizer)
	if !ok {
		return nil, xerr.Customf("language error")
	}
	return lag, nil
}

// GetFarmId 获取当前牧场Id
func (s *StoreEntry) GetFarmId(ctx context.Context) string {
	farmId := ctx.Value(CurrentFarmId)
	if farmId == nil {
		return ""
	}

	if farmIdStr, ok := farmId.(string); ok {
		return farmIdStr
	}
	return ""
}

func (s *StoreEntry) GetSystemUserById(ctx context.Context, userId int64) (*model.SystemUser, error) {
	systemUser := &model.SystemUser{Id: userId}
	if err := s.DB.Model(new(model.SystemUser)).First(systemUser).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, xerr.Customf("该系统用户数据不存在: %d", userId)
		}
		return nil, xerr.WithStack(err)
	}
	return systemUser, nil
}

func (s *StoreEntry) SystemDeptList(ctx context.Context, pastureId int64) ([]*model.SystemDept, error) {
	deptList := make([]*model.SystemDept, 0)
	if err := s.DB.Model(new(model.SystemDept)).
		Where("is_delete = ?", pasturePb.IsShow_Ok).
		Find(&deptList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}
	return deptList, nil
}

func (s *StoreEntry) GetPenById(ctx context.Context, pastureId int64, penId int32) (*model.Pen, error) {
	penData := &model.Pen{Id: penId}
	if err := s.DB.Model(new(model.Pen)).First(penData).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, xerr.Customf("该栏舍数据不存在: %d", penId)
		}
		return nil, xerr.WithStack(err)
	}
	return penData, nil
}

func (s *StoreEntry) GetPenList(ctx context.Context, pastureId int64) ([]*model.Pen, error) {
	penList := make([]*model.Pen, 0)
	if err := s.DB.Model(new(model.Pen)).
		Where("is_delete = ?", pasturePb.IsShow_Ok).
		Where("pasture_id = ?", pastureId).
		Find(&penList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}
	return penList, nil
}

func (s *StoreEntry) PenMap(ctx context.Context, pastureId int64) map[int32]*model.Pen {
	penList, err := s.GetPenList(ctx, pastureId)
	if err != nil {
		zaplog.Error("GetPenList", zap.Any("err", err), zap.Any("pastureId", pastureId))
	}
	penMap := make(map[int32]*model.Pen)
	for _, v := range penList {
		penMap[v.Id] = v
	}
	return penMap
}

func (s *StoreEntry) PenMap2(ctx context.Context, pastureId int64) map[string]*model.Pen {
	penList, err := s.GetPenList(ctx, pastureId)
	if err != nil {
		zaplog.Error("GetPenList", zap.Any("err", err), zap.Any("pastureId", pastureId))
	}
	penMap := make(map[string]*model.Pen)
	for _, v := range penList {
		penMap[v.Name] = v
	}
	return penMap
}

func (s *StoreEntry) GetCowInfoByEarNumber(ctx context.Context, pastureId int64, earNumber string) (*model.Cow, error) {
	cowInfo := &model.Cow{}
	if err := s.DB.Model(new(model.Cow)).
		Where("pasture_id = ?", pastureId).
		Where("ear_number = ?", earNumber).
		Where("admission_status = ?", pasturePb.AdmissionStatus_Admission).
		First(cowInfo).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, xerr.Customf("该牛只数据不存在: %s", earNumber)
		} else {
			return nil, xerr.WithStack(err)
		}
	}
	return cowInfo, nil
}

func (s *StoreEntry) GetCowEventByEarNumber(ctx context.Context, pastureId int64, earNumber string) (*model.Cow, error) {
	cowInfo := &model.Cow{}
	if err := s.DB.Model(new(model.Cow)).
		Where("pasture_id = ?", pastureId).
		Where("ear_number = ?", earNumber).
		First(cowInfo).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, xerr.Customf("该牛只数据不存在: %s", earNumber)
		} else {
			return nil, xerr.WithStack(err)
		}
	}
	return cowInfo, nil
}

func (s *StoreEntry) GetCowInfoByEarNumbers(ctx context.Context, pastureId int64, earNumbers []string) ([]*model.Cow, error) {
	cowList := make([]*model.Cow, 0)
	if err := s.DB.Model(new(model.Cow)).
		Where("pasture_id = ?", pastureId).
		Where("ear_number IN (?)", earNumbers).
		Where("admission_status = ?", pasturePb.AdmissionStatus_Admission).
		Find(&cowList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}
	return cowList, nil
}

func (s *StoreEntry) GetCowInfoByCowId(ctx context.Context, pastureId, cowId int64) (*model.Cow, error) {
	cowData := &model.Cow{Id: cowId}
	if err := s.DB.Model(new(model.Cow)).
		Where("pasture_id = ?", pastureId).
		Where("admission_status = ?", pasturePb.AdmissionStatus_Admission).
		First(cowData).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, xerr.Customf("该牛只数据不存在: %d", cowId)
		} else {
			return nil, xerr.WithStack(err)
		}
	}
	return cowData, nil
}

func (s *StoreEntry) GetCowInfoByCowIds(ctx context.Context, pastureId int64, cowIds []int64) ([]*model.Cow, error) {
	cowList := make([]*model.Cow, 0)
	if err := s.DB.Model(&model.Cow{}).
		Where("pasture_id = ?", pastureId).
		Where("admission_status = ?", pasturePb.AdmissionStatus_Admission).
		Where("id IN ?", cowIds).
		Find(&cowList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}
	return cowList, nil
}

func (s *StoreEntry) GetTransferReasonInfo(ctx context.Context, reasonId int64) (*model.ConfigTransferPenReason, error) {
	configTransferPenReasonData := &model.ConfigTransferPenReason{
		Id: reasonId,
	}
	if err := s.DB.Model(new(model.ConfigTransferPenReason)).First(configTransferPenReasonData).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, xerr.Customf("该转群原因数据不存在: %d", reasonId)
		}
		return nil, xerr.WithStack(err)
	}
	return configTransferPenReasonData, nil
}

func (s *StoreEntry) GetCowWeightByLastSecond(ctx context.Context, pastureId, cowId, lastWeightAt int64) (*model.EventWeight, error) {
	cowWeightData := &model.EventWeight{}
	if err := s.DB.Model(new(model.EventWeight)).
		Where("pasture_id = ?", pastureId).
		Where("cow_id = ?", cowId).
		Where("weight_at < ?", lastWeightAt).
		First(cowWeightData).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, xerr.Customf("该牛只体重数据不存在: %d", cowId)
		}
		return nil, xerr.WithStack(err)
	}
	return cowWeightData, nil
}

func (s *StoreEntry) GetDrugsById(ctx context.Context, pastureId, drugsId int64) (*model.Drugs, error) {
	drugs := &model.Drugs{Id: drugsId}
	if err := s.DB.Model(new(model.Drugs)).
		Where("pasture_id = ?", pastureId).
		First(drugs).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, xerr.Customf("该药品数据不存在: %d", drugsId)
		}
		return nil, xerr.WithStack(err)
	}
	return drugs, nil
}

func (s *StoreEntry) DiseaseTypeList(ctx context.Context) ([]*model.ConfigDiseaseType, error) {
	diseaseTypeList := make([]*model.ConfigDiseaseType, 0)
	if err := s.DB.Model(new(model.ConfigDiseaseType)).
		Where("is_show = ?", pasturePb.IsShow_Ok).
		Find(&diseaseTypeList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}
	return diseaseTypeList, nil
}

func (s *StoreEntry) GetDiseaseById(ctx context.Context, pastureId int64, diseaseId int32) (*model.Disease, error) {
	newDisease := &model.Disease{}
	if err := s.DB.Model(new(model.Disease)).
		Where("pasture_id = ?", pastureId).
		Where("is_show = ?", pasturePb.IsShow_Ok).
		Where("id = ?", diseaseId).
		First(newDisease).Error; err != nil {
		return nil, xerr.WithStack(err)
	}
	return newDisease, nil
}

func (s *StoreEntry) DiseaseListByIds(ctx context.Context, pastureId int64, ids []int32) ([]*model.Disease, error) {
	diseaseList := make([]*model.Disease, 0)
	if err := s.DB.Model(new(model.Disease)).
		Where("pasture_id = ?", pastureId).
		Where("is_show = ?", pasturePb.IsShow_Ok).
		Where("id IN ?", ids).Find(&diseaseList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}
	return diseaseList, nil
}

func (s *StoreEntry) GetPrescriptionById(ctx context.Context, pastureId int64, id int32) (*model.Prescription, error) {
	newPrescription := &model.Prescription{}
	if err := s.DB.Model(new(model.Prescription)).
		Where("id = ?", id).
		Where("pasture_id = ?", pastureId).
		Where("is_show = ?", pasturePb.IsShow_Ok).
		First(&newPrescription).Error; err != nil {
		return nil, xerr.WithStack(err)
	}
	return newPrescription, nil
}

func (s *StoreEntry) PrescriptionDrugsByPrescriptionId(ctx context.Context, pastureId int64, prescriptionId int32) ([]*model.PrescriptionDrugs, error) {
	newPrescriptionDrugsList := make([]*model.PrescriptionDrugs, 0)
	if err := s.DB.Model(new(model.PrescriptionDrugs)).
		Where("pasture_id = ?", pastureId).
		Where("prescription_id = ?", prescriptionId).
		Where("is_show = ?", pasturePb.IsShow_Ok).
		Find(&newPrescriptionDrugsList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}
	return newPrescriptionDrugsList, nil
}

func (s *StoreEntry) GetImmunizationById(ctx context.Context, pastureId, planId int64) (*model.ImmunizationPlan, error) {
	immunizationPlan := &model.ImmunizationPlan{Id: planId}
	if err := s.DB.Model(new(model.ImmunizationPlan)).
		Where("pasture_id = ?", pastureId).
		Where("is_show = ?", pasturePb.IsShow_Ok).
		First(immunizationPlan).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, xerr.Customf("该免疫计划不存在: %d", planId)
		}
		return nil, xerr.WithStack(err)
	}
	return immunizationPlan, nil
}

func (s *StoreEntry) GetWorkOrderSubByWorkOrderId(ctx context.Context, workOrderId int64) ([]*model.WorkOrderSub, error) {
	workOrderSubList := make([]*model.WorkOrderSub, 0)
	if err := s.DB.Model(new(model.WorkOrderSub)).
		Where("work_order_id = ?", workOrderId).
		Find(&workOrderSubList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}
	return workOrderSubList, nil
}

func (s *StoreEntry) GetEventCowSameTimeByCowId(ctx context.Context, pastureId, cowId int64) (*model.EventCowSameTime, error) {
	eventCowSameTime := &model.EventCowSameTime{}
	if err := s.DB.Model(new(model.EventCowSameTime)).
		Where("cow_id = ?", cowId).
		Where("pasture_id = ?", pastureId).
		Where("status = ?", pasturePb.IsShow_No).
		First(eventCowSameTime).Error; err != nil {
		return nil, xerr.WithStack(err)
	}
	return eventCowSameTime, nil
}

func (s *StoreEntry) SearchSystemDeptListByIds(ctx context.Context, pastureId int64, ids []int64) ([]*model.SystemDept, error) {
	systemDeptList := make([]*model.SystemDept, 0)
	if err := s.DB.Model(new(model.SystemDept)).
		Where("pasture_id = ?", pastureId).
		Where("is_show = ?", operationPb.IsShow_OK).
		Find(&systemDeptList, ids).Error; err != nil {
		return nil, xerr.WithStack(err)
	}
	return systemDeptList, nil
}

func (s *StoreEntry) GetSystemDeptListById(ctx context.Context, id int64) (*model.SystemDept, error) {
	systemDept := &model.SystemDept{Id: id}
	if err := s.DB.Model(new(model.SystemDept)).First(systemDept).Error; err != nil {
		return nil, xerr.WithStack(err)
	}
	return systemDept, nil
}

func (s *StoreEntry) GetSystemBasicByName(ctx context.Context, pastureId int64, name string) (*model.SystemBasic, error) {
	systemBasic := &model.SystemBasic{}
	if err := s.DB.Model(new(model.SystemBasic)).
		Where("name = ?", name).
		Where("is_show = ?", pasturePb.IsShow_Ok).
		First(systemBasic).Error; err != nil {
		return nil, xerr.WithStack(err)
	}
	return systemBasic, nil
}