leo
/
LAPP_SJA_APS_BACKEND
1
0
Fork 0
Code Issues 0 Pull Requests 0 Projects 0 Releases 0 Wiki Activity
SJA APS后端代码
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.
33 Commits
10 Branches
1.8 MiB
 
Branch: master
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'master'
${ noResults }
LAPP_SJA_APS_BACKEND/reorder/Reorder.go

649 lines
19 KiB
Raw Permalink Blame History

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)
}