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.
530 lines
15 KiB
530 lines
15 KiB
package calloff
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"leit.com/leit_seat_aps/common"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
// SEQ 数据交换头
|
|
type UNB struct {
|
|
Sender string // 发送方
|
|
Reciever string // 接收方
|
|
MsgTime time.Time // 消息时间
|
|
MsgCtrlPara string // 消息交互控制参数
|
|
ParseString string // 原始消息数据串
|
|
}
|
|
|
|
// CALLOFF 数据消息头
|
|
type UNH struct {
|
|
MsgId string // 消息标识ID
|
|
MsgType string // 消息类型 DELJIT
|
|
MsgTypeVersion string // 消息类型版本号
|
|
MsgTypeRelNo string // 消息类型版本释放号
|
|
ParseString string // 原始数据串
|
|
}
|
|
|
|
// CALLOFF 数据消息开始
|
|
type BGM struct {
|
|
MessageType int // 消息类型 30 = TOD / 221 = SEQ / 36 = CALLOFF
|
|
DeliveryPlant int // 发运目标工厂 92 = BBA
|
|
CheckSequence string // 检查排序号
|
|
ParseString string // 原始数据串
|
|
}
|
|
|
|
// CALLOFF 数据消息日期时间信息
|
|
type DTM struct {
|
|
DateTimeType int // 137 = 消息日期 / 42 = 计划开始装配时间 / 2 = SWET 客户要求的来料时间
|
|
DateTimeFormat int // 日期时间格式：203 = CCYYMMDDHHMM / 204 = CCYYMMDDHHMMSS
|
|
MsgTime time.Time // 消息时间
|
|
MsgTimeFormat string // 消息时间格式
|
|
ParseString string // 原始数据串
|
|
}
|
|
|
|
// CALLOFF 参考信息
|
|
type RFF struct {
|
|
RefType string // CALLOFF = AAN / PARTFAMILY = ZZZ
|
|
CallOffNum string // 发运排序号
|
|
PartFamily string // 零件族
|
|
ParseString string // 原始数据串
|
|
}
|
|
|
|
// CALLOFF 数据消息名称地址信息
|
|
type NAD struct {
|
|
Consignee string // 收货人
|
|
ConsigneePlant int // 收货厂编号 10 = Dadong / 66 = Shengbei / 88 = Tiexi
|
|
ConsigneeCompany int // 收货公司编号 92 = BBA
|
|
ParseString string // 原始数据串
|
|
}
|
|
|
|
// CALLOFF 地点信息
|
|
// LOC+4+PD::92:00+PC::92:10’
|
|
// Location + 4=goods receipt place + PD=place of unloading :: 92 = BBA: Place of unloading
|
|
// + PC=place of consumption :: 92 = BBA : Place of consumption
|
|
|
|
type LOC struct {
|
|
LocType int // 44 = 文档发出地 / 83 = 货物发运地 / 4 = 收货地
|
|
UnloadingPlace string // 卸货地点
|
|
ConsumeCompany int // 使用公司
|
|
ConsumePlant int // 使用工厂
|
|
ParseString string // 原始数据串
|
|
}
|
|
|
|
// CALLOFF 排序号
|
|
type SEQ struct {
|
|
SeqType int // 3=新建；1=变更；2=取消
|
|
Gir GIR
|
|
ParseString string // 原始数据串
|
|
}
|
|
|
|
// CALLOFF 排序订单相关信息
|
|
// 示例：GIR+4+43738111:AN+4173’
|
|
// Related Identification Numbers + 4=vehicle identification set
|
|
// + EINSTEIN order number : AN=Manufacturing reference number
|
|
// + Data string with free format vehicle identification = last 4 digits of check sequence number
|
|
// out of BGM segment (BGM+36::92+00014173’) It can be used as vehicle identification like VIN in production release message
|
|
type GIR struct {
|
|
VehicleIdSet string // 车辆识别集
|
|
CustOrderNr string // 客户订单号
|
|
VehicleId string // 车辆识别号
|
|
ParseString string // 原始数据串
|
|
}
|
|
|
|
// CALLOFF 数据消息尾
|
|
type UNT struct {
|
|
DataRows int // 数据行数，从UNH到UNT总数
|
|
MsgId string // 消息标识
|
|
ParseString string // 原始数据串
|
|
}
|
|
|
|
// CALLOFF 数据交换结束符
|
|
type UNZ struct {
|
|
MsgCount int // 消息数
|
|
MsgRefId string // 消息参考号
|
|
ParseString string // 原始数据串
|
|
}
|
|
|
|
// CALLOFF 消息对象
|
|
type CALLOFF struct {
|
|
FileName string // TOD文件名
|
|
DataRows int // 包含数据行 UNH->UNT
|
|
Unb UNB // 数据交换头
|
|
Unh UNH // 数据消息头
|
|
Bgm BGM // 数据消息开始
|
|
DtmMsg DTM // 数据消息日期时间信息
|
|
DtmDelivery DTM // 发运时间信息
|
|
RffCF RFF // 参考信息: 发运Calloff号
|
|
RffPF RFF // 参考信息：发运的PartFamily号
|
|
Nad NAD // 数据消息名称地址信息
|
|
Loc LOC // 地址信息
|
|
SeqList []SEQ // 数据消息的零件族信息：零件、零件族、供应组、数量等信息
|
|
Unt UNT // 数据消息尾
|
|
Unz UNZ // 数据消息交换结束
|
|
}
|
|
|
|
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.MsgCtrlPara = kvlist[5] // 消息控制参数
|
|
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!")
|
|
}
|
|
return
|
|
}
|
|
|
|
func (unb *UNB) Print() {
|
|
fmt.Println("UNB | Sender:", unb.Sender, " | Reciever:", unb.Reciever, " | MsgTime:", unb.MsgTime, " | MsgCtrlPara:", unb.MsgCtrlPara)
|
|
}
|
|
|
|
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+36::92+00200557'
|
|
// 解析：+37生产下达36发运CallOff：：92BBA+检查排序号（允许供应商检查所有请求已接收）
|
|
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]) // 30=TOD；37生产下达 36发运 242=SEQ
|
|
bgm.DeliveryPlant, _ = strconv.Atoi(kv1[2]) // 92 = BBA
|
|
bgm.CheckSequence = kvlist[2] // 检查排序号
|
|
bgm.ParseString = parseString
|
|
|
|
// 校验关键字段是否为空
|
|
if strings.TrimSpace(bgm.CheckSequence) == "" {
|
|
return errors.New("BGM: CheckSequence is empty!")
|
|
}
|
|
return
|
|
}
|
|
|
|
func (bgm *BGM) Print() {
|
|
fmt.Println("BGM | CheckSequence:", bgm.CheckSequence)
|
|
}
|
|
|
|
// 消息文档时间：DTM+137:200902201510:203'
|
|
// 发运时间信息：DTM+2:200902231011:203' OR DTM+2:20090223101159:204'
|
|
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) < 3 {
|
|
return errors.New("DTM: kv1 value length less than 3, 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+AAN:131642' => +AAN(Delivery CallOff号）：131553
|
|
// RFF+ZZZ:STFKBR3 ' =>+ZZZ：零件族号（<8位）
|
|
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"
|
|
rff.CallOffNum = kv1[1]
|
|
if strings.TrimSpace(rff.CallOffNum) == "" {
|
|
return errors.New("RFF: CallOffNum is empty!")
|
|
}
|
|
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 | CallOffNum:", rff.CallOffNum, "| Partfamily:", rff.PartFamily)
|
|
}
|
|
|
|
// 示例：NAD+CN+88::92
|
|
func (nad *NAD) Parse(parseString string) (err error) {
|
|
var (
|
|
kvlist []string
|
|
kv2 []string
|
|
)
|
|
// 输入为空，返回错误
|
|
if strings.TrimSpace(parseString) == "" {
|
|
return errors.New("NAD: parse string is empty!")
|
|
}
|
|
// 基于+分隔符来解析字符串
|
|
kvlist = strings.Split(parseString, "+")
|
|
kv2 = strings.Split(kvlist[2], ":")
|
|
if len(kv2) < 1 {
|
|
return errors.New("NAD: kv2 value length less than 1, failed to parse!")
|
|
}
|
|
|
|
// 填充值
|
|
nad.Consignee = kvlist[1] // 收货人
|
|
nad.ConsigneePlant, _ = strconv.Atoi(kv2[0]) // 收货厂编号 10=Dadong，66=Shengbei；88=Tiexi
|
|
nad.ConsigneeCompany, _ = strconv.Atoi(kv2[2]) // 收货公司编号 92 = BBA
|
|
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!")
|
|
}
|
|
if nad.ConsigneeCompany <= 0 {
|
|
return errors.New("NAD: ConsigneeCompany is not existing!")
|
|
}
|
|
return
|
|
}
|
|
|
|
func (nad *NAD) Print() {
|
|
fmt.Println("NAD | Consignee:", nad.Consignee, " | ConsigneePlant:", nad.ConsigneePlant, " | ConsigneeCompany:", nad.ConsigneeCompany)
|
|
}
|
|
|
|
// 示例1：LOC+4+PD::92:00+PC::92:88'
|
|
// +4收货地点标识+PD卸货地点：：92BBA：00+PC消耗地点：：92BBA：88Tiexi
|
|
func (loc *LOC) Parse(parseString string) (err error) {
|
|
var (
|
|
kvlist []string
|
|
kv2 []string
|
|
kv3 []string
|
|
)
|
|
// 输入为空，返回错误
|
|
if strings.TrimSpace(parseString) == "" {
|
|
return errors.New("LOC: parse string is empty!")
|
|
}
|
|
// 基于+分隔符来解析字符串
|
|
kvlist = strings.Split(parseString, "+")
|
|
kv2 = strings.Split(kvlist[2], ":")
|
|
if len(kv2) < 4 {
|
|
return errors.New("LOC: kv2 value length less than 4, failed to parse!")
|
|
}
|
|
kv3 = strings.Split(kvlist[3], ":")
|
|
if len(kv3) < 4 {
|
|
return errors.New("LOC: kv3 value length less than 4, failed to parse!")
|
|
}
|
|
|
|
// 填充值
|
|
loc.LocType, _ = strconv.Atoi(kvlist[1]) // 44 = 文档发出地 / 83 = 货物发运地 / 4 = 收货地
|
|
loc.UnloadingPlace = kv2[2]
|
|
loc.ConsumeCompany, _ = strconv.Atoi(kv3[2])
|
|
loc.ConsumePlant, _ = strconv.Atoi(kv3[3])
|
|
loc.ParseString = parseString
|
|
|
|
// 校验关键字段是否为空
|
|
if loc.LocType <= 0 {
|
|
return errors.New("LOC: LocType is empty!")
|
|
}
|
|
return
|
|
}
|
|
|
|
func (loc *LOC) Print() {
|
|
fmt.Println("LOC | LocType:", loc.LocType, " | UnloadingPlace:", loc.UnloadingPlace, " | ConsumeCompany:", loc.ConsumeCompany, " | ConsumePlantSite:", loc.ConsumePlant)
|
|
}
|
|
|
|
// 示例：SEQ+3’
|
|
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+69472141:AN+0557'
|
|
// +4车辆识别集+订单号订单类型（最后一位是订单类型）：AN+车辆识别的自由文本
|
|
func (gir *GIR) Parse(parseString string) (err error) {
|
|
var (
|
|
kvlist []string
|
|
kv2 []string
|
|
)
|
|
// 输入为空，返回错误
|
|
if strings.TrimSpace(parseString) == "" {
|
|
return errors.New("GIR: parse string is empty!")
|
|
}
|
|
// 基于+分隔符来解析字符串
|
|
// GIR+1+00024391:AQ+00000966:ML+12373531:AN + GX38594 : VN
|
|
kvlist = strings.Split(parseString, "+")
|
|
kv2 = strings.Split(kvlist[2], ":")
|
|
if len(kv2) < 2 {
|
|
return errors.New("GIR: kv2 value length less than 2, failed to parse!")
|
|
}
|
|
|
|
// 填充值
|
|
gir.VehicleIdSet = kvlist[1] // 车辆识别集
|
|
gir.CustOrderNr = kv2[0] // 客户订单号
|
|
gir.VehicleId = kvlist[3] // 车辆识别号
|
|
gir.ParseString = parseString
|
|
|
|
// 校验关键字段是否为空
|
|
if strings.TrimSpace(gir.CustOrderNr) == "" {
|
|
return errors.New("GIR: CustOrderNr is empty!")
|
|
}
|
|
if strings.TrimSpace(gir.VehicleId) == "" {
|
|
return errors.New("GIR: VehicleId is empty!")
|
|
}
|
|
return
|
|
}
|
|
|
|
func (gir *GIR) Print() {
|
|
fmt.Println("GIR | CustOrderNr:", gir.CustOrderNr, " | VehicleId:", gir.VehicleId)
|
|
}
|
|
|
|
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)
|
|
}
|
|
|
|
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)
|
|
}
|