工艺参数地址表从文件里获取改成从数据库查询

zhangqian

2023-11-03 f008bf77342a93c13d1e42399dd175c9c941d3ef

工艺参数地址表从文件里获取改成从数据库查询

 api/v1/task.go

@@ -10,7 +10,6 @@
    "apsClient/pkg/ecode"
    "apsClient/pkg/logx"
    "apsClient/service"
    "apsClient/service/plc_address"
    "errors"
    "github.com/gin-gonic/gin"
    "github.com/jinzhu/gorm"
@@ -392,8 +391,12 @@
        logx.Info("----------------开始下发工艺参数-----------------")
    }
    var failedNumbers int
    processModelAddress, err := service.GetProcessModelAddress(conf.Conf.CurrentDeviceID)
    if err != nil {
        return err
    }
    for k, v := range paramsMap {
        address, ok := plc_address.Get(k)
        address, ok := processModelAddress[k]
        if !ok {
            logx.Errorf("miss param address, k:%v, v:%v", k, v)
            continue

 main.go

@@ -11,7 +11,6 @@
    "apsClient/router"
    "apsClient/serf"
    "apsClient/service"
    "apsClient/service/plc_address"
    "fmt"
    "log"
    "net/http"
@@ -29,7 +28,7 @@
    }

    //加载plc写入地址
    plc_address.LoadAddressFromFile()
    //plc_address.LoadAddressFromFile()

    // 启动数据同步
    var serfStartChan = make(chan bool)

 model/common/common.go

@@ -147,6 +147,7 @@
const (
    PullDataTypeProcessModel = "process_model"
    PullDataTypeDevice       = "device"
    PullDataTypeProcessModelPlcAddress = "process_model_plc_address"
)

// MsgPullDataRequest 拉取云端数据

 model/process_model_plc_address.go

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

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

type (
    ProcessModelAddress struct {
        Name    string `json:"name,omitempty"`
        Address int    `json:"address,omitempty"`
    }

    // ProcessModelPlcAddress 工艺参数plc读写地址
    ProcessModelPlcAddress struct {
        ID          uint                   `gorm:"primaryKey;" json:"id"`
        AddressList []*ProcessModelAddress `json:"addressList" gorm:"-"`
        Address     string                 `json:"-" gorm:"address"`
        DeviceID    string                 `json:"deviceId" gorm:"column:deviceId;index;type:varchar(255)"`
    }

    ProcessModelPlcAddressSearch struct {
        ProcessModelPlcAddress
        Order     string
        PageNum   int
        PageSize  int
        Keyword   string
        Orm       *gorm.DB
        DeviceIDs []string
    }
)

func (slf *ProcessModelPlcAddress) TableName() string {
    return "process_model"
}

func (slf *ProcessModelPlcAddress) AfterFind(*gorm.DB) error {
    if slf.Address != "" {
        return json.Unmarshal([]byte(slf.Address), &slf.AddressList)
    }
    return nil
}

func NewProcessModelPlcAddressSearch() *ProcessModelPlcAddressSearch {
    return &ProcessModelPlcAddressSearch{Orm: sqlitex.GetDB()}
}

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

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

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

func (slf *ProcessModelPlcAddressSearch) SetDeviceID(id string) *ProcessModelPlcAddressSearch {
    slf.DeviceID = id
    return slf
}

func (slf *ProcessModelPlcAddressSearch) SetDeviceIDs(ids []string) *ProcessModelPlcAddressSearch {
    slf.DeviceIDs = ids
    return slf
}

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

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

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

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

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

    return db
}

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

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

    return nil
}

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

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

    return record, nil
}

func (slf *ProcessModelPlcAddressSearch) Find() ([]*ProcessModelPlcAddress, int64, error) {
    var (
        records = make([]*ProcessModelPlcAddress, 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 err := db.Find(&records).Error; err != nil {
        return records, total, fmt.Errorf("find records err: %v", err)
    }

    return records, total, nil
}

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

    if err := db.Find(&records).Error; err != nil {
        return records, fmt.Errorf("find records err: %v", err)
    }

    return records, nil
}

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

    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
}

 nsq/msg_handler.go

@@ -345,6 +345,8 @@
        err = slf.DealProcessModelData(pullDataResponse.Data)
    case common.PullDataTypeDevice:
        err = slf.DealDeviceData(pullDataResponse.Data)
    case common.PullDataTypeProcessModelPlcAddress:
        err = slf.DealProcessModelPlcAddressData(pullDataResponse.Data)
    }
    if err != nil {
        logx.Infof("process pull data  err :%s", err)
@@ -393,5 +395,38 @@
}

func (slf *PullDataResponse) DealDeviceData(data interface{}) error {
    //已在别的topic处理
    return nil
}

func (slf *PullDataResponse) DealProcessModelPlcAddressData(data interface{}) error {
    var addressList []*model.ProcessModelPlcAddress
    err := mapstructure.Decode(data, &addressList)
    if err != nil {
        return err
    }
    deviceIDs := make([]string, 0, len(addressList))
    for _, item := range addressList {
        deviceIDs = append(deviceIDs, item.DeviceID)
    }
    existsRecords, err := model.NewProcessModelPlcAddressSearch().SetDeviceIDs(deviceIDs).FindNotTotal()
    if err != nil {
        return err
    }

    existsRecordsMap := make(map[string]*model.ProcessModelPlcAddress, len(existsRecords))
    for _, item := range existsRecords {
        existsRecordsMap[item.DeviceID] = item
    }

    for _, item := range addressList {
        if v, exists := existsRecordsMap[item.DeviceID]; !exists {
            item.ID = 0
            err = model.NewProcessModelPlcAddressSearch().Create(item)
        } else if v.Address != item.Address {
            v.Address = item.Address
            err = model.NewProcessModelPlcAddressSearch().Save(v)
        }
    }
    return nil
}

 service/problem/check.go

@@ -6,7 +6,6 @@
    "apsClient/model"
    "apsClient/pkg/sqlitex"
    "apsClient/service"
    "apsClient/service/plc_address"
    "fmt"
    "net"
    "sync"
@@ -197,7 +196,14 @@
type PlcProcessModelAddressList struct{}

func (slf *PlcProcessModelAddressList) Check() bool {
    return plc_address.IsLoad()
    record, err := model.NewProcessModelPlcAddressSearch().SetDeviceID(conf.Conf.CurrentDeviceID).First()
    if err != nil {
        return false
    }
    if len(record.AddressList) == 0 {
        return false
    }
    return true
}

type PlcConnect struct{}

 service/process_model.go

@@ -3,6 +3,8 @@
import (
    "apsClient/conf"
    "apsClient/model"
    "apsClient/pkg/logx"
    "errors"
)

func GetProcessModelList(offset, limit int, currentNumber string) (list []*model.ProcessModel, total int64, err error) {
@@ -19,3 +21,19 @@
func GetProcessModelByNumber(num string) (record *model.ProcessModel, err error) {
    return model.NewProcessModelSearch().SetNumber(num).First()
}

func GetProcessModelAddress(deviceID string) (addressMap map[string]int, err error) {
    record, err := model.NewProcessModelPlcAddressSearch().SetDeviceID(deviceID).First()
    if err != nil {
        logx.Errorf("find process model plc address for device:%v, err:%v", deviceID, err)
        return nil, err
    }
    if record.AddressList == nil {
        return nil, errors.New("empty process model address list")
    }
    addressMap = make(map[string]int, len(record.AddressList))
    for _, item := range record.AddressList {
        addressMap[item.Name] = item.Address
    }
    return addressMap, nil
}