test_data/repository/test.data/warning.go

package test_data

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

func UpdateWarning(req *model.Warning) error {
	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
	}
	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
	}
	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
	}
	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
	}
	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
}

func UpdateWarningFactory(req *model.ProductionControl) error {
	var warning *model.ProductionControl
	if errors.Is(global.PostGreSQL.Where("factory = ?", req.Factory).First(&warning).Error, gorm.ErrRecordNotFound) {
		global.PostGreSQL.Create(&model.ProductionControl{
			Factory:           req.Factory,
			TestQuantityDiffH: req.TestQuantityDiffH,
			TestQuantityDiffL: req.TestQuantityDiffL,
			PassQuantityDiffH: req.PassQuantityDiffH,
			PassQuantityDiffL: req.PassQuantityDiffL,
		})
	} else {
		global.PostGreSQL.Model(&warning).Updates(map[string]interface{}{
			"test_quantity_diff_h": req.TestQuantityDiffH,
			"test_quantity_diff_l": req.TestQuantityDiffL,
			"pass_quantity_diff_h": req.PassQuantityDiffH,
			"pass_quantity_diff_l": req.PassQuantityDiffL,
		})
	}
	return nil
}

func ShowListWarningFactory(offset, limit int, keyWord string) ([]*model.ProductionControl, int64, error) {
	var warnings []*model.ProductionControl
	var total int64
	if keyWord == "" {
		global.PostGreSQL.Find(&warnings).
			Count(&total).Offset(offset).Limit(limit).Find(&warnings)
	} else {
		global.PostGreSQL.Where("factory LIKE ?", keyWord).Find(&warnings).
			Count(&total).Offset(offset).Limit(limit).Find(&warnings)
	}
	return warnings, total, nil
}

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