fix

zhangqian

2023-12-01 8324f872ef3a4d0c978a9b1d062800c6a1701c12

 model/device.go

New file
@@ -0,0 +1,246 @@
package model

import (
   "apsClient/pkg/sqlitex"
   "fmt"
   "github.com/jinzhu/gorm"
   "strings"
)

type (
   // Device 设备
   Device struct {
      gorm.Model
      DeviceID             string   `gorm:"column:device_id;type:varchar(255);not null;unique" json:"deviceID"` //设备编号
      DeviceName           string   `gorm:"column:device_name;type:varchar(255);" json:"deviceName"`            //设备名称
      ExtChannelAmount     int      `gorm:"type:tinyint;default:0" json:"extChannelAmount"`
      Procedures           string   `gorm:"column:procedure;type:varchar(255);not null;default ''" json:"procedures"` //设备支持的工序，用逗号分隔
      DeviceMac            string   `gorm:"type:varchar(255);" json:"deviceMac"`                                      //绑定的工控机设备ID
      ProceduresArr        []string `gorm:"-" json:"ProceduresArr"`                                                   //设备支持的工序切片
      NeedSetProcessParams bool     `gorm:"column:need_set_process_params" json:"needSetProcessParams"`               //是否需要设置工艺参数                                          //设备支持的工序切片
   }

   DeviceSearch struct {
      Device
      Order     string
      PageNum   int
      PageSize  int
      Orm       *gorm.DB
      DeviceIDs []string
   }
)

func (slf *Device) TableName() string {
   return "device"
}

func (slf *Device) AfterFind(db *gorm.DB) error {
   slf.ProceduresArr = strings.Split(slf.Procedures, ",")
   return nil
}

func NewDeviceSearch() *DeviceSearch {
   return &DeviceSearch{Orm: sqlitex.GetDB()}
}

func (slf *DeviceSearch) SetOrm(tx *gorm.DB) *DeviceSearch {
   slf.Orm = tx
   return slf
}

func (slf *DeviceSearch) SetPage(page, size int) *DeviceSearch {
   slf.PageNum, slf.PageSize = page, size
   return slf
}

func (slf *DeviceSearch) SetOrder(order string) *DeviceSearch {
   slf.Order = order
   return slf
}

func (slf *DeviceSearch) SetID(id uint) *DeviceSearch {
   slf.ID = id
   return slf
}

func (slf *DeviceSearch) SetDeviceId(deviceId string) *DeviceSearch {
   slf.DeviceID = deviceId
   return slf
}

func (slf *DeviceSearch) SetDeviceMac(deviceMac string) *DeviceSearch {
   slf.DeviceMac = deviceMac
   return slf
}

func (slf *DeviceSearch) SetDeviceIds(deviceIds []string) *DeviceSearch {
   slf.DeviceIDs = deviceIds
   return slf
}

func (slf *DeviceSearch) build() *gorm.DB {
   var db = slf.Orm.Table(slf.TableName())

   if slf.ID != 0 {
      db = db.Where("id = ?", slf.ID)
   }

   if len(slf.DeviceID) != 0 {
      db = db.Where("device_id = ?", slf.DeviceID)
   }

   if slf.DeviceMac != "" {
      db = db.Where("device_mac = ?", slf.DeviceMac)
   }

   if len(slf.DeviceIDs) != 0 {
      db = db.Where("device_id in (?)", slf.DeviceIDs)
   }

   if slf.Order != "" {
      db = db.Order(slf.Order)
   }

   return db
}

// Create 单条插入
func (slf *DeviceSearch) Create(record *Device) 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 *DeviceSearch) Save(record *Device) error {
   var db = slf.build()

   if err := db.Updates(record).Error; err != nil {
      return fmt.Errorf("create err: %v, record: %+v", err, record)
   }
   return nil
}

func (slf *DeviceSearch) 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 *DeviceSearch) 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 *DeviceSearch) Delete() error {
   var db = slf.build()

   if err := db.Unscoped().Delete(&Device{}).Error; err != nil {
      return err
   }

   return nil
}

func (slf *DeviceSearch) First() (*Device, error) {
   var (
      record = new(Device)
      db     = slf.build()
   )

   if err := db.First(record).Error; err != nil {
      return record, err
   }

   return record, nil
}

func (slf *DeviceSearch) Find() ([]*Device, int64, error) {
   var (
      records = make([]*Device, 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.PageNum*slf.PageSize > 0 {
      db = db.Offset((slf.PageNum - 1) * slf.PageSize).Limit(slf.PageSize)
   }
   if err := db.Find(&records).Error; err != nil {
      return records, total, fmt.Errorf("find records err: %v", err)
   }

   return records, total, nil
}

func (slf *DeviceSearch) FindNotTotal() ([]*Device, error) {
   var (
      records = make([]*Device, 0)
      db      = slf.build()
   )

   if slf.PageNum*slf.PageSize > 0 {
      db = db.Offset((slf.PageNum - 1) * slf.PageSize).Limit(slf.PageSize)
   }
   if err := db.Find(&records).Error; err != nil {
      return records, fmt.Errorf("find records err: %v", err)
   }

   return records, nil
}

// FindByQuery 指定条件查询.
func (slf *DeviceSearch) FindByQuery(query string, args []interface{}) ([]*Device, int64, error) {
   var (
      records = make([]*Device, 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.PageNum*slf.PageSize > 0 {
      db = db.Offset((slf.PageNum - 1) * slf.PageSize).Limit(slf.PageSize)
   }
   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 *DeviceSearch) FindByQueryNotTotal(query string, args []interface{}) ([]*Device, error) {
   var (
      records = make([]*Device, 0)
      db      = slf.Orm.Table(slf.TableName()).Where(query, args...)
   )

   if slf.PageNum*slf.PageSize > 0 {
      db = db.Offset((slf.PageNum - 1) * slf.PageSize).Limit(slf.PageSize)
   }
   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
}