package model
|
|
import (
|
"apsClient/pkg/logx"
|
"apsClient/pkg/sqlitex"
|
"encoding/json"
|
"fmt"
|
"github.com/jinzhu/gorm"
|
)
|
|
type (
|
// ProcessModel 工艺参数
|
ProcessModel struct {
|
gorm.Model
|
Number string `gorm:"index;column:number;type:varchar(255);not null;default ''" json:"number"` //工艺模型编号
|
Product string `gorm:"column:product;type:varchar(255);not null;default ''" json:"product"` //产品名称
|
Procedure string `gorm:"column:procedure;type:varchar(255);not null;default ''" json:"procedure"` //工序
|
Params string
|
ParamsMap map[string]interface{} `json:"paramsMap" gorm:"-"`
|
DeviceId string `json:"deviceId" gorm:"-"` //用于过滤获取nsq消息
|
IsNew bool `json:"-" gorm:"column:is_new"` //是否最新的
|
IsUpdate bool `json:"isUpdate" gorm:"-"` //前端用
|
NewParamsMap map[string]interface{} `json:"newParamsMap" gorm:"-"`
|
NewNumber string `json:"newNumber" gorm:"-"`
|
}
|
|
ProcessModelSearch struct {
|
ProcessModel
|
Order string
|
Limit int
|
Offset int
|
Orm *gorm.DB
|
Procedures []string
|
CurrentNumber string
|
Numbers []string
|
}
|
)
|
|
func (slf *ProcessModel) TableName() string {
|
return "process_model"
|
}
|
|
func (slf *ProcessModel) AfterFind(db *gorm.DB) error {
|
err := json.Unmarshal([]byte(slf.Params), &slf.ParamsMap)
|
if err != nil {
|
logx.Errorf("process model json.Unmarshal:%v", err)
|
return err
|
}
|
return nil
|
}
|
|
func NewProcessModelSearch() *ProcessModelSearch {
|
return &ProcessModelSearch{Orm: sqlitex.GetDB()}
|
}
|
|
func (slf *ProcessModelSearch) SetOrm(tx *gorm.DB) *ProcessModelSearch {
|
slf.Orm = tx
|
return slf
|
}
|
|
func (slf *ProcessModelSearch) SetPage(offset, limit int) *ProcessModelSearch {
|
slf.Offset, slf.Limit = offset, limit
|
return slf
|
}
|
|
func (slf *ProcessModelSearch) SetOrder(order string) *ProcessModelSearch {
|
slf.Order = order
|
return slf
|
}
|
|
func (slf *ProcessModelSearch) SetID(id uint) *ProcessModelSearch {
|
slf.ID = id
|
return slf
|
}
|
|
func (slf *ProcessModelSearch) SetNumber(number string) *ProcessModelSearch {
|
slf.Number = number
|
return slf
|
}
|
|
func (slf *ProcessModelSearch) SetNumbers(numbers []string) *ProcessModelSearch {
|
slf.Numbers = numbers
|
return slf
|
}
|
|
func (slf *ProcessModelSearch) SetCurrentNumber(number string) *ProcessModelSearch {
|
slf.CurrentNumber = number
|
return slf
|
}
|
|
func (slf *ProcessModelSearch) SetProduct(product string) *ProcessModelSearch {
|
slf.Product = product
|
return slf
|
}
|
|
func (slf *ProcessModelSearch) SetProcedure(procedure string) *ProcessModelSearch {
|
slf.Procedure = procedure
|
return slf
|
}
|
|
func (slf *ProcessModelSearch) SetProcedures(procedures []string) *ProcessModelSearch {
|
slf.Procedures = procedures
|
return slf
|
}
|
|
func (slf *ProcessModelSearch) SetIsNew(isNew bool) *ProcessModelSearch {
|
slf.IsNew = isNew
|
return slf
|
}
|
|
func (slf *ProcessModelSearch) build() *gorm.DB {
|
var db = slf.Orm.Table(slf.TableName())
|
|
if slf.ID != 0 {
|
db = db.Where("id = ?", slf.ID)
|
}
|
|
if len(slf.Product) != 0 {
|
db = db.Where("product = ?", slf.Product)
|
}
|
|
if len(slf.Procedure) != 0 {
|
db = db.Where("`procedure` = ?", slf.Procedure)
|
}
|
|
if len(slf.Procedures) != 0 {
|
db = db.Where("`procedure` IN (?)", slf.Procedures)
|
}
|
|
if len(slf.Number) != 0 {
|
db = db.Where("number = ?", slf.Number)
|
}
|
|
if slf.Order != "" {
|
db = db.Order(slf.Order)
|
}
|
|
if slf.IsNew {
|
db = db.Where("is_new = ?", 1)
|
}
|
|
if len(slf.CurrentNumber) != 0 {
|
db = db.Where("number != ?", slf.CurrentNumber)
|
}
|
|
if len(slf.Numbers) != 0 {
|
db = db.Where("number in (?)", slf.Numbers)
|
}
|
|
return db
|
}
|
|
// Create 单条插入
|
func (slf *ProcessModelSearch) Create(record *ProcessModel) error {
|
var db = slf.build()
|
|
if err := db.Create(record).Error; err != nil {
|
return fmt.Errorf("create err: %v, record: %+v", err, record)
|
}
|
|
return nil
|
}
|
|
func (slf *ProcessModelSearch) Save(record *ProcessModel) error {
|
var db = slf.build()
|
|
if err := db.Omit("CreatedAt").Save(record).Error; err != nil {
|
return fmt.Errorf("save err: %v, record: %+v", err, record)
|
}
|
|
return nil
|
}
|
|
func (slf *ProcessModelSearch) UpdateByMap(upMap map[string]interface{}) error {
|
var (
|
db = slf.build()
|
)
|
|
if err := db.Updates(upMap).Error; err != nil {
|
return fmt.Errorf("update by map err: %v, upMap: %+v", err, upMap)
|
}
|
|
return nil
|
}
|
|
func (slf *ProcessModelSearch) UpdateByQuery(query string, args []interface{}, upMap map[string]interface{}) error {
|
var (
|
db = slf.Orm.Table(slf.TableName()).Where(query, args...)
|
)
|
|
if err := db.Updates(upMap).Error; err != nil {
|
return fmt.Errorf("update by query err: %v, query: %s, args: %+v, upMap: %+v", err, query, args, upMap)
|
}
|
|
return nil
|
}
|
|
func (slf *ProcessModelSearch) Delete() error {
|
var db = slf.build()
|
|
if err := db.Unscoped().Delete(&ProcessModel{}).Error; err != nil {
|
return err
|
}
|
|
return nil
|
}
|
|
func (slf *ProcessModelSearch) First() (*ProcessModel, error) {
|
var (
|
record = new(ProcessModel)
|
db = slf.build()
|
)
|
|
if err := db.First(record).Error; err != nil {
|
return record, err
|
}
|
|
return record, nil
|
}
|
|
func (slf *ProcessModelSearch) Find() ([]*ProcessModel, int64, error) {
|
var (
|
records = make([]*ProcessModel, 0)
|
total int64
|
db = slf.build()
|
)
|
|
if err := db.Count(&total).Error; err != nil {
|
return records, total, fmt.Errorf("find count err: %v", err)
|
}
|
if slf.Offset > 0 || slf.Limit > 0 {
|
db = db.Offset(slf.Offset).Limit(slf.Limit)
|
}
|
if err := db.Find(&records).Error; err != nil {
|
return records, total, fmt.Errorf("find records err: %v", err)
|
}
|
|
return records, total, nil
|
}
|
|
func (slf *ProcessModelSearch) FindNotTotal() ([]*ProcessModel, error) {
|
var (
|
records = make([]*ProcessModel, 0)
|
db = slf.build()
|
)
|
|
if slf.Offset > 0 || slf.Limit > 0 {
|
db = db.Offset(slf.Offset).Limit(slf.Limit)
|
}
|
if err := db.Find(&records).Error; err != nil {
|
return records, fmt.Errorf("find records err: %v", err)
|
}
|
|
return records, nil
|
}
|
|
// FindByQuery 指定条件查询.
|
func (slf *ProcessModelSearch) FindByQuery(query string, args []interface{}) ([]*ProcessModel, int64, error) {
|
var (
|
records = make([]*ProcessModel, 0)
|
total int64
|
db = slf.Orm.Table(slf.TableName()).Where(query, args...)
|
)
|
|
if err := db.Count(&total).Error; err != nil {
|
return records, total, fmt.Errorf("find by query count err: %v", err)
|
}
|
if slf.Offset > 0 || slf.Limit > 0 {
|
db = db.Offset(slf.Offset).Limit(slf.Limit)
|
}
|
if err := db.Find(&records).Error; err != nil {
|
return records, total, fmt.Errorf("find by query records err: %v, query: %s, args: %+v", err, query, args)
|
}
|
|
return records, total, nil
|
}
|
|
// FindByQueryNotTotal 指定条件查询&不查询总条数.
|
func (slf *ProcessModelSearch) FindByQueryNotTotal(query string, args []interface{}) ([]*ProcessModel, error) {
|
var (
|
records = make([]*ProcessModel, 0)
|
db = slf.Orm.Table(slf.TableName()).Where(query, args...)
|
)
|
|
if slf.Offset > 0 || slf.Limit > 0 {
|
db = db.Offset(slf.Offset).Limit(slf.Limit)
|
}
|
if err := db.Find(&records).Error; err != nil {
|
return records, fmt.Errorf("find by query records err: %v, query: %s, args: %+v", err, query, args)
|
}
|
|
return records, nil
|
}
|
