kpt-pasture/module/backend/data_warning.go

package backend

import (
	"context"
	"fmt"
	"kpt-pasture/model"
	"kpt-pasture/util"
	"strings"
	"time"

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

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

func (s *StoreEntry) TestDataWaring(ctx context.Context, userId int64) error {
	userModel, err := s.GetUserModel(ctx)
	if err != nil {
		return xerr.WithStack(err)
	}
	dataWarningList := make([]*model.DataWarning, 0)
	if err := s.DB.Model(new(model.DataWarning)).Where("user_id = ?", userId).Error; err != nil {
		return xerr.WithStack(err)
	}
	for _, v := range dataWarningList {
		a, params, err := s.BuildQuery(userModel, v.Id)
		if err != nil {
			return xerr.WithStack(err)
		}
		var count int64
		if err = s.DB.Model(new(model.Cow)).Where(a, params...).Count(&count).Error; err != nil {
			return xerr.WithStack(err)
		}
	}
	return nil
}

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

	hActiveOriginalList := make([]*model.HActiveOriginal, 0)
	if err := s.DB.Model(new(model.HActiveOriginal)).
		Where("intPastureId = ?", pastureId).
		Limit(int(pagination.PageSize)).
		Offset(int(pagination.PageOffset)).
		Find(&hActiveOriginalList).Error; err != nil {
		return xerr.WithStack(err)
	}

	neckRingOriginalList := make([]*model.NeckRingOriginal, 0)
	for _, v := range hActiveOriginalList {
		_, hours := util.GetNeckRingActiveTimer(v.FrameId)
		activeDate := ""
		if v.HeatDate != "" && len(v.HeatDate) > 10 {
			hd, _ := time.Parse(time.RFC3339, v.HeatDate)
			activeDate = hd.Format(model.LayoutDate2)
		}

		var count int64
		if err := s.DB.Model(new(model.NeckRingOriginal)).
			Where("pasture_id = ?", pastureId).
			Where("neck_ring_number = ?", v.EID1).
			Where("frameid = ?", v.FrameId).
			Where("active_date = ?", activeDate).
			Count(&count).Error; err != nil {
			return xerr.WithStack(err)
		}

		if count > 0 {
			continue
		}

		neckRingOriginalList = append(neckRingOriginalList,
			&model.NeckRingOriginal{
				PastureId:       pastureId,
				Uuid:            fmt.Sprintf("%d", v.UUID),
				NeckRingNumber:  fmt.Sprintf("%d", v.EID1),
				ActiveDate:      activeDate,
				Hours:           int32(hours),
				Frameid:         v.FrameId,
				Rumina:          v.Rumina,
				Intake:          v.Intake,
				Inactive:        v.Inactive,
				Gasp:            v.Gasp,
				High:            v.High,
				Active:          v.Active,
				Other:           v.Other,
				FirmwareVersion: 10,
				HardwareVersion: 57,
				Remain:          v.Remain,
				Voltage:         v.Voltage,
				RestartReason:   0,
				Upper:           1,
				ActiveDateType:  pasturePb.ActiveTimeType_Twenty_Minutes,
				IsShow:          pasturePb.IsShow_No,
				Imei:            fmt.Sprintf("%d", v.Imei),
				ReceiveNumber:   fmt.Sprintf("%d", v.Imei),
			})
	}
	if len(neckRingOriginalList) > 0 {
		if err := s.DB.Model(new(model.NeckRingOriginal)).
			Create(neckRingOriginalList).Error; err != nil {
			return xerr.WithStack(err)
		}
	}
	return nil
}

func (s *StoreEntry) BuildQuery(userModel *model.UserModel, warningId int64) (string, []interface{}, error) {
	conditionsMap := make(map[int32][]string)
	params := make([]interface{}, 0)
	res := make([]*model.DataWarningItems, 0)
	if err := s.DB.Model(new(model.DataWarningItems)).
		Where("warning_id = ?", warningId).
		Order("group_id").
		Find(&res).Error; err != nil {
		return "", nil, xerr.WithStack(err)
	}

	for _, v := range res {
		conditionsMap[v.GroupId] = append(conditionsMap[v.GroupId], fmt.Sprintf(" %s %s ? ", v.FieldName, v.Operator))
		params = append(params, v.Value)
	}

	if len(conditionsMap) == 0 {
		messageId, _ := userModel.LanguageContent.Localize(&i18n.LocalizeConfig{
			MessageID: "dataWarning.conditionGroupNotEmpty",
		})
		return "", nil, xerr.Custom(messageId)
	}

	var sqlConditions []string
	for _, groupConditions := range conditionsMap {
		if len(groupConditions) == 0 {
			continue // 跳过空组
		}

		// 同一个组内的条件用 OR 拼接
		groupQuery := strings.Join(groupConditions, " OR ")

		// 如果组内有多个条件，用括号包裹
		if len(groupConditions) > 1 {
			groupQuery = fmt.Sprintf("(%s)", groupQuery)
		}

		sqlConditions = append(sqlConditions, groupQuery)
	}

	return strings.Join(sqlConditions, " AND "), params, nil
}