打印入库-自制导出excel 增加对取消的统计

jiangshuai

2023-11-20 10806eefe017093646a671af0b321b9df0a2ebc5

打印入库-自制导出excel
增加对取消的统计

 conf/config.go

@@ -55,7 +55,6 @@
    LocalConf        = &localConf{}
    Viper            *viper.Viper
    GrpcServerConf   = &grpcServerConf{}
    FileTemplateConf = &fileTemplateConf{}
)

func Init() error {
@@ -117,7 +116,6 @@
    _ = v.UnmarshalKey("db", DbConf)
    _ = v.UnmarshalKey("local", LocalConf)
    _ = v.UnmarshalKey("grpcServer", GrpcServerConf)
    _ = v.UnmarshalKey("fileTemplate", FileTemplateConf)
    showConfig()
}

@@ -128,6 +126,5 @@
    log.Printf("   DbConf:                 %+v", DbConf)
    log.Printf("   LocalConf:               %+v", LocalConf)
    log.Printf("   GrpcServerConf:               %+v", GrpcServerConf)
    log.Printf("   FileTemplateConf:               %+v", FileTemplateConf)
    log.Println("......................................................")
}

 conf/config.yaml

@@ -27,5 +27,3 @@
  apsAddr: 192.168.20.119:9091
  crmAddr: 192.168.20.118:9092
  srmAddr: 192.168.20.118:9093
fileTemplate:
  inputSelfmadeAddr: http://192.168.20.189:6701/1477,d7149ab4b0?collection=1700127607-wms-file

 constvar/const.go

@@ -223,3 +223,10 @@
    "png":  FileType_Picture,
    "svg":  FileType_Picture,
}

type FileTemplateCategory int

const (
    FileTemplateCategory_Selfmade FileTemplateCategory = iota + 1 //入库-自制
    FileTemplateCategory_Output                                   //出库
)

 controllers/operation.go

@@ -831,14 +831,14 @@
    util.ResponseFormat(c, code.Success, "操作成功")
}

// inputSelfmade
// outputOperation
//
//    @Tags        入库/出库
//    @Summary    打印-自制-入库
//    @Summary    打印
//    @Produce    application/json
//    @Param        id    path        int            true    "id"
//    @Success    200    {object}    util.Response    "成功"
//    @Router        /api-wms/v1/operation/inputSelfmade/{id} [put]
//    @Router        /api-wms/v1/operation/outputOperation/{id} [put]
func (slf OperationController) InputSelfmade(c *gin.Context) {
    id, err := strconv.Atoi(c.Param("id"))
    if err != nil {
@@ -854,17 +854,45 @@
        util.ResponseFormat(c, code.RequestParamError, "未找到相关出入库信息:"+err.Error())
        return
    }

    readerCloser, err := http.HttpGetWithReadCloser(conf.FileTemplateConf.InputSelfmadeAddr)
    if err != nil {
        util.ResponseFormat(c, code.RequestParamError, "获取模版失败:"+err.Error())
    if len(operation.Details) == 0 {
        util.ResponseFormat(c, code.RequestParamError, "没有相关产品明细的信息")
        return
    }

    var fileUrl string
    if operation.BaseOperationType == constvar.BaseOperationTypeIncoming {
        fileUrl, err = ExportInputSelfmade(constvar.FileTemplateCategory_Selfmade, operation)
        if err != nil {
            util.ResponseFormat(c, code.RequestParamError, err.Error())
            return
        }
    } else if operation.BaseOperationType == constvar.BaseOperationTypeOutgoing {
        fileUrl, err = ExportOutputOperation(constvar.FileTemplateCategory_Output, operation)
        if err != nil {
            util.ResponseFormat(c, code.RequestParamError, err.Error())
            return
        }
    } else {
        util.ResponseFormat(c, code.RequestParamError, "该记录不支持打印")
        return
    }

    util.ResponseFormat(c, code.Success, fileUrl)
}

func ExportInputSelfmade(category constvar.FileTemplateCategory, operation *models.Operation) (string, error) {
    template, err := models.NewFileTemplateAttachmentSearch().SetCategory(category).First()
    if err != nil {
        return "", errors.New("获取模版记录失败:" + err.Error())
    }
    readerCloser, err := http.HttpGetWithReadCloser(template.Attachment.FileUrl)
    if err != nil {
        return "", errors.New("获取模版失败:" + err.Error())
    }

    f, err := excelize.OpenReader(readerCloser)
    if err != nil {
        util.ResponseFormat(c, code.RequestParamError, "读取excel模版失败："+err.Error())
        return
        return "", errors.New("读取excel模版失败：" + err.Error())
    }
    readerCloser.Close()

@@ -905,8 +933,7 @@
        totalAmount = totalAmount.Add(v.Amount)
    }
    if err := f.MergeCell("Sheet1", "A"+strconv.Itoa(rowIndex), "C"+strconv.Itoa(rowIndex)); err != nil {
        util.ResponseFormat(c, code.RequestParamError, err.Error())
        return
        return "", err
    }
    f.SetCellValue("Sheet1", "A"+strconv.Itoa(rowIndex), "合计")
    f.SetCellValue("Sheet1", "E"+strconv.Itoa(rowIndex), totalAmount.String())
@@ -920,16 +947,86 @@

    buf, err := f.WriteToBuffer()
    if err != nil {
        util.ResponseFormat(c, code.RequestParamError, err.Error())
        return
        return "", err
    }

    fileUrl, err := upload.UploadFileToSeaWeed(string(constvar.FileType_File), "xlsx", buf.Bytes())
    if err != nil {
        logx.Errorf("file upload err: %v", err)
        util.ResponseFormat(c, code.RequestParamError, err.Error())
        return
        return "", err
    }

    util.ResponseFormat(c, code.Success, fileUrl)
    return fileUrl, nil
}

func ExportOutputOperation(category constvar.FileTemplateCategory, operation *models.Operation) (string, error) {
    template, err := models.NewFileTemplateAttachmentSearch().SetCategory(category).First()
    if err != nil {
        return "", errors.New("获取模版记录失败:" + err.Error())
    }
    readerCloser, err := http.HttpGetWithReadCloser(template.Attachment.FileUrl)
    if err != nil {
        return "", errors.New("获取模版失败:" + err.Error())
    }

    f, err := excelize.OpenReader(readerCloser)
    if err != nil {
        return "", errors.New("读取excel模版失败：" + err.Error())
    }
    readerCloser.Close()

    style, _ := f.NewStyle(&excelize.Style{
        Border: []excelize.Border{
            {Type: "left", Color: "#000000", Style: 1},
            {Type: "top", Color: "#000000", Style: 1},
            {Type: "bottom", Color: "#000000", Style: 1},
            {Type: "right", Color: "#000000", Style: 1},
        },
        Alignment: &excelize.Alignment{
            Horizontal: "center",
            Vertical:   "center",
        },
    })

    f.SetCellValue("Sheet1", "C2", operation.FromLocation.Name)
    f.SetCellValue("Sheet1", "H2", operation.WaybillNumber)
    f.SetCellValue("Sheet1", "H3", operation.SourceNumber)
    f.SetCellValue("Sheet1", "K3", operation.Number)
    f.SetCellValue("Sheet1", "C4", operation.CompanyName)

    rowIndex := 8
    totalAmount := decimal.NewFromInt(0)
    totalWeight := decimal.NewFromInt(0)

    addRows := len(operation.Details) - 1
    if addRows > 0 {
        f.InsertRows("Sheet1", 9, addRows)
        f.SetCellStyle("Sheet1", "A9", "K"+strconv.Itoa(rowIndex+addRows), style)
    }

    for k, v := range operation.Details {
        productTotalWeight := v.Amount.Mul(v.Product.Weight).Div(decimal.NewFromInt(1000))
        f.SetCellValue("Sheet1", "A"+strconv.Itoa(rowIndex), k+1)
        f.SetCellValue("Sheet1", "B"+strconv.Itoa(rowIndex), v.Product.Name)
        f.SetCellValue("Sheet1", "H"+strconv.Itoa(rowIndex), v.Amount)
        f.SetCellValue("Sheet1", "I"+strconv.Itoa(rowIndex), v.Product.Weight)
        f.SetCellValue("Sheet1", "J"+strconv.Itoa(rowIndex), productTotalWeight)
        rowIndex++
        totalAmount = totalAmount.Add(v.Amount)
        totalWeight = totalWeight.Add(productTotalWeight)
    }

    buf, err := f.WriteToBuffer()
    if err != nil {
        return "", err
    }

    fileUrl, err := upload.UploadFileToSeaWeed(string(constvar.FileType_File), "xlsx", buf.Bytes())
    if err != nil {
        logx.Errorf("file upload err: %v", err)
        return "", err
    }

    return fileUrl, nil

}

 models/db.go

@@ -116,6 +116,7 @@
        ReorderRule{},
        Attachment{},
        LogisticCompany{},
        FileTemplateAttachment{},
    )
    return err
}

 models/file_template_attachment.go

New file
@@ -0,0 +1,205 @@
package models

import (
    "fmt"
    "gorm.io/gorm"
    "wms/constvar"
    "wms/pkg/mysqlx"
)

type (
    FileTemplateAttachment struct {
        WmsModel
        Id           int                           `json:"id"  gorm:"column:id;primary_key;AUTO_INCREMENT"`
        Category     constvar.FileTemplateCategory `json:"category" gorm:"type:int(11);comment:模版种类"`
        Name         string                        `json:"name" gorm:"type:varchar(63);comment:模版名称"`
        AttachmentId uint                          `json:"attachmentId" gorm:"comment:附件表外键"`
        Attachment   Attachment                    `json:"attachment" gorm:"foreignKey:AttachmentId;references:Id"`
    }
    FileTemplateAttachmentSearch struct {
        FileTemplateAttachment
        Order    string
        PageNum  int
        PageSize int
        Keyword  string
        Orm      *gorm.DB
        Preload  bool
    }
)

func (slf *FileTemplateAttachment) TableName() string {
    return "wms_file_template_attachment"
}

func NewFileTemplateAttachmentSearch() *FileTemplateAttachmentSearch {
    return &FileTemplateAttachmentSearch{Orm: mysqlx.GetDB()}
}

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

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

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

func (slf *FileTemplateAttachmentSearch) SetID(id int) *FileTemplateAttachmentSearch {
    slf.Id = id
    return slf
}

func (slf *FileTemplateAttachmentSearch) SetKeyword(keyword string) *FileTemplateAttachmentSearch {
    slf.Keyword = keyword
    return slf
}

func (slf *FileTemplateAttachmentSearch) SetPreload(preload bool) *FileTemplateAttachmentSearch {
    slf.Preload = preload
    return slf
}

func (slf *FileTemplateAttachmentSearch) SetCategory(category constvar.FileTemplateCategory) *FileTemplateAttachmentSearch {
    slf.Category = category
    return slf
}

func (slf *FileTemplateAttachmentSearch) build() *gorm.DB {
    var db = slf.Orm.Model(&FileTemplateAttachment{})

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

    if slf.Preload {
        db = db.Model(&FileTemplateAttachment{}).Preload("Attachment")
    }

    if int(slf.Category) != 0 {
        db = db.Where("category=?", slf.Category)
    }

    return db
}

// Create 单条插入
func (slf *FileTemplateAttachmentSearch) Create(record *FileTemplateAttachment) error {
    var db = slf.build()

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

    return nil
}

// CreateBatch 批量插入
func (slf *FileTemplateAttachmentSearch) CreateBatch(records []*FileTemplateAttachment) error {
    var db = slf.build()

    if err := db.Create(&records).Error; err != nil {
        return fmt.Errorf("create batch err: %v, records: %+v", err, records)
    }

    return nil
}

func (slf *FileTemplateAttachmentSearch) Update(record *FileTemplateAttachment) error {
    var db = slf.build()

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

    return nil
}

func (slf *FileTemplateAttachmentSearch) Delete() error {
    var db = slf.build()
    return db.Unscoped().Delete(&FileTemplateAttachment{}).Error
}

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

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

    return record, nil
}

func (slf *FileTemplateAttachmentSearch) FindByPage() ([]*FileTemplateAttachment, int64, error) {
    var (
        records = make([]*FileTemplateAttachment, 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 *FileTemplateAttachmentSearch) Find() ([]*FileTemplateAttachment, error) {
    var (
        records = make([]*FileTemplateAttachment, 0)
        db      = slf.build()
    )

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

    return records, nil
}

func (slf *FileTemplateAttachmentSearch) FirstRes() (*FileTemplateAttachment, *gorm.DB) {
    var (
        record = new(FileTemplateAttachment)
        db     = slf.build()
    )

    return record, db.First(&record)
}

func (slf *FileTemplateAttachmentSearch) Count() (int64, error) {
    var (
        total int64
        db    = slf.build()
    )
    err := db.Count(&total).Error
    return total, err
}

func (slf *FileTemplateAttachmentSearch) 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
}