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.
661 lines
20 KiB
661 lines
20 KiB
package service
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"github.com/go-xorm/xorm"
|
|
"leit.com/leit_seat_aps/common"
|
|
"leit.com/leit_seat_aps/db"
|
|
"leit.com/leit_seat_aps/glog"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
// 用于生产包装的项目主数据对象
|
|
type ProdProject struct {
|
|
Projectid string
|
|
Projecttab db.Prod_project // 项目表
|
|
Packtmpldict map[string]BL_ProdPackTmp // 生产包装模板
|
|
Paktypdict map[string]db.Prod_packtype // 生产包装类型
|
|
Sgdict map[string]db.Me_supplygroup // 供应组
|
|
Pfdict map[string]db.Me_partfamily // 零件族
|
|
}
|
|
|
|
// 加载项目的主数据
|
|
func (pproj *ProdProject) LoadMasterData() (err error) {
|
|
// 读取项目的零件族主数据
|
|
if err = pproj.LoadPartFamily(); err != nil {
|
|
return
|
|
}
|
|
// 读取项目的包装类型主数据
|
|
if err = pproj.LoadPackType(); err != nil {
|
|
return
|
|
}
|
|
// 读取项目的供应组主数据
|
|
if err = pproj.LoadSupplyGroup(); err != nil {
|
|
return
|
|
}
|
|
// 读取项目的发运包装模板主数据
|
|
if err = pproj.LoadPackageTemplate(); err != nil {
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 加载项目的发运包装模板
|
|
func (pproj *ProdProject) LoadPackageTemplate() (err error) {
|
|
var (
|
|
paktmpltab db.Prod_packtemplate
|
|
paktmpltablst []db.Prod_packtemplate
|
|
bl_sp BL_ProdPackTmp
|
|
i,j int
|
|
)
|
|
// 初始化
|
|
pproj.Packtmpldict = make(map[string]BL_ProdPackTmp)
|
|
paktmpltab = db.Prod_packtemplate{}
|
|
// 读取项目发运包装模板数据
|
|
if paktmpltablst, err = paktmpltab.GetProjectAll(pproj.Projectid); err != nil {
|
|
return
|
|
}
|
|
|
|
for i = 0; i < len(paktmpltablst); i++ {
|
|
bl_sp = BL_ProdPackTmp{}
|
|
bl_sp.SgDict = make(map[string]string)
|
|
bl_sp.PackTmplId = paktmpltablst[i].Packtemplateid
|
|
bl_sp.Paktmpltab = paktmpltablst[i]
|
|
for j = 0; j < len(paktmpltablst[i].Itemlst); j++ {
|
|
bl_sp.SgDict[paktmpltablst[i].Itemlst[j].Supplygroupid] = paktmpltablst[i].Itemlst[j].Supplygroupid
|
|
}
|
|
pproj.Packtmpldict[bl_sp.PackTmplId] = bl_sp
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 加载包装类型
|
|
func (pproj *ProdProject) LoadPackType() (err error) {
|
|
var (
|
|
paktyptab db.Prod_packtype
|
|
paktyptablst []db.Prod_packtype
|
|
i int
|
|
)
|
|
// 初始化
|
|
pproj.Paktypdict = make(map[string]db.Prod_packtype)
|
|
paktyptab = db.Prod_packtype{}
|
|
paktyptablst = []db.Prod_packtype{}
|
|
if paktyptablst, err = paktyptab.GetProjectAll(pproj.Projectid); err != nil {
|
|
return
|
|
}
|
|
for i = 0; i < len(paktyptablst); i++ {
|
|
pproj.Paktypdict[paktyptablst[i].Packtypeid] = paktyptablst[i]
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 加载供应组信息
|
|
func (pproj *ProdProject) LoadSupplyGroup() (err error) {
|
|
var (
|
|
sgtab db.Me_supplygroup
|
|
sgtablst []db.Me_supplygroup
|
|
i int
|
|
)
|
|
// 初始化
|
|
pproj.Sgdict = make(map[string]db.Me_supplygroup)
|
|
sgtab = db.Me_supplygroup{}
|
|
sgtablst = []db.Me_supplygroup{}
|
|
if sgtablst, err = sgtab.GetProjectAll(pproj.Projectid); err != nil {
|
|
return
|
|
}
|
|
for i = 0; i < len(sgtablst); i++ {
|
|
pproj.Sgdict[sgtablst[i].Supplygroupid] = sgtablst[i]
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 获取项目的零件族字典
|
|
func (pproj *ProdProject) LoadPartFamily() (err error) {
|
|
var (
|
|
pftab db.Me_partfamily
|
|
pftablst []db.Me_partfamily
|
|
i int
|
|
)
|
|
|
|
// 初始化项目的零件族字典
|
|
pproj.Pfdict = make(map[string]db.Me_partfamily)
|
|
pftab = db.Me_partfamily{}
|
|
if pftablst, err = pftab.GetProjectPfList(pproj.Projectid); err != nil {
|
|
return
|
|
}
|
|
|
|
// 遍历零件族列表并写入字典
|
|
for i = 0; i < len(pftablst); i++ {
|
|
pproj.Pfdict[pftablst[i].Partfamilyid] = pftablst[i]
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 获取项目供应组的包装排序
|
|
func (pproj *ProdProject) GetSupplyGroupPackSortWay(sgid string) (sortway string) {
|
|
var (
|
|
bl_paktmp BL_ProdPackTmp
|
|
paktmpitemtab db.Prod_packtemplate_itemlst
|
|
paktyptab db.Prod_packtype
|
|
ok bool
|
|
)
|
|
|
|
// 判断供应组
|
|
if _, ok = pproj.Sgdict[sgid]; !ok {
|
|
glog.Infoln("包装匹配", "工单的供应组在当前项目中不存在！",sgid,pproj.Projectid)
|
|
sortway = common.MESPACK_SORT_RELSEQ
|
|
return
|
|
}
|
|
|
|
// 获取供应组对应的包装单模板
|
|
ok = false
|
|
for _, bl_paktmp = range pproj.Packtmpldict {
|
|
for _, paktmpitemtab = range bl_paktmp.Paktmpltab.Itemlst {
|
|
if paktmpitemtab.Supplygroupid == sgid {
|
|
ok = true
|
|
break
|
|
}
|
|
}
|
|
if ok {
|
|
break
|
|
}
|
|
}
|
|
|
|
if !ok {
|
|
sortway = common.MESPACK_SORT_RELSEQ
|
|
glog.Infoln("包装匹配", "工单的供应组没有对应的包装模板！",sgid,pproj.Projectid)
|
|
return
|
|
}
|
|
|
|
// 获取包装模板的包装类型
|
|
if paktyptab, ok = pproj.Paktypdict[bl_paktmp.Paktmpltab.Packtypeid]; !ok {
|
|
sortway = common.MESPACK_SORT_RELSEQ
|
|
glog.Infoln("包装匹配", "工单的供应组对应的包装模板的包装类型在当前项目中不存在！",sgid,bl_paktmp.Paktmpltab.Packtemplateid,bl_paktmp.Paktmpltab.Packtypeid)
|
|
return
|
|
}
|
|
|
|
sortway = paktyptab.Sortorder
|
|
return
|
|
}
|
|
|
|
// 判断两者的pfid是否一致
|
|
func (pproj *ProdProject) IsSamePartFamily(sgid, chksgid string)(same bool){
|
|
var(
|
|
sgtab, chksgtab db.Me_supplygroup
|
|
)
|
|
|
|
sgtab, _ = pproj.Sgdict[sgid]
|
|
chksgtab, _ = pproj.Sgdict[chksgid]
|
|
if chksgtab.Partfamilyid != sgtab.Partfamilyid {
|
|
return false
|
|
}else{
|
|
return true
|
|
}
|
|
}
|
|
|
|
// 基于项目的供应组获取需要生产包装的生产订单
|
|
func (pproj *ProdProject) CreatePackOrderRelMsg(packordid string, session *xorm.Session)(err error){
|
|
var(
|
|
bl_msg BL_Mesmsg
|
|
)
|
|
|
|
bl_msg = BL_Mesmsg{}
|
|
bl_msg.MsgType = common.MESMSG_TYPE_PACK
|
|
bl_msg.MsgEvent = common.MESMSG_EVENT_RELPACK
|
|
bl_msg.MsgObjid = packordid
|
|
bl_msg.MsgiPara1 = 0
|
|
bl_msg.MsgiPara2 = 0
|
|
bl_msg.MsgcPara1 = pproj.Projectid
|
|
bl_msg.MsgcPara2 = ""
|
|
if err = bl_msg.CreateProdPackMsg(session); err != nil {
|
|
err = errors.New(fmt.Sprintf("插入包装单：%s下达消息失败：%v", packordid, err))
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 基于指定起始的OEMSEQ号按oemseq和worklineid排序依次获取未进行生产包装的生产订单
|
|
func (pproj *ProdProject) GetUnpackedWorkorderListByOemseq()(wotablst []db.Pln_workorder, err error){
|
|
var (
|
|
i int
|
|
wotab db.Pln_workorder
|
|
wopacktab db.Prod_wo_packstatus
|
|
vwotablst []db.VWorkOrderPackStatus
|
|
)
|
|
|
|
// 获取项目的起始OEMSEQ, 查询未包装订单
|
|
if vwotablst, err = wopacktab.GetUnpackedWOByStartOemseq(pproj.Projecttab.Startoemseq, pproj.Projecttab.Endoemseq); err != nil {
|
|
err = errors.New(fmt.Sprintf("基于起始OEMSEQ:%d获取未包装生产订单失败:%v",pproj.Projecttab.Startoemseq, err))
|
|
return
|
|
}
|
|
// 返回数据
|
|
wotablst = []db.Pln_workorder{}
|
|
for i = 0; i < len(vwotablst); i++ {
|
|
wotab = vwotablst[i].Pln_workorder
|
|
wotab.Clipped()
|
|
wotablst = append(wotablst, wotab)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 下达包装单
|
|
// 1. 必须满包，检查包装项数量是否满足
|
|
// 2. 可以不满包，检查已下达的OEMSEQ数是否达标，如果不达标，则检查剩余填充项是否存在维保的WO（基于OEMSEQ+SGID检索）
|
|
func (pproj *ProdProject) ReleasePackOrder(session *xorm.Session, bl_pakord BL_ProdPackOrder) (relstat bool, err error) {
|
|
var (
|
|
i int
|
|
pakordtab db.Prod_packorder
|
|
wotab db.Pln_workorder
|
|
bl_paktpl BL_ProdPackTmp
|
|
ok,exist bool
|
|
)
|
|
|
|
relstat= false
|
|
|
|
// 查询包装单数据
|
|
pakordtab = db.Prod_packorder{Finr: db.G_FINR, Packorderid: bl_pakord.PackorderId}
|
|
if bl_pakord.Pkotab, err = pakordtab.SelectOneBySession(session); err != nil {
|
|
return
|
|
}
|
|
|
|
// 获取包装单完整数据，检查包装单状态是否满足
|
|
if bl_pakord.Pkotab.Status >= common.PKO_STATUS_RELEASED {
|
|
return
|
|
}
|
|
|
|
// 获取包装单的模板
|
|
if bl_paktpl, ok = pproj.Packtmpldict[bl_pakord.Pkotab.Packtemplateid]; !ok {
|
|
err = errors.New(fmt.Sprintf("Packorder %s template %s is not existing in global template dict!", bl_pakord.Pkotab.Packorderid, bl_pakord.Pkotab.Packtemplateid))
|
|
return
|
|
}
|
|
|
|
// 更新包装单模板和包装单的填充状态
|
|
bl_paktpl.RefreshFillStatus()
|
|
bl_pakord.RefreshFillStatus()
|
|
|
|
// 基于不同类型的包装下达模式进行处理
|
|
if bl_paktpl.Paktmpltab.Unfullfillable > 0 {
|
|
if bl_pakord.OemseqCount >= bl_paktpl.OemseqCount {
|
|
// 检查剩余未填充的工单是否存在
|
|
ok = true
|
|
for i = 0; i < len(bl_pakord.Pkotab.Itemlst); i++{
|
|
if bl_pakord.Pkotab.Itemlst[i].Status >= common.PKO_STATUS_RELEASED{
|
|
continue
|
|
}
|
|
if exist, wotab, err = wotab.GetByProjectOemSeqSg(session, bl_pakord.Pkotab.Projnr,bl_pakord.Pkotab.Itemlst[i].Oemseq,bl_pakord.Pkotab.Itemlst[i].Supplygroupid); err != nil{
|
|
err = errors.New(fmt.Sprintf("查找项目 %s OEMSEQ %s 供应组 %s 的工单失败!", bl_pakord.Pkotab.Projnr,bl_pakord.Pkotab.Itemlst[i].Oemseq,bl_pakord.Pkotab.Itemlst[i].Supplygroupid))
|
|
return
|
|
}
|
|
if exist && (wotab.Packstatus <= 0){
|
|
ok = false
|
|
break
|
|
}
|
|
}
|
|
|
|
if ok {
|
|
// 达到下达条件
|
|
if err = bl_pakord.Release(session, bl_pakord.FillQty); err != nil {
|
|
return
|
|
}
|
|
relstat= true
|
|
}
|
|
}
|
|
} else {
|
|
// 检查包装项是否都已填满，如果是，则释放包装订单
|
|
if bl_pakord.FillQty >= bl_pakord.Pkotab.Planqty {
|
|
// 达到下达条件
|
|
if err = bl_pakord.Release(session, bl_pakord.FillQty); err != nil {
|
|
return
|
|
}
|
|
relstat= true
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 基于指定供应组寻找匹配的包装单模板
|
|
func (pproj *ProdProject) GetPackTemplateListBySupplyGroup(sgid string) (rettpldict map[string]string) {
|
|
var (
|
|
tpldict map[string]BL_ProdPackTmp
|
|
bl_paktpl, bl_paktpl2 BL_ProdPackTmp
|
|
i int
|
|
matched bool
|
|
)
|
|
|
|
// 初始化
|
|
tpldict = make(map[string]BL_ProdPackTmp)
|
|
|
|
// 基于sgid查询获取包装模板ID
|
|
for _, bl_paktpl = range pproj.Packtmpldict {
|
|
matched = false
|
|
for i = 0; i < len(bl_paktpl.Paktmpltab.Itemlst); i++ {
|
|
if strings.TrimSpace(sgid) == strings.TrimSpace(bl_paktpl.Paktmpltab.Itemlst[i].Supplygroupid) {
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
if matched {
|
|
tpldict[bl_paktpl.Paktmpltab.Packtemplateid] = bl_paktpl
|
|
}
|
|
}
|
|
|
|
// 遍历获取的模板ID，获取具有相同同步号的模板
|
|
rettpldict = make(map[string]string)
|
|
for _, bl_paktpl = range tpldict {
|
|
rettpldict[bl_paktpl.Paktmpltab.Packtemplateid] = bl_paktpl.Paktmpltab.Packtemplateid
|
|
for _, bl_paktpl2 = range pproj.Packtmpldict {
|
|
if bl_paktpl.Paktmpltab.Syncnr == bl_paktpl2.Paktmpltab.Syncnr {
|
|
rettpldict[bl_paktpl2.Paktmpltab.Packtemplateid] = bl_paktpl2.Paktmpltab.Packtemplateid
|
|
}
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 获取指定项目，OEMSEQ和supplygroup的开口包装
|
|
func (pproj *ProdProject) GetOpenPackOrderByOemseqSupplyGroup(wotab db.Pln_workorder) (exist bool, bl_pakord BL_ProdPackOrder, err error) {
|
|
var(
|
|
pakord db.Prod_packorder
|
|
pakordlst []db.Prod_packorder
|
|
)
|
|
|
|
if pakordlst, err = pakord.GetByOemSeqSupplyGroup(pproj.Projectid, common.ValueToInt(wotab.Oemseq, 0), wotab.Supplygroupid); err != nil {
|
|
err = errors.New(fmt.Sprintf("基于项目 %s Oemseq %d 供应组 %s 查询开口包装单失败!", pproj.Projectid, wotab.Oemseq, wotab.Supplygroupid))
|
|
return
|
|
}
|
|
|
|
exist = false
|
|
if len(pakordlst) > 0 {
|
|
bl_pakord = BL_ProdPackOrder{PackorderId: pakordlst[0].Packorderid, Pkotab: pakordlst[0]}
|
|
exist = true
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 获取指定项目，schedseq和supplygroup的开口包装
|
|
func (pproj *ProdProject) GetOpenPackOrderBySupplyGroup(sgid string) (exist bool, bl_pakord BL_ProdPackOrder, err error) {
|
|
var(
|
|
pakord db.Prod_packorder
|
|
pakordlst []db.Prod_packorder
|
|
)
|
|
|
|
if pakordlst, err = pakord.GetOpenOnesBySupplyGroup(pproj.Projectid, sgid); err != nil {
|
|
err = errors.New(fmt.Sprintf("基于项目 %s 供应组 %s 查询开口包装单失败!", pproj.Projectid, sgid))
|
|
return
|
|
}
|
|
|
|
exist = false
|
|
if len(pakordlst) > 0 {
|
|
bl_pakord = BL_ProdPackOrder{PackorderId: pakordlst[0].Packorderid, Pkotab: pakordlst[0]}
|
|
exist = true
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 获取指定项目，checksequence的开口包装
|
|
func (pproj *ProdProject) GetOpenPackOrderBySchedSeq(session *xorm.Session, cs int) (bl_pakordlst []BL_ProdPackOrder, err error) {
|
|
var(
|
|
i int
|
|
pakord db.Prod_packorder
|
|
pakordlst []db.Prod_packorder
|
|
bl_pakord BL_ProdPackOrder
|
|
)
|
|
|
|
bl_pakordlst = []BL_ProdPackOrder{}
|
|
if pakordlst, err = pakord.GetByCheckSeq(session, pproj.Projectid, cs); err != nil {
|
|
err = errors.New(fmt.Sprintf("基于项目 %s CheckSequence %d 查询开口包装单失败!", pproj.Projectid, cs))
|
|
return
|
|
}
|
|
|
|
for i = 0; i < len(pakordlst); i++ {
|
|
bl_pakord = BL_ProdPackOrder{PackorderId: pakordlst[i].Packorderid, Pkotab: pakordlst[i]}
|
|
bl_pakordlst = append(bl_pakordlst, bl_pakord)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (pproj *ProdProject) CreatePackOrderByOemseq(session *xorm.Session, wotab db.Pln_workorder, sortway string) (bl_polst []BL_ProdPackOrder, err error) {
|
|
var (
|
|
bl_pak BL_ProdPackTmp
|
|
bl_pakord BL_ProdPackOrder
|
|
paktmpitemtab db.Prod_packtemplate_itemlst
|
|
syncid, boxid, paktpl string
|
|
sgdict map[string]string
|
|
tpldict map[string]string
|
|
ok bool
|
|
)
|
|
|
|
// 初始化
|
|
bl_polst = []BL_ProdPackOrder{}
|
|
tpldict = make(map[string]string)
|
|
|
|
// 1. 基于供应组ID获取包含它的模板ID列表
|
|
tpldict = pproj.GetPackTemplateListBySupplyGroup(wotab.Supplygroupid)
|
|
if len(tpldict) <= 0 {
|
|
err = errors.New(fmt.Sprintf("供应组%s 没有任何适配的包装模板!", wotab.Supplygroupid))
|
|
return
|
|
}
|
|
|
|
// 2. 如果有多个匹配模板，则获取自动同步号
|
|
if len(tpldict) > 1 {
|
|
if strings.TrimSpace(pproj.Projecttab.Prodpacksync_snr) != "" {
|
|
if syncid, err = SN_GetNextSnrBySession(strings.TrimSpace(pproj.Projecttab.Prodpacksync_snr), session); err != nil {
|
|
return
|
|
}
|
|
} else {
|
|
if syncid, err = SN_GetNextSnrBySession("PRODPACKSYNC", session); err != nil {
|
|
return
|
|
}
|
|
}
|
|
} else {
|
|
syncid = ""
|
|
}
|
|
|
|
// 3. 获取包装模板
|
|
sgdict = make(map[string]string)
|
|
for _, paktpl = range tpldict {
|
|
if bl_pak, ok = pproj.Packtmpldict[paktpl]; !ok {
|
|
err = errors.New(fmt.Sprintf("包装模板 %s 不存在!", paktpl))
|
|
return
|
|
}
|
|
for _, paktmpitemtab = range bl_pak.Paktmpltab.Itemlst {
|
|
sgdict[paktmpitemtab.Supplygroupid] = paktmpitemtab.Supplygroupid
|
|
}
|
|
}
|
|
|
|
// 4. 获取包装箱流水号( 默认取多个模板最后一个模板为参照）
|
|
if bl_pak.Paktmpltab.Boxsn != "" {
|
|
if boxid, err = SN_GetNextSnrBySession(bl_pak.Paktmpltab.Boxsn, session); err != nil {
|
|
return
|
|
}
|
|
} else {
|
|
boxid = ""
|
|
}
|
|
|
|
// 5. 根据获取的模板列表依次创建包装单，并设置同步号
|
|
for _, paktpl = range tpldict {
|
|
if bl_pakord, err = pproj.CreatePackOrder(paktpl, syncid, boxid, sortway, wotab, session); err != nil {
|
|
return
|
|
}
|
|
bl_polst = append(bl_polst, bl_pakord)
|
|
fmt.Println("--------------------新建包装：",bl_pakord.PackorderId,"---------------")
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (pproj *ProdProject) CreatePackOrder(paktplid, syncid, boxid, sortway string, wotab db.Pln_workorder, session *xorm.Session) (bl_pako BL_ProdPackOrder, err error) {
|
|
var (
|
|
pkoitemtab db.Prod_packorder_itemlst
|
|
bl_pak BL_ProdPackTmp
|
|
i int
|
|
ok bool
|
|
pkoid string
|
|
)
|
|
|
|
// 获取包装模板
|
|
if bl_pak, ok = pproj.Packtmpldict[paktplid]; !ok {
|
|
err = errors.New(fmt.Sprintf("包装模板 %s 不存在!", paktplid))
|
|
return
|
|
}
|
|
// 获取项目的包装单号
|
|
if strings.TrimSpace(bl_pak.Paktmpltab.Packordersn) != "" {
|
|
if pkoid, err = SN_GetNextSnrBySession(strings.TrimSpace(bl_pak.Paktmpltab.Packordersn), session); err != nil {
|
|
return
|
|
}
|
|
} else {
|
|
if pkoid, err = SN_GetNextSnrBySession(strings.TrimSpace(pproj.Projecttab.Prodpack_snr), session); err != nil {
|
|
return
|
|
}
|
|
}
|
|
|
|
// 创建包装单头
|
|
bl_pako = BL_ProdPackOrder{}
|
|
bl_pako.Pkotab.Finr = db.G_FINR
|
|
bl_pako.Pkotab.Packorderid = pkoid
|
|
bl_pako.Pkotab.Packtemplateid = bl_pak.PackTmplId
|
|
bl_pako.Pkotab.Projnr = bl_pak.Paktmpltab.Projnr
|
|
bl_pako.Pkotab.Packtypeid = bl_pak.Paktmpltab.Packtypeid
|
|
bl_pako.Pkotab.Boxsn = boxid
|
|
bl_pako.Pkotab.Syncsn = syncid
|
|
bl_pako.Pkotab.Orderinfo = bl_pak.Paktmpltab.Syncflag
|
|
bl_pako.Pkotab.Planqty = bl_pak.Paktmpltab.Planqty
|
|
bl_pako.Pkotab.Actqty = 0
|
|
bl_pako.Pkotab.Printerid = bl_pak.Paktmpltab.Printerid
|
|
bl_pako.Pkotab.Templatefile = bl_pak.Paktmpltab.Templatefile
|
|
bl_pako.Pkotab.Status = common.PKO_STATUS_PLANNED
|
|
bl_pako.Pkotab.Loadstatus = common.PKO_STATUS_UNLOADED
|
|
bl_pako.Pkotab.Credatuz = common.Date(time.Now().Unix(), "YYYYMMDDHHmmss")
|
|
bl_pako.Pkotab.Lastuser = "service"
|
|
bl_pako.Pkotab.Itemlst = []db.Prod_packorder_itemlst{}
|
|
|
|
for i = 0; i < len(bl_pak.Paktmpltab.Itemlst); i++ {
|
|
pkoitemtab = db.Prod_packorder_itemlst{}
|
|
pkoitemtab.Finr = db.G_FINR
|
|
pkoitemtab.Packorderid = pkoid
|
|
pkoitemtab.Supplygroupid = bl_pak.Paktmpltab.Itemlst[i].Supplygroupid
|
|
pkoitemtab.Pos = bl_pak.Paktmpltab.Itemlst[i].Pos
|
|
pkoitemtab.Poscode = bl_pak.Paktmpltab.Itemlst[i].Poscode
|
|
pkoitemtab.Seq = bl_pak.Paktmpltab.Itemlst[i].Seq
|
|
if sortway == common.MESPACK_SORT_OEMSEQ {
|
|
pkoitemtab.Oemseq = common.ValueToInt(wotab.Oemseq, 0) + bl_pak.Paktmpltab.Itemlst[i].Seq - 1
|
|
}
|
|
pkoitemtab.Planqty = bl_pak.Paktmpltab.Itemlst[i].Planqty
|
|
pkoitemtab.Actqty = 0
|
|
pkoitemtab.Status = common.PKO_STATUS_PLANNED
|
|
pkoitemtab.Credatuz = common.Date(time.Now().Unix(), "YYYYMMDDHHmmss")
|
|
pkoitemtab.Lastuser = "service"
|
|
bl_pako.Pkotab.Itemlst = append(bl_pako.Pkotab.Itemlst, pkoitemtab)
|
|
}
|
|
if err = bl_pako.Pkotab.Insert(session); err != nil {
|
|
return
|
|
}
|
|
|
|
bl_pako.PlanQty = bl_pak.Paktmpltab.Planqty
|
|
bl_pako.PackorderId = pkoid
|
|
|
|
return
|
|
}
|
|
|
|
// 将生产订单加入包装单
|
|
func (pproj *ProdProject) AddWOToPackOrder(wotab db.Pln_workorder, bl_pakord *BL_ProdPackOrder, sortway string, session *xorm.Session) (success bool, err error) {
|
|
var (
|
|
pakordtab db.Prod_packorder
|
|
pakstatab db.Prod_wo_packstatus
|
|
i,pos,seq int
|
|
)
|
|
|
|
// 获取包装单完整数据
|
|
pakordtab = db.Prod_packorder{Finr: db.G_FINR, Packorderid: bl_pakord.PackorderId}
|
|
if bl_pakord.Pkotab, err = pakordtab.SelectOneBySession(session); err != nil {
|
|
return
|
|
}
|
|
|
|
// 检查包装单状态是否满足
|
|
success = false
|
|
if bl_pakord.Pkotab.Status >= common.PKO_STATUS_RELEASED {
|
|
return
|
|
}
|
|
|
|
// 遍历包装单项，匹配WO并更新
|
|
pos = -1
|
|
for i = 0; i < len(bl_pakord.Pkotab.Itemlst); i++ {
|
|
switch sortway {
|
|
case common.MESPACK_SORT_OEMSEQ:
|
|
if (bl_pakord.Pkotab.Itemlst[i].Supplygroupid == wotab.Supplygroupid) && bl_pakord.Pkotab.Itemlst[i].Oemseq == common.ValueToInt(wotab.Oemseq,0) {
|
|
success = true
|
|
pos = i
|
|
}
|
|
case common.MESPACK_SORT_RELSEQ:
|
|
if bl_pakord.Pkotab.Itemlst[i].Status < common.PKO_STATUS_RELEASED && bl_pakord.Pkotab.Itemlst[i].Supplygroupid == wotab.Supplygroupid {
|
|
success = true
|
|
pos = i
|
|
}
|
|
}
|
|
// 找到WO对应的包装项更新对应的状态和OEMSEQ信息
|
|
if success {
|
|
// 更新包装子项的计划包装信息
|
|
bl_pakord.Pkotab.Itemlst[i].Status = common.PKO_STATUS_RELEASED
|
|
bl_pakord.Pkotab.Itemlst[i].Workordernr = wotab.Workordernr
|
|
bl_pakord.Pkotab.Itemlst[i].Oemseq = common.ValueToInt(wotab.Oemseq,0)
|
|
bl_pakord.Pkotab.Itemlst[i].Lastmodif = common.Date(time.Now().Unix(), "YYYYMMDDHHmmss")
|
|
if !bl_pakord.Pkotab.Itemlst[i].UpdateBySession(session) {
|
|
err = errors.New("Failed to update jit_packorder_itemlst!")
|
|
return
|
|
}
|
|
|
|
// 新建包装单和生产订单的关系
|
|
pakstatab = db.Prod_wo_packstatus{}
|
|
pakstatab.Finr = db.G_FINR
|
|
pakstatab.Workordernr = wotab.Workordernr
|
|
pakstatab.Packorderid = bl_pakord.Pkotab.Packorderid
|
|
pakstatab.Projnr = bl_pakord.Pkotab.Projnr
|
|
pakstatab.Packstatus = 1
|
|
pakstatab.Lastuser = "pack_service"
|
|
pakstatab.Credatuz = common.Date(time.Now().Unix(), "YYYYMMDDHHmmss")
|
|
if !pakstatab.UpdateBySession(session) {
|
|
err = errors.New(fmt.Sprintf("将生产订单%s更新到包装单%s的状态表失败!", wotab.Workordernr,bl_pakord.Pkotab.Packorderid))
|
|
return
|
|
}
|
|
|
|
seq = bl_pakord.Pkotab.Itemlst[i].Seq
|
|
break
|
|
}
|
|
}
|
|
|
|
// 遍历包装单，根据pos插入的WO更新其它包装项
|
|
if success && sortway == common.MESPACK_SORT_OEMSEQ {
|
|
for i = 0; i < len(bl_pakord.Pkotab.Itemlst); i++ {
|
|
if i == pos || bl_pakord.Pkotab.Itemlst[i].Status >= common.PKO_STATUS_RELEASED {
|
|
continue
|
|
}
|
|
// 如果模板中的SEQ一致，尝试更新OEMSEQ
|
|
if bl_pakord.Pkotab.Itemlst[i].Oemseq <= 0{
|
|
bl_pakord.Pkotab.Itemlst[i].Oemseq = common.ValueToInt(wotab.Oemseq,0) + bl_pakord.Pkotab.Itemlst[i].Seq - seq
|
|
bl_pakord.Pkotab.Itemlst[i].Lastmodif = common.Date(time.Now().Unix(), "YYYYMMDDHHmmss")
|
|
if !bl_pakord.Pkotab.Itemlst[i].UpdateBySession(session) {
|
|
err = errors.New("Failed to update jit_packorder_itemlst!")
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|