test_data/repository/test.data/warning.go

package test_data

import (
	"errors"
	"gorm.io/gorm"
	"strconv"
	"testData/global"
	"testData/model"
)

func UpdateWarning(req *model.Warning) error {
	_, err := strconv.ParseFloat(req.FirstPassProbabilityLimitL, 64)
	if err != nil {
		return errors.New("一次通过率下限必须是数字")
	}
	_, err = strconv.ParseFloat(req.ReturnProbabilityLimitH, 64)
	if err != nil {
		return errors.New("回收率上限必须是数字")
	}
	_, err = strconv.ParseFloat(req.PassProbabilityLimitL, 64)
	if err != nil {
		return errors.New("良率下限必须是数字")
	}
	_, err = strconv.ParseFloat(req.AveragePassProbability, 64)
	if err != nil {
		return errors.New("平均良率必须是数字")
	}
	var warning *model.Warning
	if errors.Is(global.PostGreSQL.Where("product = ? AND step = ?", req.Product, req.Step).First(&warning).Error, gorm.ErrRecordNotFound) {
		global.PostGreSQL.Create(&model.Warning{
			Product:                    req.Product,
			Step:                       req.Step,
			FirstPassProbabilityLimitL: req.FirstPassProbabilityLimitL,
			ReturnProbabilityLimitH:    req.ReturnProbabilityLimitH,
			PassProbabilityLimitL:      req.PassProbabilityLimitL,
			AveragePassProbability:     req.AveragePassProbability,
		})
		global.PostGreSQL.Where("product = ? AND step = ?", req.Product, req.Step).Find(&warning)
	} else {
		global.PostGreSQL.Model(&warning).Updates(map[string]interface{}{
			"first_pass_probability_limit_l": req.FirstPassProbabilityLimitL,
			"return_probability_limit_h":     req.ReturnProbabilityLimitH,
			"pass_probability_limit_l":       req.PassProbabilityLimitL,
			"average_pass_probability":       req.AveragePassProbability,
		})
	}
	//for k := range req.ProductionControl {
	//	req.ProductionControl[k].ID = 0
	//	req.ProductionControl[k].WarningID = warning.ID
	//}
	//global.PostGreSQL.Where("warning_id = ?", warning.ID).Delete(&model.ProductionControl{})
	//global.PostGreSQL.Create(&req.ProductionControl)
	for k := range req.PassProbabilityDiff {
		req.PassProbabilityDiff[k].ID = 0
		req.PassProbabilityDiff[k].WarningID = warning.ID
		_, err = strconv.ParseFloat(req.PassProbabilityDiff[k].SitePassProbabilityDiff, 64)
		if err != nil {
			return errors.New("良率差异设置必须是数字")
		}
		_, err = strconv.ParseFloat(req.PassProbabilityDiff[k].PassProbabilityDiff, 64)
		if err != nil {
			return errors.New("良率差异设置必须是数字")
		}
		_, err = strconv.ParseFloat(req.PassProbabilityDiff[k].PassProbabilityWave, 64)
		if err != nil {
			return errors.New("良率差异设置必须是数字")
		}
	}
	global.PostGreSQL.Where("warning_id = ?", warning.ID).Delete(&model.PassProbabilityDiff{})
	global.PostGreSQL.Create(&req.PassProbabilityDiff)
	for k := range req.BinControl {
		req.BinControl[k].ID = 0
		req.BinControl[k].WarningID = warning.ID
		_, err = strconv.ParseFloat(req.BinControl[k].BinFailLimitH, 64)
		if err != nil {
			return errors.New("关键BIN设置必须是数字")
		}
	}
	global.PostGreSQL.Where("warning_id = ?", warning.ID).Delete(&model.BinControl{})
	global.PostGreSQL.Create(&req.BinControl)
	for k := range req.SelectionDiffControl {
		req.SelectionDiffControl[k].ID = 0
		req.SelectionDiffControl[k].WarningID = warning.ID
		_, err = strconv.ParseFloat(req.SelectionDiffControl[k].SiteDiff, 64)
		if err != nil {
			return errors.New("参数允许差异设置必须是数字")
		}
		_, err = strconv.ParseFloat(req.SelectionDiffControl[k].SubBatchDiff, 64)
		if err != nil {
			return errors.New("参数允许差异设置必须是数字")
		}
	}
	global.PostGreSQL.Where("warning_id = ?", warning.ID).Delete(&model.SelectionDiffControl{})
	global.PostGreSQL.Create(&req.SelectionDiffControl)
	for k := range req.StackingMaterialsWarning {
		req.StackingMaterialsWarning[k].ID = 0
		req.StackingMaterialsWarning[k].WarningID = warning.ID
		_, err = strconv.ParseFloat(req.StackingMaterialsWarning[k].Diff, 64)
		if err != nil {
			return errors.New("叠料报警设置必须是数字")
		}
	}
	global.PostGreSQL.Where("warning_id = ?", warning.ID).Delete(&model.StackingMaterialsWarning{})
	global.PostGreSQL.Create(&req.StackingMaterialsWarning)
	for k := range req.HistogramSelection {
		req.HistogramSelection[k].ID = 0
		req.HistogramSelection[k].WarningID = warning.ID
	}
	global.PostGreSQL.Where("warning_id = ?", warning.ID).Delete(&model.HistogramSelection{})
	global.PostGreSQL.Create(&req.HistogramSelection)
	for k := range req.ScatterSelection {
		req.ScatterSelection[k].ID = 0
		req.ScatterSelection[k].WarningID = warning.ID
	}
	global.PostGreSQL.Where("warning_id = ?", warning.ID).Delete(&model.ScatterSelection{})
	global.PostGreSQL.Create(&req.ScatterSelection)
	return nil
}

func ShowListWarning(offset, limit int, keyWord string) ([]*model.Warning, int64, error) {
	var warnings []*model.Warning
	var total int64
	if keyWord == "" {
		global.PostGreSQL.Find(&warnings).
			Count(&total).Offset(offset).Limit(limit).
			Preload("ProductionControl").Preload("PassProbabilityDiff").Preload("BinControl").
			Preload("SelectionDiffControl").Preload("StackingMaterialsWarning").Preload("HistogramSelection").
			Preload("ScatterSelection").Find(&warnings)
	} else {
		global.PostGreSQL.Where("product LIKE ?", keyWord).Find(&warnings).
			Count(&total).Offset(offset).Limit(limit).Find(&warnings)
	}
	return warnings, total, nil
}

func DeleteWarning(req *model.Warning) error {
	var warning *model.Warning
	if errors.Is(global.PostGreSQL.First(&warning, req.ID).Error, gorm.ErrRecordNotFound) {
		return errors.New("未找到需要删除的型号信息")
	}
	global.PostGreSQL.Delete(&warning)
	return nil
}