You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
800 lines
23 KiB
800 lines
23 KiB
package lab
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"leit.com/leit_seat_aps/common"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
/** LAB文件结构定义，用于LAB文件解析 **/
|
|
|
|
// LAB 数据交换头
|
|
// 示例：UNB+UNOA:1+ODX0SENDER00A+ODX0RECEIVER002+100515:0537+S2010/13-5++DELINS'
|
|
type UNB struct {
|
|
Sender string // 发送方
|
|
Reciever string // 接收方
|
|
MsgTime time.Time // 消息时间
|
|
MsgRefId string // 消息参考号
|
|
MsgType string // 消息类型：1=生产用
|
|
ParseString string // 原始消息数据串
|
|
}
|
|
|
|
// LAB 数据消息头
|
|
// UNH+00001+DELINS:3:0:OD'
|
|
type UNH struct {
|
|
MsgId string // 消息标识ID
|
|
MsgType string // 消息类型 DELINS
|
|
MsgTypeVersion string // 消息类型版本号
|
|
MsgTypeRelNo string // 消息类型版本释放号
|
|
ParseString string // 原始数据串
|
|
}
|
|
|
|
// LAB 数据消息开始
|
|
// MID+S2010/13-5'
|
|
type MID struct {
|
|
InterchangeRefId string // 数据交换参考号
|
|
ParseString string // 原始数据串
|
|
}
|
|
|
|
// LAB 销售方信息
|
|
// 示例： SDT+14924810:SUPPLIER (SHENYANG):* *****++++CN+:84556891’
|
|
// Seller Details + Supplier Code : Supplier Name : Address + + + + Country Code + :
|
|
type SDT struct {
|
|
SupplierCode string // 供应商编码
|
|
SupplierName string // 供应商名称
|
|
CountryCode string // 国家编码
|
|
ParseString string // 原始数据串
|
|
}
|
|
|
|
// LAB 买方信息
|
|
// 示例：BDT+15281010 ’
|
|
type BDT struct {
|
|
Consignee string // 收货人
|
|
ParseString string // 原始数据串
|
|
}
|
|
|
|
// LAB 买方详细信息
|
|
// 示例：CSG+15281018 :******:ULS WAREHOUSE:::* ******************8*+:******+XT01+CN’
|
|
// Consignee Details + BBA delivery address code : Address Line : Address Line : : : Address Line + : Address Line + Additional Destination Details + Country Code
|
|
type CSG struct {
|
|
DeliveryAddressCode string // 交付地址编码
|
|
AdditionalDest string // 额外地址信息
|
|
ParseString string // 原始数据串
|
|
}
|
|
|
|
// LAB 零件信息
|
|
// 示例：ARD+7840613-04::LU RR/CONS INDIVID.(POPLAR BRIGHT)B+:00+L784061304+++04’
|
|
// Article details + part number-AI : : Description + : Measure Unit Specifier + Purchase Order + + + AI
|
|
type ARD struct {
|
|
PartId string // 零件ID
|
|
Descr string // 描述
|
|
Uom string // 计量单位
|
|
PurchaseOrder string // 采购订单号
|
|
Ai string // AI号
|
|
Pdi PDI // 前一个发运指示
|
|
Sad SAD // 补充物料信息
|
|
Dst DST
|
|
Pdn PDN
|
|
SidList []SID
|
|
DelList []DEL // 零件需求信息
|
|
Adi ADI
|
|
ParseString string // 原始数据串
|
|
}
|
|
|
|
// LAB 前一个发运指导
|
|
// PDI+0 0000016+091213’
|
|
// Previous delivery instruction + Document Number + Document Date YYMMDD
|
|
type PDI struct {
|
|
PrevDeliveryInstruction string // 前一个发运指导
|
|
DocumentNr string // 文档号
|
|
DocumentDate time.Time // 文档日期
|
|
ParseString string // 原始数据串
|
|
}
|
|
|
|
// LAB 物料补充信息
|
|
// SAD+1+:250 CHENCHEN CHEN:84556891+03++3’
|
|
// Supplementary Articles Details + Action Code (1=Replace Previous Release) + : Material planner : Phone Number + Article Status Code + + 3 =Frequency
|
|
type SAD struct {
|
|
ActionCode int // 动作编码
|
|
MaterialPlanner string // 物料计划员
|
|
Phone string // 联系电话
|
|
ArticleStatusCode string // 物料状态码
|
|
Frequency int // 频率
|
|
ParseString string // 原始数据串
|
|
}
|
|
|
|
// LAB 发运信息
|
|
// DST+091214+59:0::000000’
|
|
// Delivery Status + Date of MRP YYMMDD + Cumulative Quantity : Cumulative Quantity received : : Quantity accumulation start date
|
|
type DST struct {
|
|
MrpDate time.Time // MRP日期
|
|
TotalQty int // 需求总量
|
|
DemandStartDate time.Time // 需求起始日期
|
|
ParseString string // 原始数据串
|
|
}
|
|
|
|
// LAB 前一个发货说明
|
|
// PDN+ABC0100891:000000+20’
|
|
// Previous Despatch Notes + Delivery Note Number : Delivery Date + Quantity received
|
|
type PDN struct {
|
|
DeliveryNoteNr string // 发货说明号
|
|
DeliveryDate time.Time // 发货日期
|
|
RecievedQty int // 已接收数量
|
|
ParseString string // 原始数据串
|
|
}
|
|
|
|
// LAB 排序指示符
|
|
// SID+2’
|
|
// SID+3’
|
|
// Schedule Indicator Details
|
|
// An indicator to show the supplier commitment
|
|
// First occurrence: ‘2’,
|
|
// Second occurrence: ‘3’
|
|
type SID struct {
|
|
OccurrenceNr int
|
|
ParseString string // 原始数据串
|
|
}
|
|
|
|
// LAB 零件需求信息
|
|
// DEL+100405::100411+3::0::59’
|
|
// Delivery Details + First Date YYMMDD : : Last Date YYMMDD + Quantity : : D elivery Instruction : : Cumulative Quantity
|
|
type DEL struct {
|
|
StartDate time.Time // 起始日期
|
|
EndDate time.Time // 结束日期
|
|
DemandQty int // 需求数量
|
|
CumulativeQty int // 累计数量
|
|
ParseString string // 原始数据串
|
|
}
|
|
|
|
// LAB 物料交付指示信息
|
|
// ADI+0 0000017+091214’
|
|
// Article Delivery Instruction Number + Document Number + Document Date YYMMDD
|
|
type ADI struct {
|
|
DeliveryInsNr string // 物料交付指示号
|
|
DocDate time.Time // 文档日期
|
|
DocNr string // 文档号
|
|
ParseString string // 原始数据串
|
|
}
|
|
|
|
// LAB 文本数据
|
|
type FTX struct {
|
|
Text string // 文本信息
|
|
ParseString string // 原始数据串
|
|
}
|
|
|
|
// LAB 数据消息尾
|
|
// UNT+89+00001
|
|
type UNT struct {
|
|
DataRows int // 数据行数，从UNH到UNT总数
|
|
MsgId string // 消息标识，与UNH一致
|
|
ParseString string // 原始数据串
|
|
}
|
|
|
|
// LAB 数据交换结束符
|
|
// UNZ+1+S2009/34-8
|
|
type UNZ struct {
|
|
MsgCount int // 消息数
|
|
MsgRefId string // 消息参考号
|
|
ParseString string // 原始数据串
|
|
}
|
|
|
|
// LAB 消息对象
|
|
type LAB struct {
|
|
FileName string // TOD文件名
|
|
DataRows int // 包含数据行 UNH->UNT
|
|
Unb UNB // 数据交换头
|
|
Unh UNH // 数据消息头
|
|
Mid MID
|
|
Sdt SDT // 卖方信息
|
|
Bdt BDT // 买方信息
|
|
Csg CSG // 买方详细信息
|
|
ArdList []ARD // 零件清单信息
|
|
FtxList []FTX
|
|
Unt UNT // 数据消息尾
|
|
Unz UNZ // 数据消息交换结束
|
|
}
|
|
|
|
// 示例：UNB+UNOA:1+ODX0SENDER00A+ODX0RECEIVER002+091214:1801+S2009/34-8 ++DELINS’
|
|
func (unb *UNB) Parse(parseString string) (err error) {
|
|
var (
|
|
kvlist []string
|
|
kv4 []string
|
|
)
|
|
// 输入为空，返回错误
|
|
if strings.TrimSpace(parseString) == "" {
|
|
return errors.New("UNB: parse string is empty!")
|
|
}
|
|
// 基于+分隔符来解析字符串
|
|
kvlist = strings.Split(parseString, "+")
|
|
if len(kvlist) < 5 {
|
|
return errors.New("UNB: Key value length less than 5, failed to parse!")
|
|
}
|
|
kv4 = strings.Split(kvlist[4], ":")
|
|
if len(kv4) < 2 {
|
|
return errors.New("UNB: Key4 value length less than 2, failed to parse!")
|
|
}
|
|
|
|
// 填充值
|
|
unb.Sender = kvlist[2] // 发送方
|
|
unb.Reciever = kvlist[3] // 接收方
|
|
if unb.MsgTime, err = common.DateParse(kv4[0]+kv4[1], "ymdHi"); err != nil {
|
|
return errors.New("UNB: Failed to get the MsgTime!")
|
|
}
|
|
unb.MsgRefId = kvlist[5] // 消息参考ID
|
|
unb.MsgType = kvlist[7] // 消息类型
|
|
unb.ParseString = parseString
|
|
|
|
// 校验关键字段是否为空
|
|
if strings.TrimSpace(unb.Sender) == "" {
|
|
return errors.New("UNB: Sender is empty!")
|
|
}
|
|
if strings.TrimSpace(unb.Reciever) == "" {
|
|
return errors.New("UNB: Reciever is empty!")
|
|
}
|
|
if strings.TrimSpace(unb.MsgRefId) == "" {
|
|
return errors.New("UNB: MsgRefId is empty!")
|
|
}
|
|
return
|
|
}
|
|
|
|
func (unb *UNB) Print() {
|
|
fmt.Println("UNB | Sender:", unb.Sender, " | Reciever:", unb.Reciever, " | MsgTime:", unb.MsgTime, " | MsgType:", unb.MsgType, " | MsgRefId:", unb.MsgRefId)
|
|
}
|
|
|
|
// UNH+00001+DELINS:3:0:OD'
|
|
func (unh *UNH) Parse(parseString string) (err error) {
|
|
var (
|
|
kvlist []string
|
|
kv2 []string
|
|
)
|
|
// 输入为空，返回错误
|
|
if strings.TrimSpace(parseString) == "" {
|
|
return errors.New("UNH: parse string is empty!")
|
|
}
|
|
// 基于+分隔符来解析字符串
|
|
kvlist = strings.Split(parseString, "+")
|
|
kv2 = strings.Split(kvlist[2], ":")
|
|
if len(kv2) < 3 {
|
|
return errors.New("UNH: kv2 value length less than 3, failed to parse!")
|
|
}
|
|
|
|
// 填充值
|
|
unh.MsgId = kvlist[1] // 消息ID
|
|
unh.MsgType = kv2[0] // 消息类型
|
|
unh.MsgTypeVersion = kv2[1]
|
|
unh.MsgTypeRelNo = kv2[2]
|
|
unh.ParseString = parseString
|
|
|
|
// 校验关键字段是否为空
|
|
if strings.TrimSpace(unh.MsgId) == "" {
|
|
return errors.New("UNH: MsgId is empty!")
|
|
}
|
|
if strings.TrimSpace(unh.MsgType) == "" {
|
|
return errors.New("UNH: MsgType is empty!")
|
|
}
|
|
if strings.ToUpper(strings.TrimSpace(unh.MsgType)) != "DELINS" {
|
|
return errors.New("UNH: MsgType is not DELINS!")
|
|
}
|
|
return
|
|
}
|
|
|
|
func (unh *UNH) Print() {
|
|
fmt.Println("UNH | MsgId:", unh.MsgId, " | MsgType:", unh.MsgType)
|
|
}
|
|
|
|
// MID+S2010/13-5'
|
|
func (mid *MID) Parse(parseString string) (err error) {
|
|
var (
|
|
kvlist []string
|
|
)
|
|
// 输入为空，返回错误
|
|
if strings.TrimSpace(parseString) == "" {
|
|
return errors.New("MID: parse string is empty!")
|
|
}
|
|
// 基于+分隔符来解析字符串
|
|
kvlist = strings.Split(parseString, "+")
|
|
if len(kvlist) < 2 {
|
|
return errors.New("MID: value length less than 2, failed to parse!")
|
|
}
|
|
|
|
// 填充值
|
|
mid.InterchangeRefId = kvlist[1]
|
|
mid.ParseString = parseString
|
|
|
|
// 校验关键字段是否为空
|
|
if strings.TrimSpace(mid.InterchangeRefId) == "" {
|
|
return errors.New("MID: InterchangeRefId is empty!")
|
|
}
|
|
return
|
|
}
|
|
|
|
func (mid *MID) Print() {
|
|
fmt.Println("MID | InterchangeRefId:", mid.InterchangeRefId)
|
|
}
|
|
|
|
// LAB 销售方信息
|
|
// 示例： SDT+14924810:SUPPLIER (SHENYANG):* *****++++CN+:84556891’
|
|
// Seller Details + Supplier Code : Supplier Name : Address + + + + Country Code + :
|
|
func (sdt *SDT) Parse(parseString string) (err error) {
|
|
var (
|
|
kvlist []string
|
|
kv1 []string
|
|
)
|
|
// 输入为空，返回错误
|
|
if strings.TrimSpace(parseString) == "" {
|
|
return errors.New("SDT: parse string is empty!")
|
|
}
|
|
// 基于+分隔符来解析字符串
|
|
kvlist = strings.Split(parseString, "+")
|
|
kv1 = strings.Split(kvlist[1], ":")
|
|
if len(kv1) < 2 {
|
|
return errors.New("SDT: kv1 value length less than 3, failed to parse!")
|
|
}
|
|
|
|
// 填充值
|
|
sdt.SupplierCode = kv1[0]
|
|
sdt.SupplierName = kv1[1]
|
|
sdt.ParseString = parseString
|
|
|
|
// 校验关键字段是否为空
|
|
if strings.TrimSpace(sdt.SupplierCode) == "" {
|
|
return errors.New("SDT: SupplierCode is empty!")
|
|
}
|
|
if strings.TrimSpace(sdt.SupplierName) == "" {
|
|
return errors.New("SDT: SupplierName is empty!")
|
|
}
|
|
return
|
|
}
|
|
|
|
func (sdt *SDT) Print() {
|
|
fmt.Println("SDT | SupplierCode:", sdt.SupplierCode, " | SupplierName:", sdt.SupplierName)
|
|
}
|
|
|
|
// LAB 买方信息
|
|
// 示例：BDT+15281010 ’
|
|
func (bdt *BDT) Parse(parseString string) (err error) {
|
|
var (
|
|
kvlist []string
|
|
)
|
|
// 输入为空，返回错误
|
|
if strings.TrimSpace(parseString) == "" {
|
|
return errors.New("BDT: parse string is empty!")
|
|
}
|
|
// 基于+分隔符来解析字符串
|
|
kvlist = strings.Split(parseString, "+")
|
|
|
|
// 填充值
|
|
bdt.Consignee = kvlist[1] // 收货人
|
|
bdt.ParseString = parseString
|
|
|
|
// 校验关键字段是否为空
|
|
if strings.TrimSpace(bdt.Consignee) == "" {
|
|
return errors.New("BDT: Consignee is empty!")
|
|
}
|
|
return
|
|
}
|
|
|
|
func (bdt *BDT) Print() {
|
|
fmt.Println("BDT | Consignee:", bdt.Consignee)
|
|
}
|
|
|
|
// LAB 买方详细信息
|
|
// 示例：CSG+15281018 :******:ULS WAREHOUSE:::* ******************8*+:******+XT01+CN’
|
|
// Consignee Details + BBA delivery address code : Address Line : Address Line : : : Address Line + : Address Line + Additional Destination Details + Country Code
|
|
func (csg *CSG) Parse(parseString string) (err error) {
|
|
var (
|
|
kvlist []string
|
|
kv1 []string
|
|
)
|
|
// 输入为空，返回错误
|
|
if strings.TrimSpace(parseString) == "" {
|
|
return errors.New("CSG: parse string is empty!")
|
|
}
|
|
// 基于+分隔符来解析字符串
|
|
kvlist = strings.Split(parseString, "+")
|
|
kv1 = strings.Split(kvlist[1], ":")
|
|
if len(kv1) < 3 {
|
|
return errors.New("CSG: kv1 value length less than 3, failed to parse!")
|
|
}
|
|
|
|
// 填充值
|
|
csg.DeliveryAddressCode = kv1[0]
|
|
csg.AdditionalDest = kvlist[3]
|
|
csg.ParseString = parseString
|
|
|
|
// 校验关键字段是否为空
|
|
if strings.TrimSpace(csg.DeliveryAddressCode) == "" {
|
|
return errors.New("BDT: Consignee is empty!")
|
|
}
|
|
return
|
|
}
|
|
|
|
func (csg *CSG) Print() {
|
|
fmt.Println("CSG | DeliveryAddressCode + ", csg.DeliveryAddressCode)
|
|
}
|
|
|
|
// LAB 零件信息
|
|
// 示例：ARD+7840613-04::LU RR/CONS INDIVID.(POPLAR BRIGHT)B+:00+L784061304+++04’
|
|
// Article details + part number-AI : : Description + : Measure Unit Specifier + Purchase Order + + + AI
|
|
func (ard *ARD) Parse(parseString string) (err error) {
|
|
var (
|
|
kvlist []string
|
|
kv1, kv2 []string
|
|
)
|
|
// 输入为空，返回错误
|
|
if strings.TrimSpace(parseString) == "" {
|
|
return errors.New("ARD: parse string is empty!")
|
|
}
|
|
// 基于+分隔符来解析字符串
|
|
kvlist = strings.Split(parseString, "+")
|
|
kv1 = strings.Split(kvlist[1], ":")
|
|
kv2 = strings.Split(kvlist[2], ":")
|
|
if len(kv1) < 3 || len(kv2) < 2 {
|
|
return errors.New("ARD: kv1/2 value length less than 3/2, failed to parse!")
|
|
}
|
|
|
|
// 填充值
|
|
ard.PartId = kv1[0]
|
|
ard.Descr = kv1[2]
|
|
ard.Uom = kv2[1]
|
|
ard.PurchaseOrder = kvlist[3]
|
|
ard.Ai = kvlist[6]
|
|
ard.ParseString = parseString
|
|
|
|
// 校验关键字段是否为空
|
|
if strings.TrimSpace(ard.PartId) == "" {
|
|
return errors.New("ARD: PartId is empty!")
|
|
}
|
|
if strings.TrimSpace(ard.PurchaseOrder) == "" {
|
|
return errors.New("ARD: PurchaseOrder is empty!")
|
|
}
|
|
return
|
|
}
|
|
|
|
func (ard *ARD) Print() {
|
|
fmt.Println("ARD | PartId:", ard.PartId, " | Descr:", ard.Descr, " | PurchaseOrder:", ard.PurchaseOrder)
|
|
}
|
|
|
|
// LAB 前一个发运指导
|
|
// PDI+0 0000016+091213’
|
|
// Previous delivery instruction + Document Number + Document Date YYMMDD
|
|
func (pdi *PDI) Parse(parseString string) (err error) {
|
|
var (
|
|
kvlist []string
|
|
)
|
|
// 输入为空，返回错误
|
|
if strings.TrimSpace(parseString) == "" {
|
|
return errors.New("PDI: parse string is empty!")
|
|
}
|
|
// 基于+分隔符来解析字符串
|
|
kvlist = strings.Split(parseString, "+")
|
|
if len(kvlist) < 3 {
|
|
return errors.New("PDI: kvlist value length less than 3, failed to parse!")
|
|
}
|
|
|
|
// 填充值
|
|
pdi.DocumentNr = kvlist[1] // 文档号
|
|
if pdi.DocumentDate, err = common.DateParse(kvlist[2], "ymd"); err != nil {
|
|
return errors.New("PDI: Failed to get the DocumentDate!")
|
|
}
|
|
pdi.ParseString = parseString
|
|
|
|
// 校验关键字段是否为空
|
|
if strings.TrimSpace(pdi.DocumentNr) == "" {
|
|
return errors.New("PDI: DocumentNr is empty!")
|
|
}
|
|
return
|
|
}
|
|
|
|
func (pdi *PDI) Print() {
|
|
return
|
|
fmt.Println("PDI | PartNr:", pdi.DocumentNr, " | DocumentDate:", pdi.DocumentDate)
|
|
}
|
|
|
|
// LAB 物料补充信息
|
|
// SAD+1+:250 CHENCHEN CHEN:84556891+03++3’
|
|
// Supplementary Articles Details + Action Code (1=Replace Previous Release) + : Material planner : Phone Number + Article Status Code + + 3 =Frequency
|
|
func (sad *SAD) Parse(parseString string) (err error) {
|
|
var (
|
|
kvlist []string
|
|
kv2 []string
|
|
)
|
|
// 输入为空，返回错误
|
|
if strings.TrimSpace(parseString) == "" {
|
|
return errors.New("SAD: parse string is empty!")
|
|
}
|
|
// 基于+分隔符来解析字符串
|
|
kvlist = strings.Split(parseString, "+")
|
|
kv2 = strings.Split(kvlist[2], ":")
|
|
if len(kv2) < 2 {
|
|
return errors.New("SAD: kv2 value length less than 2, failed to parse!")
|
|
}
|
|
|
|
// 填充值
|
|
sad.ActionCode, _ = strconv.Atoi(kvlist[1])
|
|
sad.MaterialPlanner = kv2[1]
|
|
sad.Phone = kv2[2]
|
|
sad.ArticleStatusCode = kvlist[3]
|
|
sad.Frequency, _ = strconv.Atoi(kvlist[5])
|
|
sad.ParseString = parseString
|
|
|
|
// 校验关键字段是否为空
|
|
return
|
|
}
|
|
|
|
func (sad *SAD) Print() {
|
|
fmt.Println("SAD | ActionCode:", sad.ActionCode, " | MaterialPlanner:", sad.MaterialPlanner, " | Phone:", sad.Phone)
|
|
}
|
|
|
|
// LAB 发运信息
|
|
// DST+200204+107004:74761::000000'
|
|
// Delivery Status + Date of MRP YYMMDD + Cumulative Quantity : Cumulative Quantity received : : Quantity accumulation start date
|
|
func (dst *DST) Parse(parseString string) (err error) {
|
|
var (
|
|
kvlist []string
|
|
kv2 []string
|
|
)
|
|
// 输入为空，返回错误
|
|
if strings.TrimSpace(parseString) == "" {
|
|
return errors.New("DST: parse string is empty!")
|
|
}
|
|
// 基于+分隔符来解析字符串
|
|
kvlist = strings.Split(parseString, "+")
|
|
kv2 = strings.Split(kvlist[2], ":")
|
|
if len(kv2) < 4 {
|
|
return errors.New("QTY: kv2 value length less than 3, failed to parse!")
|
|
}
|
|
|
|
// 填充值
|
|
if dst.MrpDate, err = common.DateParse(kvlist[1], "ymd"); err != nil {
|
|
return errors.New("DST: failed to parse MrpDate!")
|
|
}
|
|
if kv2[3] != "000000" {
|
|
if dst.DemandStartDate, err = common.DateParse(kv2[3], "ymd"); err != nil {
|
|
return errors.New("DST: failed to parse DemandStartDate!")
|
|
}
|
|
}
|
|
dst.TotalQty, _ = strconv.Atoi(kv2[0])
|
|
dst.ParseString = parseString
|
|
|
|
return
|
|
}
|
|
|
|
func (dst *DST) Print() {
|
|
fmt.Println("DST | MrpDate:", dst.MrpDate, " | TotalQty:", dst.TotalQty, " | DemandStartDate:", dst.DemandStartDate)
|
|
}
|
|
|
|
// LAB 前一个发货说明
|
|
// PDN+ADTT202000454:000000+4
|
|
// Previous Despatch Notes + Delivery Note Number : Delivery Date + Quantity received
|
|
func (pdn *PDN) Parse(parseString string) (err error) {
|
|
var (
|
|
kvlist []string
|
|
kv1 []string
|
|
)
|
|
// 输入为空，返回错误
|
|
if strings.TrimSpace(parseString) == "" {
|
|
return errors.New("PDN: parse string is empty!")
|
|
}
|
|
// 基于+分隔符来解析字符串
|
|
kvlist = strings.Split(parseString, "+")
|
|
kv1 = strings.Split(kvlist[1], ":")
|
|
if len(kv1) < 2 {
|
|
return errors.New("PDN: kv1 value length less than 2, failed to parse!")
|
|
}
|
|
|
|
// 填充值
|
|
pdn.DeliveryNoteNr = kvlist[1]
|
|
if kv1[1] != "000000" {
|
|
if pdn.DeliveryDate, err = common.DateParse(kv1[1], "ymd"); err != nil {
|
|
return errors.New("PDN: failed to parse DeliveryDate!")
|
|
}
|
|
}
|
|
// 有些PDN没有该字段
|
|
//pdn.RecievedQty,_ = strconv.Atoi(kvlist[2])
|
|
pdn.ParseString = parseString
|
|
|
|
// 校验关键字段是否为空
|
|
if strings.TrimSpace(pdn.DeliveryNoteNr) == "" {
|
|
return errors.New("PDN: DeliveryNoteNr is empty!")
|
|
}
|
|
return
|
|
}
|
|
|
|
func (pdn *PDN) Print() {
|
|
fmt.Println("PDN | DeliveryNoteNr:", pdn.DeliveryNoteNr, " | DeliveryDate:", pdn.DeliveryDate, " | RecievedQty:", pdn.RecievedQty)
|
|
}
|
|
|
|
// LAB 排序指示符
|
|
// SID+2’
|
|
// SID+3’
|
|
// Schedule Indicator Details
|
|
// An indicator to show the supplier commitment
|
|
// First occurrence: ‘2’,
|
|
// Second occurrence: ‘3’
|
|
func (sid *SID) Parse(parseString string) (err error) {
|
|
var (
|
|
kvlist []string
|
|
)
|
|
// 输入为空，返回错误
|
|
if strings.TrimSpace(parseString) == "" {
|
|
return errors.New("ADI: parse string is empty!")
|
|
}
|
|
// 基于+分隔符来解析字符串
|
|
kvlist = strings.Split(parseString, "+")
|
|
|
|
// 填充值
|
|
sid.OccurrenceNr, _ = strconv.Atoi(kvlist[1])
|
|
sid.ParseString = parseString
|
|
|
|
// 校验关键字段是否为空
|
|
return
|
|
}
|
|
|
|
func (sid *SID) Print() {
|
|
fmt.Println("SID | OccurrenceNr:", sid.OccurrenceNr)
|
|
}
|
|
|
|
// LAB 零件需求信息
|
|
// DEL+200222::200222+108::0::1304'
|
|
// Delivery Details + First Date YYMMDD : : Last Date YYMMDD + Quantity : : Delivery Instruction : : Cumulative Quantity
|
|
func (del *DEL) Parse(parseString string) (err error) {
|
|
var (
|
|
kvlist []string
|
|
kv1, kv2 []string
|
|
)
|
|
// 输入为空，返回错误
|
|
if strings.TrimSpace(parseString) == "" {
|
|
return errors.New("DEL: parse string is empty!")
|
|
}
|
|
// 基于+分隔符来解析字符串
|
|
kvlist = strings.Split(parseString, "+")
|
|
kv1 = strings.Split(kvlist[1], ":")
|
|
if len(kv1) < 3 {
|
|
return errors.New("DEL: kv1 value length less than 3, failed to parse!")
|
|
}
|
|
kv2 = strings.Split(kvlist[2], ":")
|
|
if len(kv2) < 5 {
|
|
return errors.New("DEL: kv2 value length less than 5, failed to parse!")
|
|
}
|
|
|
|
// 填充值
|
|
if del.StartDate, err = common.DateParse(kv1[0], "ymd"); err != nil {
|
|
return errors.New("DEL: failed to parse StartDate!")
|
|
}
|
|
if del.EndDate, err = common.DateParse(kv1[2], "ymd"); err != nil {
|
|
return errors.New("DEL: failed to parse EndDate!")
|
|
}
|
|
del.DemandQty, _ = strconv.Atoi(kv2[0])
|
|
del.CumulativeQty, _ = strconv.Atoi(kv2[4])
|
|
del.ParseString = parseString
|
|
|
|
// 校验关键字段是否为空
|
|
return
|
|
}
|
|
|
|
func (del *DEL) Print() {
|
|
fmt.Println("DEL | DemandQty:", del.DemandQty, " | StartDate:", del.StartDate, " | EndDate:", del.EndDate, " | CumulativeQty:", del.CumulativeQty)
|
|
}
|
|
|
|
// LAB 物料交付指示信息
|
|
// ADI+0 0000017+091214’
|
|
// Article Delivery Instruction Number + Document Number + Document Date YYMMDD
|
|
func (adi *ADI) Parse(parseString string) (err error) {
|
|
var (
|
|
kvlist []string
|
|
)
|
|
// 输入为空，返回错误
|
|
if strings.TrimSpace(parseString) == "" {
|
|
return errors.New("ADI: parse string is empty!")
|
|
}
|
|
// 基于+分隔符来解析字符串
|
|
kvlist = strings.Split(parseString, "+")
|
|
|
|
// 填充值
|
|
adi.DeliveryInsNr = kvlist[1]
|
|
if adi.DocDate, err = common.DateParse(kvlist[2], "ymd"); err != nil {
|
|
return errors.New("ADI: failed to parse DocDate!")
|
|
}
|
|
adi.ParseString = parseString
|
|
|
|
// 校验关键字段是否为空
|
|
if strings.TrimSpace(adi.DeliveryInsNr) == "" {
|
|
return errors.New("ADI: DeliveryInsNr is empty!")
|
|
}
|
|
return
|
|
}
|
|
|
|
func (adi *ADI) Print() {
|
|
fmt.Println("ADI | DeliveryInsNr:", adi.DeliveryInsNr, " | DocDate:", adi.DocDate)
|
|
}
|
|
|
|
// LAB 文本数据
|
|
// UNT+89+00001
|
|
func (ftx *FTX) Parse(parseString string) (err error) {
|
|
var (
|
|
kvlist []string
|
|
)
|
|
// 输入为空，返回错误
|
|
if strings.TrimSpace(parseString) == "" {
|
|
return errors.New("FTX: parse string is empty!")
|
|
}
|
|
// 基于+分隔符来解析字符串
|
|
kvlist = strings.Split(parseString, "+")
|
|
|
|
// 填充值
|
|
ftx.Text = kvlist[1]
|
|
ftx.ParseString = parseString
|
|
|
|
// 校验关键字段是否为空
|
|
return
|
|
}
|
|
|
|
func (ftx *FTX) Print() {
|
|
fmt.Println("FTX | Text:", ftx.Text)
|
|
}
|
|
|
|
// LAB 数据消息尾
|
|
// UNT+89+00001
|
|
func (unt *UNT) Parse(parseString string) (err error) {
|
|
var (
|
|
kvlist []string
|
|
)
|
|
// 输入为空，返回错误
|
|
if strings.TrimSpace(parseString) == "" {
|
|
return errors.New("UNT: parse string is empty!")
|
|
}
|
|
// 基于+分隔符来解析字符串
|
|
kvlist = strings.Split(parseString, "+")
|
|
|
|
// 填充值
|
|
if unt.DataRows, err = strconv.Atoi(kvlist[1]); err != nil {
|
|
return errors.New("UNT: Failed to get data rows!")
|
|
}
|
|
unt.MsgId = kvlist[2]
|
|
unt.ParseString = parseString
|
|
|
|
// 校验关键字段是否为空
|
|
if strings.TrimSpace(unt.MsgId) == "" {
|
|
return errors.New("UNT: MsgId is empty!")
|
|
}
|
|
return
|
|
}
|
|
|
|
func (unt *UNT) Print() {
|
|
fmt.Println("UNT | MsgId:", unt.MsgId, " | DataRows:", unt.DataRows)
|
|
}
|
|
|
|
// LAB 数据交换结束符
|
|
// UNZ+1+S2009/34-8
|
|
func (unz *UNZ) Parse(parseString string) (err error) {
|
|
var (
|
|
kvlist []string
|
|
)
|
|
// 输入为空，返回错误
|
|
if strings.TrimSpace(parseString) == "" {
|
|
return errors.New("UNZ: parse string is empty!")
|
|
}
|
|
// 基于+分隔符来解析字符串
|
|
kvlist = strings.Split(parseString, "+")
|
|
|
|
// 填充值
|
|
if unz.MsgCount, err = strconv.Atoi(kvlist[1]); err != nil {
|
|
return errors.New("UNZ: Failed to get message count!")
|
|
}
|
|
unz.MsgRefId = kvlist[2]
|
|
unz.ParseString = parseString
|
|
|
|
// 校验关键字段是否为空
|
|
if strings.TrimSpace(unz.MsgRefId) == "" {
|
|
return errors.New("UNZ: MsgRefId is empty!")
|
|
}
|
|
return
|
|
}
|
|
|
|
func (unz *UNZ) Print() {
|
|
fmt.Println("UNZ | MsgRefId:", unz.MsgRefId, " | MsgCount:", unz.MsgCount)
|
|
}
|