LAPP_SJA_APS_BACKEND/reorder/Reorder.go

package reorder

import (
	"errors"
	"fmt"
	"leit.com/leit_seat_aps/common"
	"strconv"
	"strings"
	"time"
)

// REORDER 数据交换头
// 示例：UNB+UNOA:1+ODX0SENDER00A+ODX0RECEIVER001+140123:2057+149401140123'
// 说明：Interchange header + Translator value + Sender’s Odette Code + Supplier’s Odette Code + Date:Time + Unique number
type UNB struct {
	Sender      string    // 发送方
	Reciever    string    // 接收方
	MsgTime     time.Time // 消息时间
	MsgRefId    string    // 消息参考号
	ParseString string    // 原始消息数据串
}

// REORDER 数据消息头
// 示例：UNH+1494012057+DELJIT:D:96A:UN'
// 说明：Message header 2 + Message Number + UN Standard
type UNH struct {
	MsgId          string // 消息标识ID
	MsgType        string // 消息类型 DELJIT
	MsgTypeVersion string // 消息类型版本号
	MsgTypeRelNo   string // 消息类型版本释放号
	ParseString    string // 原始数据串
}

// REORDER 数据消息开始
// 示例：BGM+39::92+00017131'
// 说明：Begin of message + 39=Re-Order:: 92=BMW + Detective goods number (Similar to call off number)
type BGM struct {
	MessageType int    // 消息类型 39 = REORDER
	ReorderNum  string // Reorder号
	ParseString string // 原始数据串
}

// REORDER 数据消息日期时间信息
// 示例：DTM+137:201506021252:203'
// 说明：Date / Time / Period + 137=Date and Time : Date / Time : 203=Format Date / Time
type DTM struct {
	DateTimeType   int // 137 = 消息日期
	DateTimeFormat int // 日期时间格式：203 = CCYYMMDDHHMM
	MsgTimeFormat  string
	MsgTime        time.Time // 消息时间
	ParseString    string    // 原始数据串
}

// REORDER 参考信息
// 示例：RFF+ZZZ:TVKKBR1'
// 说明：Reference Serial Number + ZZZ=User defined Text : Name of Parts Family
type RFF struct {
	RefType     string // CALLOFF = AAN / PARTFAMILY = ZZZ
	PartFamily  string // 零件族
	ParseString string // 原始数据串
}

// REORDER 数据消息名称地址信息
// 示例：NAD+CN+88'
// 说明：Name and Address + CN=consignee + Plant site code
type NAD struct {
	Consignee      string // 收货人
	ConsigneePlant int    // 收货厂编号
	ParseString    string // 原始数据串
}

// REORDER 文本区
// 示例：FTX+ZZZ+++202104731:2015:0001'
// 说明：Free text + ZZZ to be entered as the default value for identification of reason for scraping  / comment +++ Rejection number : Year : Version number
type FTX struct {
	RejectionNum string // 返工号
	Year         int    // 年份
	VerNum       string //版本号
	ParseString  string // 原始数据串
}

// REORDER 排序号
// 示例：SEQ+3'
// 说明：Sequence details + 3=Generation
type SEQ struct {
	SeqType     int // 3=新建；1=变更；2=取消
	Gir         GIR
	LinList     []LIN
	ParseString string // 原始数据串
}

// REORDER 排序订单相关信息
// 示例：GIR+4+32091571:AN+TVKH2K:VG'
// 说明：Related Identification Numbers + 4=vehicle identification set + EINSTEIN order number  : AN=Manufacturing reference number
//		+ Name of Supply Group : VG=Supply Group
type GIR struct {
	VehicleIdSet string // 车辆识别集
	CustOrderNr  string // 客户订单号
	SupplyGroup  string // 供应组
	ParseString  string // 原始数据串
}

// REORDER 数据消息零件信息
// 示例：LIN+++2992888:IN'
// 说明：LIN=line item +++ Part number : IN= Buyers item number
type LIN struct {
	PartNr      string // 零件号
	Pia         PIA    // 零件号版本信息
	Qty         QTY    // 零件数量信息
	ParseString string // 原始数据串
}

// REORDER 数据消息零件版本信息
// 示例：PIA+1+11:EC'
// 说明：PIA=Additional product ID + 1 = Product + Additional Identificaiton – E.g. 00, 01, 02…  : EC=engineering change level
type PIA struct {
	Ai           string // 版本号
	ChangeReason string // 变更原因
	ParseString  string // 原始数据串
}

// REORDER 数据消息数量信息
// 示例：QTY+131:1000'
// 说明：QTY=Quantity + 131=Quantity unit in pieces : Quantity including 3 decimal places without dot (1000=1 2000=2)
type QTY struct {
	QtyType     int    // 数量类型： 131 = 交付数量
	OriQty      int    // 文件定义数量（*1000）
	Qty         int    // 零件数量 = OriQty / 1000
	ParseString string // 原始数据串
}

// REORDER 数据消息尾
// 示例：UNT+21+1494012057'
// 说明：Message Trailer + Number of segments + Message Reference Number like UNH
type UNT struct {
	DataRows    int    // 数据行数，从UNH到UNT总数
	MsgId       string // 消息标识
	ParseString string // 原始数据串
}

// REORDER 数据交换结束符
// 示例：UNZ+1+149401140123'
// 说明：End of message + 1 + Transmission Number like UNB
type UNZ struct {
	MsgCount    int    // 消息数
	MsgRefId    string // 消息参考号
	ParseString string // 原始数据串
}

// REORDER 消息对象
type REORDER struct {
	FileName string // REORDER
	DataRows int    // 包含数据行 UNH->UNT
	Unb      UNB    // 数据交换头
	Unh      UNH    // 数据消息头
	Bgm      BGM    // 数据消息开始
	Dtm      DTM    // 数据消息日期时间信息
	Rff      RFF
	Nad      NAD // 数据消息名称地址信息
	Ftx      FTX
	SeqList  []SEQ // 数据消息的零件族信息：零件、零件族、供应组、数量等信息
	Unt      UNT   // 数据消息尾
	Unz      UNZ   // 数据消息交换结束
}

// 示例：UNB+UNOA:1+ODX0SENDER00A+ODX0RECEIVER001+140123:2057+149401140123'
// 说明：Interchange header + Translator value + Sender’s Odette Code + Supplier’s Odette Code + Date:Time + Unique number
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) < 6 {
		return errors.New("UNB: Key value length less than 6, 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.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, " | MsgRefId:", unb.MsgRefId)
}

// 示例：UNH+1494012057+DELJIT:D:96A:UN'
// 说明：Message header 2 + Message Number + UN Standard
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)) != "DELJIT" {
		return errors.New("UNH: MsgType is not DELJIT!")
	}
	return
}
func (unh *UNH) Print() {
	fmt.Println("UNH | MsgId:", unh.MsgId, " | MsgType:", unh.MsgType)
}

// 示例：BGM+39::92+00017131'
// 说明：Begin of message + 39=Re-Order:: 92=BMW + Detective goods number (Similar to call off number)
func (bgm *BGM) Parse(parseString string) (err error) {
	var (
		kvlist []string
		kv1    []string
	)
	// 输入为空，返回错误
	if strings.TrimSpace(parseString) == "" {
		return errors.New("BGM: parse string is empty!")
	}
	// 基于+分隔符来解析字符串
	kvlist = strings.Split(parseString, "+")
	kv1 = strings.Split(kvlist[1], ":")
	if len(kv1) < 3 {
		return errors.New("BGM: kv1 value length less than 3, failed to parse!")
	}

	// 填充值
	bgm.MessageType, _ = strconv.Atoi(kv1[0])
	bgm.ReorderNum = kvlist[2]
	bgm.ParseString = parseString

	// 校验关键字段是否为空
	if strings.TrimSpace(bgm.ReorderNum) == "" {
		return errors.New("BGM: ReorderNum is empty!")
	}
	return
}
func (bgm *BGM) Print() {
	fmt.Println("BGM | ReorderNum:", bgm.ReorderNum)
}

// 示例：DTM+137:201506021252:203'
// 说明：Date / Time / Period + 137=Date and Time : Date / Time : 203=Format Date / Time
func (dtm *DTM) Parse(parseString string) (err error) {
	var (
		kvlist []string
		kv1    []string
	)
	// 输入为空，返回错误
	if strings.TrimSpace(parseString) == "" {
		return errors.New("DTM: parse string is empty!")
	}
	// 基于+分隔符来解析字符串
	kvlist = strings.Split(parseString, "+")
	kv1 = strings.Split(kvlist[1], ":")
	if len(kv1) < 2 {
		return errors.New("DTM: kv1 value length less than 2, failed to parse!")
	}

	// 填充值
	dtm.DateTimeType, _ = strconv.Atoi(kv1[0]) // 时间格式
	dtm.DateTimeFormat, _ = strconv.Atoi(kv1[2])
	dtm.MsgTimeFormat = common.GetTimeFormatByType(dtm.DateTimeFormat)
	if dtm.MsgTime, err = common.DateParse(kv1[1], dtm.MsgTimeFormat); err != nil {
		return errors.New("DTM: Failed to get the MsgTime!")
	}
	dtm.ParseString = parseString

	// 校验关键字段是否为空
	if strings.TrimSpace(dtm.MsgTimeFormat) == "" {
		return errors.New("DTM: MsgTimeFormat is empty!")
	}
	return
}
func (dtm *DTM) Print() {
	fmt.Println("DTM | DateTimeType:", dtm.DateTimeType, " | DateTimeFormat:", dtm.DateTimeFormat, " | MsgTime:", dtm.MsgTime)
}

// 示例：RFF+ZZZ:TVKKBR1'
// 说明：Reference Serial Number + ZZZ=User defined Text : Name of Parts Family
func (rff *RFF) Parse(parseString string) (err error) {
	var (
		kvlist []string
		kv1    []string
	)
	// 输入为空，返回错误
	if strings.TrimSpace(parseString) == "" {
		return errors.New("RFF: parse string is empty!")
	}
	// 基于+分隔符来解析字符串
	kvlist = strings.Split(parseString, "+")
	kv1 = strings.Split(kvlist[1], ":")
	if len(kv1) < 2 {
		return errors.New("RFF: kv1 value length less than 2, failed to parse!")
	}

	// 填充值
	rff.ParseString = parseString
	switch strings.TrimSpace(kv1[0]) {
	case "AAN":
		rff.RefType = "CALLOFF"
	case "ZZZ":
		rff.RefType = "PARTFAMILY"
		rff.PartFamily = kv1[1] // 零件族
		if strings.TrimSpace(rff.PartFamily) == "" {
			return errors.New("RFF: Partfamily is empty!")
		}
	default:

	}

	return
}
func (rff *RFF) Print() {
	fmt.Println("RFF | Partfamily:", rff.PartFamily)
}

// 示例：NAD+CN+88'
// 说明：Name and Address + CN=consignee + Plant site code
func (nad *NAD) Parse(parseString string) (err error) {
	var (
		kvlist []string
	)
	// 输入为空，返回错误
	if strings.TrimSpace(parseString) == "" {
		return errors.New("NAD: parse string is empty!")
	}
	// 基于+分隔符来解析字符串
	kvlist = strings.Split(parseString, "+")

	// 填充值
	nad.Consignee = kvlist[1]                       // 收货人
	nad.ConsigneePlant, _ = strconv.Atoi(kvlist[2]) // 收货厂编号
	nad.ParseString = parseString

	// 校验关键字段是否为空
	if strings.TrimSpace(nad.Consignee) == "" {
		return errors.New("NAD: Consignee is empty!")
	}
	if nad.ConsigneePlant <= 0 {
		return errors.New("NAD: ConsigneePlant is not existing!")
	}
	return
}
func (nad *NAD) Print() {
	fmt.Println("NAD | Consignee:", nad.Consignee, " | ConsigneePlant:", nad.ConsigneePlant)
}

// 示例：FTX+ZZZ+++202104731:2015:0001'
// 说明：Free text + ZZZ to be entered as the default value for identification of reason for scraping  / comment +++ Rejection number : Year : Version number
func (ftx *FTX) Parse(parseString string) (err error) {
	var (
		kvlist []string
		kv4    []string
	)
	// 输入为空，返回错误
	if strings.TrimSpace(parseString) == "" {
		return errors.New("FTX: parse string is empty!")
	}
	// 基于+分隔符来解析字符串
	kvlist = strings.Split(parseString, "+")
	kv4 = strings.Split(kvlist[4], ":")
	if len(kv4) < 3 {
		return errors.New("FTX: kv4 value length less than 3, failed to parse!")
	}

	// 填充值
	ftx.RejectionNum = kv4[0] // 返工号
	ftx.Year, _ = strconv.Atoi(kv4[1])
	ftx.VerNum = kv4[2]
	ftx.ParseString = parseString

	// 校验关键字段是否为空
	if strings.TrimSpace(ftx.RejectionNum) == "" {
		return errors.New("FTX: RejectionNum is empty!")
	}
	return
}
func (ftx *FTX) Print() {
	fmt.Println("FTX | RejectionNum:", ftx.RejectionNum)
}

// 示例：SEQ+3'
// 说明：Sequence details + 3=Generation
func (seq *SEQ) Parse(parseString string) (err error) {
	var (
		kvlist []string
	)
	// 输入为空，返回错误
	if strings.TrimSpace(parseString) == "" {
		return errors.New("SEQ: parse string is empty!")
	}
	// 基于+分隔符来解析字符串
	kvlist = strings.Split(parseString, "+")

	// 填充值
	seq.SeqType, _ = strconv.Atoi(kvlist[1]) // 3=新建；1=更新；2=取消
	seq.ParseString = parseString

	// 校验关键字段是否为空
	if seq.SeqType < 1 || seq.SeqType > 3 {
		return errors.New("SEQ: Unvalid seq type!")
	}
	return
}
func (seq *SEQ) Print() {
	fmt.Println("SEQ | SEQ + ", seq.SeqType)
}

// 示例：GIR+4+32091571:AN+TVKH2K:VG'
// 说明：Related Identification Numbers + 4=vehicle identification set + EINSTEIN order number  : AN=Manufacturing reference number
//		+ Name of Supply Group : VG=Supply Group
func (gir *GIR) Parse(parseString string) (err error) {
	var (
		kvlist   []string
		kv2, kv3 []string
	)
	// 输入为空，返回错误
	if strings.TrimSpace(parseString) == "" {
		return errors.New("GIR: parse string is empty!")
	}
	// 基于+分隔符来解析字符串
	kvlist = strings.Split(parseString, "+")
	kv2 = strings.Split(kvlist[2], ":")
	kv3 = strings.Split(kvlist[3], ":")
	if len(kv2) < 1 || len(kv3) < 1 {
		return errors.New("GIR: kv2/3 value length less than 1, failed to parse!")
	}

	// 填充值
	gir.VehicleIdSet = kvlist[1] // 车辆集号
	gir.SupplyGroup = kv3[0]     // 供应组
	gir.CustOrderNr = kv2[0]     // 客户订单号
	gir.ParseString = parseString

	// 校验关键字段是否为空
	if strings.TrimSpace(gir.SupplyGroup) == "" {
		return errors.New("GIR: SupplyGroup is empty!")
	}
	if strings.TrimSpace(gir.CustOrderNr) == "" {
		return errors.New("GIR: CustOrderNr is empty!")
	}
	return
}
func (gir *GIR) Print() {
	fmt.Println("GIR | SupplyGroup:", gir.SupplyGroup, " | CustOrderNr:", gir.CustOrderNr)
}

// 示例：LIN+++2992888:IN'
// 说明：LIN=line item +++ Part number : IN= Buyers item number
func (lin *LIN) Parse(parseString string) (err error) {
	var (
		kvlist []string
		kv3    []string
	)
	// 输入为空，返回错误
	if strings.TrimSpace(parseString) == "" {
		return errors.New("LIN: parse string is empty!")
	}
	// 基于+分隔符来解析字符串
	kvlist = strings.Split(parseString, "+")
	kv3 = strings.Split(kvlist[3], ":")
	if len(kv3) < 1 {
		return errors.New("LIN: kv3 value length less than 1, failed to parse!")
	}

	// 填充值
	lin.PartNr = kv3[0] // 零件号
	lin.ParseString = parseString

	// 校验关键字段是否为空
	if strings.TrimSpace(lin.PartNr) == "" {
		return errors.New("LIN: PartNr is empty!")
	}
	return
}
func (lin *LIN) Print() {
	fmt.Println("LIN | PartNr:", lin.PartNr)
}

// 示例：PIA+1+11:EC'
// 说明：PIA=Additional product ID + 1 = Product + Additional Identificaiton – E.g. 00, 01, 02…  : EC=engineering change level
func (pia *PIA) Parse(parseString string) (err error) {
	var (
		kvlist []string
		kv2    []string
	)
	// 输入为空，返回错误
	if strings.TrimSpace(parseString) == "" {
		return errors.New("PIA: parse string is empty!")
	}
	// 基于+分隔符来解析字符串
	kvlist = strings.Split(parseString, "+")
	kv2 = strings.Split(kvlist[2], ":")
	if len(kv2) < 2 {
		return errors.New("PIA: kv2 value length less than 2, failed to parse!")
	}

	// 填充值
	pia.Ai = kv2[0] // 零件版本号
	pia.ChangeReason = kv2[1]
	pia.ParseString = parseString

	// 校验关键字段是否为空
	if strings.TrimSpace(pia.Ai) == "" {
		return errors.New("PIA: Part AI is empty!")
	}
	return
}
func (pia *PIA) Print() {
	fmt.Println("PIA | AI:", pia.Ai)
}

// 示例：QTY+131:1000'
// 说明：QTY=Quantity + 131=Quantity unit in pieces : Quantity including 3 decimal places without dot (1000=1 2000=2)
func (qty *QTY) Parse(parseString string) (err error) {
	var (
		kvlist []string
		kv1    []string
	)
	// 输入为空，返回错误
	if strings.TrimSpace(parseString) == "" {
		return errors.New("QTY: parse string is empty!")
	}
	// 基于+分隔符来解析字符串
	kvlist = strings.Split(parseString, "+")
	kv1 = strings.Split(kvlist[1], ":")
	if len(kv1) < 2 {
		return errors.New("QTY: kv1 value length less than 2, failed to parse!")
	}

	// 填充值
	if qty.QtyType, err = strconv.Atoi(kv1[0]); err != nil {
		return errors.New("QTY: Failed to get qty type!")
	} // 零件版本号
	if qty.OriQty, err = strconv.Atoi(kv1[1]); err != nil {
		return errors.New("QTY: Failed to get original qty!")
	}
	qty.Qty = qty.OriQty / 1000

	return
}
func (qty *QTY) Print() {
	fmt.Println("QTY | Qty:", qty.Qty)
}

// 示例：UNT+21+1494012057'
// 说明：Message Trailer + Number of segments + Message Reference Number like UNH
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)
}

// 示例：UNZ+1+149401140123'
// 说明：End of message + 1 + Transmission Number like UNB
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)
}