root
/
ldj
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
ldj/WcfService1/BLL/lWmsOutPickPort.cs

1640 lines
57 KiB
C#
Raw Normal View History

初次提交
2023-05-23 16:13:17 +08:00

/// <summary>
///LOGIC CLASS FOR TABLE t_wmsOutPickPort
///By wm with codesmith.
///on 06/17/2020
/// </summary>
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DeiNiu.wms.Data.Model;
using System.Data;
using System.Transactions;
using DeiNiu.Utils;
namespace DeiNiu.wms.Logical
{
[Serializable]
public class lWmsOutPickPort :lbase
{
WmsOutPickPort _obj;
public lWmsOutPickPort()
{
initialize();
}
before release
2023-11-21 19:18:23 +08:00
WmsInRequestDetail _inRequestDetail;
public WmsInRequestDetail getWmsInRequestDetail
{
get
{
if (_inRequestDetail == null)
{
_inRequestDetail = new WmsInRequestDetail();
}
_inRequestDetail.operater = operId;
return _inRequestDetail;
}
}
WmsInUpPort _inUpPort;
public WmsInUpPort getWmsInUpPort
{
get
{
if (_inUpPort == null)
{
_inUpPort = new WmsInUpPort();
}
_inUpPort.operater = operId;
return _inUpPort;
}
}
初次提交
2023-05-23 16:13:17 +08:00
public WmsOutPickPort getWmsOutPickPort
{
get
{
if (_obj == null)
{
_obj = new WmsOutPickPort();
}
_obj.operater = operId;
return _obj;
}
}
public lWmsOutPickPort(int operId)
: base(operId)
{
initialize();
}
WmsWave _wmsWave ;
WmsWave wmsWave
{
get
{
if (_wmsWave == null)
{
_wmsWave = new WmsWave();
}
_wmsWave.operater = operId;
return _wmsWave;
}
}
/// <summary>
/// get all data
/// </summary>
public DataSet getAllData()
{
return _obj.Query();
}
/// <summary>
/// get all data
/// </summary>
public DataSet getAllActiveData()
{
return _obj.QueryActived();
}
/// <summary>
/// get a record by id
/// </summary>
public void initialize(int id)
{
_obj = id != 0 ? new WmsOutPickPort(id) : new WmsOutPickPort();
}
/// <summary>
/// get a record by id 0
/// </summary>
public void initialize()
{
initialize(0);
}
/// <summary>
/// get a record by id
/// </summary>
public void initialize(DataRow dr)
{
_obj = new WmsOutPickPort(dr);
}
protected override DeiNiu.Data.BaseObject.BaseModel getModel()
{
return _obj;
}
//begin cust db operation, query, excute sql etc.
internal int add(WmsOutPickPort obj)
{
return obj.Add();
}
process succeed.
2023-09-04 22:41:19 +08:00
初次提交
2023-05-23 16:13:17 +08:00
internal DataSet getWaveDetails(string waveNo, int rowStart, int rowEnd)
{
return _obj.getWaveDetails(waveNo, rowStart, rowEnd);
}
internal DataTable getWaveDetails(string waveNo)
{
return _obj.getWaveDetails(waveNo );
}
internal DataSet getWavePages(int state, int rowStart, int rowEnd)
{
return wmsWave.queryPages(state, rowStart, rowEnd);
}
internal DataTable getPickInfo(string waveNo, int volType)
{
return _obj.getPickInfo(waveNo, volType);
}
internal DataTable getPickInfo(string waveNo)
{
return _obj.getPickInfo(waveNo );
}
internal DataTable getPickSummary(string waveNo, int volType)
{
return _obj.getPickSummary(waveNo, volType);
}
// to move to lStockOutPort
/// <summary>
/// 出库分拣任务
/// 按相同的集货区域的拣货单合并拣货
/// 同一个波次按拣货区域划分为不同的任务
/// 每个任务有一个或多个拣货明细
/// 每个任务考虑作为播种亮灯的播种单号
/// </summary>
/// <returns></returns>
public bool createPickWaves()
process succeed.
2023-09-04 22:41:19 +08:00
{
DataTable dt = getWmsOutPickPort.getNewPickTasks(new WaveRule().getCurrentActiveRule(enumWaveRuleType.普通波次));
logOut.Debug("start to process new waves...count:" + dt.Rows.Count);
初次提交
2023-05-23 16:13:17 +08:00
if (dt.Rows.Count == 0)
{
process succeed.
2023-09-04 22:41:19 +08:00
初次提交
2023-05-23 16:13:17 +08:00
return false;
}
int lastTranArea = -100, lastPartion = -100, lastVolType = -100, lastOrderType = -100; ;
string lastPickRequest = "", waveNo = "", jobNo = "",lastWaveNo="";
bool isNewWave = false, isNewJob = false;
Dictionary<int, string> waveJobs = new Dictionary<int, string>();
int waveSize = 0;
int maxSize = WmsConstants.WAVE_ORDERS_CNT;
int jobMax = WmsConstants.WAVE_TASK_MAX_CNT;
process succeed.
2023-09-04 22:41:19 +08:00
初次提交
2023-05-23 16:13:17 +08:00
int jobcnt = 0;
before release
2023-11-21 19:18:23 +08:00
int taskcnt = 0;
初次提交
2023-05-23 16:13:17 +08:00
bool isCreateFlowTask = WmsConstants.OUT_LIGHT_ENABLE ? WmsConstants.DPS_TASK_GENERATION :true ;
process succeed.
2023-09-04 22:41:19 +08:00
WmsOutPickPort _obj;
初次提交
2023-05-23 16:13:17 +08:00
WmsFlow wmsflow;
process succeed.
2023-09-04 22:41:19 +08:00
using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required, new TransactionOptions()
初次提交
2023-05-23 16:13:17 +08:00
{
process succeed.
2023-09-04 22:41:19 +08:00
//IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted,
IsolationLevel = System.Transactions.IsolationLevel.Serializable,
Timeout = new TimeSpan(0, 10, 0)
}
))
{
// logSpec.Debug("start work...to create wave and jobs ");
初次提交
2023-05-23 16:13:17 +08:00
foreach (DataRow dr in dt.Rows)
{
_obj = new WmsOutPickPort(dr);
if (lastTranArea == -100)
{
lastTranArea = _obj.tranArea;
}
if (lastPartion == -100)
{
lastPartion = _obj.partion;
}
if (lastVolType == -100)
{
lastVolType = _obj.volType;
}
/*
if (lastOrderType == -100)
{
lastOrderType = _obj.or;
}
*/
if (lastPickRequest != _obj.pickOrderNo)
{
waveSize++;
//TODO:更新拣货状态 1. 整库拣货状态 2. 零库拣货状态
if (String.IsNullOrEmpty(lastPickRequest))
{
lastPickRequest = _obj.pickOrderNo;
}
WmsOutPickRequest pr = new WmsOutPickRequest(lastPickRequest);
process succeed.
2023-09-04 22:41:19 +08:00
if(pr.state != (int)enumOutStockRequestStatus.等待补货) {
初次提交
2023-05-23 16:13:17 +08:00
pr.state = (int)enumOutStockRequestStatus.正在分拣;
pr.Update();
process succeed.
2023-09-04 22:41:19 +08:00
}
before release
2023-11-21 19:18:23 +08:00
jobcnt = jobMax; //每个job只属于一个分拣单
初次提交
2023-05-23 16:13:17 +08:00
}
isNewWave = String.IsNullOrEmpty(waveNo)
|| lastTranArea != _obj.tranArea //集货目的地不同，开新波次
|| waveSize == maxSize; //达到波次最大订单数，开新波次
if (isNewWave)
{
/*if (!string.IsNullOrEmpty(waveNo) && waveJobs.ContainsKey(lastPartion))
{
WmsFlow wmsflow = new WmsFlow(jobNo, waveNo);
if(wmsflow.ID>0){
wmsflow.taskCnt = jobcnt;
wmsflow.Update();
}
}*/
lastWaveNo = waveNo;
waveNo = Util.getOrderNo(enumCreateOrderType.waveOrder, _obj.getNextSeq(enumCreateOrderType.waveOrder));
waveJobs = new Dictionary<int, string>();
waveSize = 0;
WmsWave wave = new WmsWave();
wave.waveNo = waveNo;
wave.type = _obj.recType;
wave.operater = operId;
wave.Add();
}
isNewJob = isNewWave || lastPartion != _obj.partion
|| jobcnt >= jobMax
|| !waveJobs.ContainsKey(_obj.partion);
if (jobcnt >= maxSize)
{
}
if (isNewJob)
{
isCreateFlowTask = WmsConstants.OUT_LIGHT_ENABLE ? WmsConstants.DPS_TASK_GENERATION : true ;
isCreateFlowTask = isCreateFlowTask || lastVolType > 0;
// LogHelper.WriteLog(typeof(lWmsOutPickPort), string.Format("1 isCreateFlowTask: {0},lastVolType {1}", isCreateFlowTask, lastVolType));
if (isCreateFlowTask && !string.IsNullOrEmpty(jobNo) )
{
wmsflow = new WmsFlow(jobNo);
if (wmsflow.ID > 0)
{
before release
2023-11-21 19:18:23 +08:00
wmsflow.taskCnt = taskcnt;// waveJobs[lastPartion].Length;
初次提交
2023-05-23 16:13:17 +08:00
wmsflow.Update();
}
}
before release
2023-11-21 19:18:23 +08:00
jobcnt = 0; taskcnt = 0;
初次提交
2023-05-23 16:13:17 +08:00
jobNo = Util.getOrderNo(enumCreateOrderType.pickJobNo, _obj.getNextSeq(enumCreateOrderType.pickJobNo));
waveJobs[_obj.partion] = jobNo;
isCreateFlowTask = WmsConstants.OUT_LIGHT_ENABLE ? WmsConstants.DPS_TASK_GENERATION :true ;
isCreateFlowTask = isCreateFlowTask || _obj.volType > 0;
// LogHelper.WriteLog(typeof(lWmsOutPickPort), string.Format("2 isCreateFlowTask: {0},_obj.volType {1}", isCreateFlowTask, _obj.volType));
if (isCreateFlowTask)
{
wmsflow = new WmsFlow();
wmsflow.operater = operId;
before release
2023-11-21 19:18:23 +08:00
wmsflow.orderNo = _obj.pickOrderNo;// waveNo;
初次提交
2023-05-23 16:13:17 +08:00
wmsflow.type = (int)Util.getTaskType(_obj.recType);
before release
2023-11-21 19:18:23 +08:00
wmsflow.typeName = Util.getTaskType(_obj.recType).ToString();
初次提交
2023-05-23 16:13:17 +08:00
wmsflow.task = jobNo;
wmsflow.fromPartion = _obj.partion;
wmsflow.toPartion = _obj.tranArea;
wmsflow.taskPartion = _obj.partion;
before release
2023-11-21 19:18:23 +08:00
// wmsflow.fromLocationId=_obj.locationId;
初次提交
2023-05-23 16:13:17 +08:00
wmsflow.Add();
}
}
else
{
jobNo = waveJobs[_obj.partion];
}
jobcnt++;
before release
2023-11-21 19:18:23 +08:00
taskcnt++;
初次提交
2023-05-23 16:13:17 +08:00
_obj.waveOrder = waveNo;
_obj.jobNo = jobNo;
_obj.operater = operId;
_obj.Update();
lastTranArea = _obj.tranArea;
lastPickRequest = _obj.pickOrderNo;
lastPartion = _obj.partion;
lastVolType = _obj.volType;
}
if (!string.IsNullOrEmpty(waveNo) )
{
wmsflow = new WmsFlow(jobNo );
if (wmsflow.ID > 0)
{
before release
2023-11-21 19:18:23 +08:00
wmsflow.taskCnt = taskcnt;
初次提交
2023-05-23 16:13:17 +08:00
wmsflow.Update();
}
}
scope.Complete();
}
process succeed.
2023-09-04 22:41:19 +08:00
logOut.Debug("end process new waves.. in last wave, created job count " +jobcnt);
初次提交
2023-05-23 16:13:17 +08:00
process succeed.
2023-09-04 22:41:19 +08:00
初次提交
2023-05-23 16:13:17 +08:00
return true;
}
WmsOutDesk _desk;
WmsOutDesk desk
{
get
{
if (_desk == null)
{
_desk = new WmsOutDesk();
_desk.operater = operId;
}
return _desk;
}
}
WmsOutDesk _seedsDesk;
WmsOutDesk seedsDesk
{
get
{
if (_seedsDesk == null)
{
_seedsDesk = new WmsOutDesk();
}
return _seedsDesk;
}
}
static List<int> lblist = new List<int>();
static Dictionary<int, int> comLables = new Dictionary<int, int>();
void initialDebugSetting()
{
DataTable dt = new Node().QueryByFlag(10001);
foreach (DataRow dr in dt.Rows)
{
Node node = new Node(dr);
if (!node.isOn)
{
continue;
}
try
{
string labels = node.description;
string[] lbs = labels.Split(',');
foreach (string s in lbs)
{
process succeed.
2023-09-04 22:41:19 +08:00
comLables[Convert.ToInt32(s.Trim())] = Convert.ToInt32(node.name.Trim());
lblist.Add(Convert.ToInt32(s.Trim()));
初次提交
2023-05-23 16:13:17 +08:00
}
}
catch
{
continue;
}
}
}
private string waveOrder = "";
public void newBulkDPSPickWave()
{
if (!WmsConstants.OUT_LIGHT_ENABLE)
{
return;
}
//播种筛选，
//适合播种的客户订单合并成一个、多个大订单，统一捡出后进行播种操作
//1. 单个订单的品种少 、数量少
//2. 订单数量多
//只处理订单零货部分
//加入播种选项，所有订单零货部分使用摘取+播种方式
//1.播种点数量可配置， 分别用不同颜色区分
//2.每个播种点可分播客户的数量配置， 即每个播种点处理零货订单数量（ 例如配置成6个，一次捡6个客户的订单零货部分，送由一个播种点播种）
//3.波次和播种点的对应关系，一个波次只摘取一个播种点的零货，还是多个播种点的数据？
//4.
//一个波次可以摘取订单数 = 空闲分播台数量*每个分播台可分播客户数， 分播台的订单用颜色区分
//
LogHelper.debug(typeof(lWmsOutPickPort), "开始新波次。。。。。。。。。。。。。。。。。。");
DataTable dtPorts = getWmsOutPickPort.getNewPickTasks(new WaveRule().getCurrentActiveRule(enumWaveRuleType.DPS灯光波次));
LogHelper.debug(typeof(lWmsOutPickPort), string.Format("待处理任务数量：{0}", dtPorts.Rows.Count));
if (dtPorts.Rows.Count == 0)
{
LogHelper.debug(typeof(lWmsOutPickPort), string.Format("无订单需要处理，波次结束"));
new lWmsOutPickRequest(this.operId).checkRepAndNoStockOrders();
return;
}
desk.restDeskStatus(enumDeskState.空闲);
desk.restDeskStatus(enumDeskState.空闲, enumDeskType.播种); //播种台状态复位到空闲，是不是可以由播种员实际播种任务进度控制？
_seedsDesk = desk.getRandomDesk(enumDeskState.空闲, enumDeskType.播种); ;
_desk = desk.getRandomDesk(enumDeskState.空闲, enumDeskType.复核);
int labelMaxInWave = WmsConstants.MAX_LABEL_DATA_IN_A_WAVE; //一个标签一个波次只能存储40条数据
#if DEBUG
// if (lblist.Count == 0)
{
lblist.Clear();
initialDebugSetting();
}
lblist.Sort();
#endif
// List<WmsStockRecord> strecs = null;
waveOrder = Util.getOrderNo(enumCreateOrderType.dpsOrder, _obj.getNextSeq(enumCreateOrderType.dpsOrder));
//waveOrder = "WV" + System.DateTime.Now.ToString("yyyyMMddHHmmss");
Dictionary<int, int> labelCnt = new Dictionary<int, int>();
Dictionary<int, int> comCnt = new Dictionary<int, int>();
Dictionary<int, int> tmplabelCnt = new Dictionary<int, int>();
Dictionary<int, int> tmpcomCnt = new Dictionary<int, int>();
bool isReachLimit = false;
int waveSize = 0;
//List<WmsOutPickPort> lstPort;
List<WmsOutPickLable_tmp> lstLabel;
List<WmsStockRecord> lstBulk;
LogHelper.debug(typeof(lWmsOutPickRequest), string.Format("waveNo {0}", waveOrder));
//播种常量，达不到最小订单摘取需求的合并成大订单先统一摘取再分播
bool isSeedsEnabled = WmsConstants.OUT_BULK_SEEDS_PICK_ON;
int pickGoodsTypeMin = WmsConstants.OUT_MAX_SEEDS_GOODSTYPE_CNT; //单独摘取订单 最少货物类型
int pickGoodsCountMin = WmsConstants.OUT_MAX_SEEDS_BULK_CNT_SUM; // 单独摘取订单 最少货物数量
int seedsCount = seedsDesk.seedsCount; //播种台一次播种订单数量
decimal sumBulkCnt = 0;
bool isSeedPickInSameWave = true;
// bool canSeedPickLessThanseedsCount = false; //单个播种拣选单数量不可少于播种能力
List<WmsOutPickRequest> seedsRequests = new List<WmsOutPickRequest>();
Dictionary<string, WmsStockRecord> seedsBulks = new Dictionary<string, WmsStockRecord>();
if (desk.ID == 0) // no free pick desk
{
if (isSeedsEnabled)
{
_seedsDesk = desk.getRandomDesk(enumDeskState.空闲, enumDeskType.播种);
if (seedsDesk.ID == 0)
{
return;
}
}
else
{
return;
}
}
int bulkCnt = 0;
int requestCnt = 0;
//开始处理有零货的订单
DateTime d0 = DateTime.Now;
double totoalTime = 0d;
string lastAddress = "";
// foreach (WmsOutPickRequest request in requests)
WmsOutPickPort wopp;
string lastPickOrder = "";
List<WmsOutPickPort> lstPort = new List<WmsOutPickPort>();
lstBulk = new List<WmsStockRecord>();
int elebleId = 0, port = 0;
WmsOutPickRequest request;
List<WmsOutPickRequest> taskRequests = new List<WmsOutPickRequest>();
Dictionary<String, List<WmsStockRecord>> tasks = new Dictionary<string, List<WmsStockRecord>>();
Dictionary<String, List<WmsOutPickPort>> portTasks = new Dictionary<string, List<WmsOutPickPort>>();
foreach (DataRow dr in dtPorts.Rows)
{
DateTime d00 = DateTime.Now;
wopp = new WmsOutPickPort(dr);
if (lastPickOrder != wopp.pickOrderNo)
{
lastPickOrder = wopp.pickOrderNo;
_desk = desk.getRandomDesk(enumDeskState.空闲, enumDeskType.复核);
if (_desk.ID > 0)
{
request = new WmsOutPickRequest(lastPickOrder);
request.desk = _desk.color;
desk.state = (int)enumDeskState.任务中;
desk.Update();
taskRequests.Add(request);
}
else
{
break;
}
}
if (!tasks.Keys.Contains(lastPickOrder))
{
tasks[lastPickOrder] = new List<WmsStockRecord>();
}
if (!portTasks.Keys.Contains(lastPickOrder))
{
portTasks[lastPickOrder] = new List<WmsOutPickPort>();
}
tasks[lastPickOrder].Add(new WmsStockRecord(dr));
portTasks[lastPickOrder].Add(wopp);
}
#region savedata
foreach (WmsOutPickRequest pickRequest in taskRequests)
{
int lastId = 0;
LogHelper.debug(typeof(lWmsOutPickRequest), " 摘果式 保存整货和零货出库分拣数据");
lstLabel = new List<WmsOutPickLable_tmp>();
WmsOutPickLable_tmp wpl;
foreach (WmsStockRecord rec in tasks[pickRequest.pickOrderNo])
{
// if (rec.count == 0)
if (rec.count + rec.countOuting < 1) //不支持小数
{
continue;
}
if (lblist.Count > 0)
{
int id = new Random().Next(lblist.Count);
//#if DEBUG
rec.location.elabId = lblist[id]; //new Random().Next(minId, maxId + 1); //测试。。。随机分配标签id 为 1-3
while (lblist.Count > 1 && lastId == rec.location.elabId)
{
id = new Random().Next(lblist.Count);
rec.location.elabId = lblist[id];
}
lastId = rec.location.elabId;
//#endif
}
wpl = new WmsOutPickLable_tmp();
wpl.pickOrderNo = pickRequest.pickOrderNo;
wpl.recordId = rec.ID;
wpl.color = pickRequest.desk;
wpl.count = rec.count + rec.countOuting;
wpl.locationId = rec.locationId;
wpl.elabAddress = rec.location.elabAddress;
wpl.elabId = rec.location.elabId;
wpl.port = rec.location.port;
wpl.orderDetailId = rec.orderDetailId;
//#if DEBUG
try
{
if (comLables.Count > 0)
{
wpl.port = comLables[wpl.elabId]; //rec.location.elabId < 4 ?5 :3; //测试。。。 分配标签端口为3
}
}
catch { }
//#endif
wpl.dpsOrder = waveOrder;
wpl.operater = this.operId;
lstLabel.Add(wpl);
}
//保存整货和零货出库分拣数据
try
{
using (TransactionScope scope1 = new TransactionScope())
{
foreach (WmsOutPickLable_tmp wp in lstLabel) //建立电子拣选临时数据
{
wp.Add();
}
foreach (WmsOutPickPort pt in portTasks[pickRequest.pickOrderNo])
{
pt.dpsOrder = waveOrder;
pt.Update();
}
if (lstLabel.Count > 0)
{
pickRequest.waveOrder = waveOrder;
pickRequest.state = (int)enumOutStockRequestStatus.正在分拣;
pickRequest.waveStart = pickRequest.getDateTime();
pickRequest.operater = this.operId;
pickRequest.updateBulkPickStatus(pickRequest.pickOrderNo, enumOutStockPickStatus.正在分拣, operId);
// pickRequest.state =
pickRequest.Update();
}
waveSize++;
scope1.Complete();
}
}
catch (Exception e)
{
LogHelper.WriteLog(typeof(lWmsOutPickRequest), e);
desk.restDeskStatus(enumDeskState.空闲);
throw e;
}
}
#endregion
// totoalTime += ts00.TotalSeconds;
//建立零库电子拣选临时数据
new WmsOutPickRequest().saveTempData4Validation(waveOrder);
WmsConstants.WAVE_CURRENT_PICK_STATUS.Clear();
WmsConstants.WAVE_CURRENT_ORDER = waveOrder;
WmsConstants.WAVE_LAST_TIME = DateTime.Now;
//检查待补货出货单状态
new lWmsOutPickRequest(this.operId).checkRepAndNoStockOrders();
}
before release
2023-11-21 19:18:23 +08:00
internal int clearJobLightTask(string jobNo)
{
return new WmsOutPickLable_tmp().clearByDpsOrder(jobNo);
}
internal DataTable prePareLightByJob(string jobNo,bool isValid)
{
WmsOutPickLable_tmp wpl = new WmsOutPickLable_tmp();
log.Debug(" to get pick port task for light :" +jobNo +" isValid :" +isValid);
if (!isValid)
{
DataTable dt = getWmsOutPickPort.geTasksByJobNo(jobNo);
if (dt.Rows.Count > 0)
{
wpl = new WmsOutPickLable_tmp(dt.Rows[0]);
}
else
{
return dt;
}
using (TransactionScope scope = new TransactionScope())
{
int i = 0;
wpl.clearByDpsOrder(jobNo);
wpl.clearByPartion(wpl.partion);
foreach (DataRow dr in dt.Rows)
{
// WmsOutPickPort wpp = new WmsOutPickPort(dr);
// log.Debug(" get pick port task :" + wpp);
decimal pcs = Convert.ToDecimal(dr["pcs"].ToString());
wpl = new WmsOutPickLable_tmp(dr);
wpl.count = pcs > 0 ? pcs : 1;
wpl.color = 1;
wpl.dpsOrder = jobNo;
#if DEBUG
wpl.elabId = ++i;
log.Debug("use fake id....." + wpl.elabId);
#endif
wpl.Add();
log.Debug("2 get pick port task for light :" + wpl);
}
scope.Complete();
}
}
return wpl.getByDpsOrder(jobNo);
}
internal DataTable getPickSummary(int takeBy, int partion, int orderType)
{
return getWmsOutPickPort.getPickLightTasks( takeBy, partion, orderType);
}
初次提交
2023-05-23 16:13:17 +08:00
/*
* 分配拣货任务
*/
public void taskAssign(int taskBy,int partion,int lineId,int maxLocCnt=0,int maxBoxs=0,
before release
2023-11-21 19:18:23 +08:00
bool batchOnly=true,enumOrderType orderType = enumOrderType.销售出库)
初次提交
2023-05-23 16:13:17 +08:00
{
process succeed.
2023-09-04 22:41:19 +08:00
// logTest.Debug(string.Format("1 maxLocCnt {0},maxBoxs {1}",maxLocCnt,maxBoxs));
maxLocCnt = maxLocCnt<=0?WmsConstants.MAX_PICK_LOT_CNT:maxLocCnt;
maxBoxs = maxBoxs <= 0 ? WmsConstants.MAX_PICK_BOX_CNT : maxBoxs;
// logTest.Debug(string.Format("2 maxLocCnt {0},maxBoxs {1}", maxLocCnt, maxBoxs));
before release
2023-11-21 19:18:23 +08:00
// int lotcnt = 0,boxcnt=0;
if (!isJobMax(taskBy, partion, lineId, maxLocCnt, maxBoxs,
batchOnly, orderType))
初次提交
2023-05-23 16:13:17 +08:00
{
return;
}
before release
2023-11-21 19:18:23 +08:00
int lotcnt = 0, boxcnt = 0;
WmsOutPickPort wop;
初次提交
2023-05-23 16:13:17 +08:00
before release
2023-11-21 19:18:23 +08:00
DataTable dt = getWmsOutPickPort.getFreeTasks(partion, lineId, batchOnly,orderType,taskBy);
初次提交
2023-05-23 16:13:17 +08:00
process succeed.
2023-09-04 22:41:19 +08:00
// logTest.Debug(string.Format(" exists tasks to do , loc cnt :{0}, box cnt: {1}, free tasks cnt :{2}", lotcnt, boxcnt,dt.Rows.Count));
初次提交
2023-05-23 16:13:17 +08:00
before release
2023-11-21 19:18:23 +08:00
初次提交
2023-05-23 16:13:17 +08:00
using (TransactionScope scope = new TransactionScope())
{
foreach (DataRow dr in dt.Rows)
{
wop = new WmsOutPickPort(dr);
lotcnt++;
process succeed.
2023-09-04 22:41:19 +08:00
boxcnt += Convert.ToInt32(dr["boxcnt"].ToString());
初次提交
2023-05-23 16:13:17 +08:00
before release
2023-11-21 19:18:23 +08:00
if (lotcnt > maxLocCnt || boxcnt > maxBoxs)
初次提交
2023-05-23 16:13:17 +08:00
{
before release
2023-11-21 19:18:23 +08:00
// logTest.Debug(string.Format(" All tasks to do , loc cnt :{0}, box cnt: {1}",lotcnt,boxcnt));
初次提交
2023-05-23 16:13:17 +08:00
break;
}
wop.takeBy = taskBy;
// wop.operater = operId;
wop.Update();
before release
2023-11-21 19:18:23 +08:00
// log.Debug( " user " + taskBy + " task Assign :" + wop.ID);
/*
WmsFlow wf = new WmsFlow(wop.jobNo);
wf.owner = operId;
wf.state = (int)enumFlowTaskStatus.进行中;
wf.Update();
*/
初次提交
2023-05-23 16:13:17 +08:00
process succeed.
2023-09-04 22:41:19 +08:00
/**
* 改为下架时生成补零上架任务
*
初次提交
2023-05-23 16:13:17 +08:00
if (wop.recType != (int)enumStockRecordType.补零出库)
{
continue;
}
//to create inport data
int skuId = Convert.ToInt32(dr["skuId"].ToString());
string goodsId =dr["goodsId"].ToString();
string batch =dr["batch"].ToString();
string skucode = dr["skucode"].ToString();
string prdtime = dr["productDate"].ToString();
string vltime = dr["validDate"].ToString();
DataTable dtBulkLocs = lstk.getBulkLocations(skuId, "",goodsId , batch, wop.count);
foreach (DataRow dr1 in dtBulkLocs.Rows)
{
//todo: to add stock record
WmsInUpPort wip = new WmsInUpPort();
wip.locationId = dr1[0].ToString();
wip.count =Convert.ToDecimal( dr1[1].ToString());
wip.orderNo = wop.pickOrderNo;
wip.skuId = skuId;
wip.skuCode = skucode;
wip.batch = batch;
wip.goodsId = goodsId;
wip.detailId = wop.pickDetailId;
wip.recType = (int)enumStockRecordType.补零入库;
wip.recordId = wop.recordId;
wip.productDate = prdtime;
wip.validDate = vltime;
wip.flowNo = "0";
WmsLocation loc = new WmsLocation(wip.locationId);
Node nd = new Node( loc.part);
if (nd.ID > 0)
{
wip.partion = nd.flag;
}
wip.Add();
//create stock,lock the location
process succeed.
2023-09-04 22:41:19 +08:00
WmsStock newStk = new WmsStock(wip.locationId, skuId,wip.goodsId);
初次提交
2023-05-23 16:13:17 +08:00
if (newStk.ID == 0) //new one
{
newStk.countIn = wip.count;
newStk.skuCode = skucode;
newStk.goodsId = goodsId;
newStk.skuId = skuId;
newStk.locationId = wip.locationId ;
newStk.batch = batch;
newStk.productDate = wip.productDate;
newStk.validDate = wip.validDate;
newStk.maintainDate = newStk.getDateTime();
newStk.Add();
}
}
process succeed.
2023-09-04 22:41:19 +08:00
*/
before release
2023-11-21 19:18:23 +08:00
初次提交
2023-05-23 16:13:17 +08:00
}
before release
2023-11-21 19:18:23 +08:00
初次提交
2023-05-23 16:13:17 +08:00
scope.Complete();
}
process succeed.
2023-09-04 22:41:19 +08:00
//
// logTest.Debug(string.Format(" All tasks to do , loc cnt :{0}, box cnt: {1},max lot limit {2},max box limit {3},orderType:{4}", lotcnt, boxcnt,maxLocCnt,maxBoxs,orderType));
初次提交
2023-05-23 16:13:17 +08:00
}
before release
2023-11-21 19:18:23 +08:00
bool isJobMax(int taskBy, int partion, int lineId, int maxLocCnt = 0, int maxBoxs = 0, bool batchOnly = true, enumOrderType orderType = enumOrderType.销售出库)
{
maxLocCnt = maxLocCnt <= 0 ? WmsConstants.MAX_PICK_LOT_CNT : maxLocCnt;
maxBoxs = maxBoxs <= 0 ? WmsConstants.MAX_PICK_BOX_CNT : maxBoxs;
// logTest.Debug(string.Format("2 maxLocCnt {0},maxBoxs {1}", maxLocCnt, maxBoxs));
int lotcnt = 0, boxcnt = 0;
WmsOutPickPort wop;
DataTable dt = getWmsOutPickPort.getAssignedTasks(taskBy, -1, -1, batchOnly, orderType);
lotcnt = dt.Rows.Count;
if (lotcnt >= maxLocCnt)
{
logTest.Debug(" user " + taskBy + " 无法分配更多的任务了，未完成 task lotcnt :" + lotcnt);
return false;
}
foreach (DataRow dr in dt.Rows)
{
wop = new WmsOutPickPort(dr);
try
{
boxcnt += Convert.ToInt32(dr["boxcnt"].ToString());
}
catch { }
if (boxcnt >= maxBoxs)
{
logTest.Debug(" user " + taskBy + " 无法分配更多的任务了，未完成 box cnt :" + boxcnt);
return false;
}
// wop.operater = operId;
}
return true;
}
/// <summary>
/// 以Job 为单位分配工作
/// </summary>
/// <param name="taskBy"></param>
/// <param name="partion"></param>
/// <param name="lineId"></param>
/// <param name="maxLocCnt"></param>
/// <param name="maxBoxs"></param>
/// <param name="batchOnly"></param>
/// <param name="orderType"></param>
public void taskAssignByJob(int taskBy, int partion, int lineId, int maxLocCnt = 0, int maxBoxs = 0,
bool batchOnly = true, enumOrderType orderType = enumOrderType.销售出库)
{
// logTest.Debug(string.Format("1 maxLocCnt {0},maxBoxs {1}",maxLocCnt,maxBoxs));
maxLocCnt = maxLocCnt <= 0 ? WmsConstants.MAX_PICK_LOT_CNT : maxLocCnt;
maxBoxs = maxBoxs <= 0 ? WmsConstants.MAX_PICK_BOX_CNT : maxBoxs;
// logTest.Debug(string.Format("2 maxLocCnt {0},maxBoxs {1}", maxLocCnt, maxBoxs));
if(!isJobMax( taskBy, partion, lineId, maxLocCnt, maxBoxs ,
batchOnly , orderType))
{
return;
}
int lotcnt = 0, boxcnt = 0;
WmsOutPickPort wop;
DataTable dt = getWmsOutPickPort.getFreeTasksByJob(partion, lineId, batchOnly, orderType, taskBy);
// logTest.Debug(string.Format(" exists tasks to do , loc cnt :{0}, box cnt: {1}, free tasks cnt :{2}", lotcnt, boxcnt,dt.Rows.Count));
DataView dv = dt.DefaultView;
dv.Sort = "jobNo";
string lastJob = "";
using (TransactionScope scope = new TransactionScope())
{
foreach (DataRowView dr in dv)
{
/*
lotcnt++;
boxcnt += Convert.ToInt32(dr["boxcnt"].ToString());
if (lotcnt > maxLocCnt || boxcnt > maxBoxs)
{
// logTest.Debug(string.Format(" All tasks to do , loc cnt :{0}, box cnt: {1}",lotcnt,boxcnt));
break;
}
*/
wop = new WmsOutPickPort(dr.Row);
wop.takeBy = taskBy;
// wop.operater = operId;
wop.Update();
// log.Debug( " user " + taskBy + " task Assign :" + wop.ID);
if (string.IsNullOrEmpty(lastJob))
{
lastJob = wop.jobNo;
}
else
if (lastJob != wop.jobNo)
{
WmsFlow wf = new WmsFlow(wop.jobNo);
wf.owner = operId;
wf.state = (int)enumFlowTaskStatus.进行中;
wf.Update();
}
lastJob= wop.jobNo;
}
scope.Complete();
}
//
// logTest.Debug(string.Format(" All tasks to do , loc cnt :{0}, box cnt: {1},max lot limit {2},max box limit {3},orderType:{4}", lotcnt, boxcnt,maxLocCnt,maxBoxs,orderType));
}
初次提交
2023-05-23 16:13:17 +08:00
/// <summary>
/// 取总播种操作
/// </summary>
/// <param name="flowNo">取总板号</param>
/// <param name="outDetailId">销售明细id</param>
/// <param name="seedCnt">分播数量</param>
/// <param name="toFlowNo">周转箱号</param>
/// <returns></returns>
before release
2023-11-21 19:18:23 +08:00
internal enumRepResult seedsPickOut(string flowNo,int skuId,string productDate, string batch, int outDetailId, decimal seedCnt, string toFlowNo,int inDetailId)
初次提交
2023-05-23 16:13:17 +08:00
{
before release
2023-11-21 19:18:23 +08:00
// logTest.Debug(string.Format(" flowNo:{0} ，batch :{1} , outDetailId:{2} , seedsCnt:{3}", flowNo, batch ,outDetailId, seedCnt));
process succeed.
2023-09-04 22:41:19 +08:00
// WmsOutDetail wod = new WmsOutDetail(outDetailId);
// WmsOutRequest wor = new WmsOutRequest(wod.orderNo);
before release
2023-11-21 19:18:23 +08:00
bool isZhitongSeed = inDetailId > 0;
if (isZhitongSeed)
{
return zhitongSeedOut(inDetailId, outDetailId, seedCnt, flowNo, toFlowNo);
}
process succeed.
2023-09-04 22:41:19 +08:00
WmsOutPickDetail wod = new WmsOutPickDetail(outDetailId);
before release
2023-11-21 19:18:23 +08:00
// logTest.Debug(string.Format("seeds pickdetail {0}", wod.ToString()));
if (!isZhitongSeed && string.IsNullOrEmpty(wod.seedsPickNo) || wod.state == (int)enumOutStockDetailStatus.播种完成)
process succeed.
2023-09-04 22:41:19 +08:00
{
logTest.Debug(string.Format(" detialId {0}, seedsNo is null, {1}", outDetailId, enumRepResult.不适合播种));
return enumRepResult.不适合播种;
}
before release
2023-11-21 19:18:23 +08:00
if (wod.count != seedCnt)
process succeed.
2023-09-04 22:41:19 +08:00
{
before release
2023-11-21 19:18:23 +08:00
logTest.Debug(string.Format(" detialId {0}, order Cnt {1}, seeds cnt {2}", outDetailId, wod.count, seedCnt));
process succeed.
2023-09-04 22:41:19 +08:00
}
before release
2023-11-21 19:18:23 +08:00
WmsFlow wmsflow = new WmsFlow(wod.seedsPickNo+wod.goodsId+batch, flowNo);
// logTest.Debug(string.Format("orderNo {0}, flowNo {1}, wmsflow {2}", wod.seedsPickNo + wod.goodsId + batch, flowNo, wmsflow.ToString()));
enumRepResult rs= wmsflow.checkFlow(operId, wmsflow.type);
if (rs!=enumRepResult.成功)
{
logTest.Debug(string.Format(" {0} checkflow result {1}, WmsConstants.MAX_TASKS_OWN {2}", operId, rs, WmsConstants.MAX_TASKS_OWN));
return rs;// enumRepResult.任务已被他人抢占;
}
//to check the toFlowNo plate
// WmsPlate toPlate = new WmsPlate(toFlowNo);
process succeed.
2023-09-04 22:41:19 +08:00
before release
2023-11-21 19:18:23 +08:00
WmsPlateStock_tmp tmpStk = new WmsPlateStock_tmp();
string custId = tmpStk.getRelatedCustId(flowNo);
if (!string.IsNullOrEmpty(custId) && custId != wod.customerId)
{
return enumRepResult.容器已被其他客户占用;
}
process succeed.
2023-09-04 22:41:19 +08:00
seedCnt = seedCnt > wod.count - wod.seeded ? wod.count - wod.seeded : seedCnt;
before release
2023-11-21 19:18:23 +08:00
process succeed.
2023-09-04 22:41:19 +08:00
初次提交
2023-05-23 16:13:17 +08:00
// pickport with flowno can be multi records, update the finished seeds count in loop
before release
2023-11-21 19:18:23 +08:00
DataTable dt = getWmsOutPickPort.getFlowNoDetails(flowNo, wod.goodsId, batch);
process succeed.
2023-09-04 22:41:19 +08:00
List<WmsOutPickPort> lstExists = new List<WmsOutPickPort>();
before release
2023-11-21 19:18:23 +08:00
List<WmsPlateStock_tmp> lstUpdate = new List<WmsPlateStock_tmp>();
;
初次提交
2023-05-23 16:13:17 +08:00
decimal tmpCnt = seedCnt;
before release
2023-11-21 19:18:23 +08:00
DataView dv = dt.DefaultView;
dv.RowFilter = "state="+ (int)enumPickState.已分播;
int seedsDoneCnt = dv.Count;
dv.RowFilter = "";
// logTest.Debug(string.Format("1 seeds done cnt {0}, totalcnt of task{1}", seedsDoneCnt, dt.Rows.Count));
foreach (DataRow dr in dt.Rows)
初次提交
2023-05-23 16:13:17 +08:00
{
before release
2023-11-21 19:18:23 +08:00
WmsOutPickPort wop = new WmsOutPickPort(dr);
process succeed.
2023-09-04 22:41:19 +08:00
decimal tmpCnt2 = 0;
before release
2023-11-21 19:18:23 +08:00
if (wop.state == (int)enumPickState.已分播)
{
seedsDoneCnt++;
}
process succeed.
2023-09-04 22:41:19 +08:00
if (wop.state == 1) //已经拣货完毕
初次提交
2023-05-23 16:13:17 +08:00
{
if (wop.seedsOutCount + tmpCnt <= wop.pickCount)
{
process succeed.
2023-09-04 22:41:19 +08:00
tmpCnt2 = tmpCnt;
初次提交
2023-05-23 16:13:17 +08:00
wop.seedsOutCount += tmpCnt;
process succeed.
2023-09-04 22:41:19 +08:00
lstExists.Add(wop);
tmpCnt = 0;
before release
2023-11-21 19:18:23 +08:00
初次提交
2023-05-23 16:13:17 +08:00
}
else
{
tmpCnt -= wop.pickCount - wop.seedsOutCount;
wop.seedsOutCount = wop.pickCount;
before release
2023-11-21 19:18:23 +08:00
process succeed.
2023-09-04 22:41:19 +08:00
lstExists.Add(wop);
tmpCnt2 = wop.pickCount;
初次提交
2023-05-23 16:13:17 +08:00
}
process succeed.
2023-09-04 22:41:19 +08:00
/*
* 更新临时库数据
*
*/
before release
2023-11-21 19:18:23 +08:00
DataTable dt1 = tmpStk.getByOutPort(wop.ID);
foreach (DataRow dr1 in dt1.Rows)
{
if (tmpCnt2 <= 0)
process succeed.
2023-09-04 22:41:19 +08:00
{
break;
}
tmpStk = new WmsPlateStock_tmp(dr1);
before release
2023-11-21 19:18:23 +08:00
// log.Debug("1 tmpStk.count " + tmpStk.count + ", tmpCnt2: " + tmpCnt2);
process succeed.
2023-09-04 22:41:19 +08:00
if (tmpStk.count >= tmpCnt2)
{
tmpStk.count -= tmpCnt2;
tmpCnt2 = 0;
}
else
before release
2023-11-21 19:18:23 +08:00
{
process succeed.
2023-09-04 22:41:19 +08:00
tmpCnt2 -= tmpStk.count;
before release
2023-11-21 19:18:23 +08:00
tmpStk.count = 0;
process succeed.
2023-09-04 22:41:19 +08:00
}
before release
2023-11-21 19:18:23 +08:00
// log.Debug("2 tmpStk.count " + tmpStk.count + ", tmpCnt2: " + tmpCnt2);
// log.Debug(tmpStk);
lstUpdate.Add(tmpStk);
process succeed.
2023-09-04 22:41:19 +08:00
}
if (tmpCnt == 0)
{
break;
}
}
初次提交
2023-05-23 16:13:17 +08:00
}
before release
2023-11-21 19:18:23 +08:00
if (tmpCnt > 0)
初次提交
2023-05-23 16:13:17 +08:00
{
before release
2023-11-21 19:18:23 +08:00
//logTest.Debug(string.Format(" 播种请求数量{0}, 可用播种数量{1},flowNo:{2} ，batch :{3} , outDetailId:{4} ", seedCnt, seedCnt - tmpCnt, flowNo, batch, outDetailId));
// return enumRepResult.分播数量大于剩余数量;
process succeed.
2023-09-04 22:41:19 +08:00
}
seedCnt -= tmpCnt;
if (seedCnt <= 0)
{
before release
2023-11-21 19:18:23 +08:00
初次提交
2023-05-23 16:13:17 +08:00
return enumRepResult.分播数量大于剩余数量;
}
process succeed.
2023-09-04 22:41:19 +08:00
seedCnt = seedCnt > wod.count - wod.seeded ? wod.count - wod.seeded : seedCnt;
wod.seeded += seedCnt;
before release
2023-11-21 19:18:23 +08:00
if (wod.count <= wod.seeded)
{
wod.state = (int)enumOutStockDetailStatus.播种完成;
}
process succeed.
2023-09-04 22:41:19 +08:00
before release
2023-11-21 19:18:23 +08:00
// log.Debug(" 1 WmsPlateStock_tmp lstUpdate count " + lstUpdate.Count);
初次提交
2023-05-23 16:13:17 +08:00
using (TransactionScope scope = new TransactionScope())
{
before release
2023-11-21 19:18:23 +08:00
// logTest.Debug(string.Format("start update 分播 tasks ,operid {0}, wmsflow : {1}",operId, wmsflow.ToString() ));
初次提交
2023-05-23 16:13:17 +08:00
wod.Update();
process succeed.
2023-09-04 22:41:19 +08:00
if (wod.isAllPicked(wod.pickOrderNo))
{
new lWmsOutPickRequest(operId).updateOrderStatus(wod.pickOrderNo, enumOutStockPickStatus.分拣完成);
}
before release
2023-11-21 19:18:23 +08:00
初次提交
2023-05-23 16:13:17 +08:00
WmsStockRecord wsr = new WmsStockRecord();
process succeed.
2023-09-04 22:41:19 +08:00
wsr.orderNo = wod.pickOrderNo;
初次提交
2023-05-23 16:13:17 +08:00
wsr.orderDetailId = wod.ID;
before release
2023-11-21 19:18:23 +08:00
wsr.goodsId = wod.goodsId;
初次提交
2023-05-23 16:13:17 +08:00
wsr.count = seedCnt;
wsr.locationId = flowNo;
process succeed.
2023-09-04 22:41:19 +08:00
wsr.operater = operId;
before release
2023-11-21 19:18:23 +08:00
wsr.batch = batch;// wod.batch;
wsr.productDate = productDate;
wsr.skuId = skuId;
wsr.rectype = (int)enumStockRecordType.集货分播;
初次提交
2023-05-23 16:13:17 +08:00
wsr.Add();
WmsOutPickPort wop = new WmsOutPickPort();
wop.recordId = wsr.ID;
wop.pickBy = operId;
before release
2023-11-21 19:18:23 +08:00
wop.pickTime = wop.getDateTime();
初次提交
2023-05-23 16:13:17 +08:00
wop.pickCount = seedCnt;
before release
2023-11-21 19:18:23 +08:00
wop.pickOrderNo = wod.pickOrderNo;
初次提交
2023-05-23 16:13:17 +08:00
wop.state = (int)enumPickState.已分播;
before release
2023-11-21 19:18:23 +08:00
wop.recType = (int)enumStockRecordType.集货分播;
初次提交
2023-05-23 16:13:17 +08:00
wop.seedsFromFlowNo = flowNo;
wop.flowNo = toFlowNo;
process succeed.
2023-09-04 22:41:19 +08:00
wop.pickDetailId = wod.ID;
wop.operater = operId;
before release
2023-11-21 19:18:23 +08:00
wop.jobNo = wmsflow.task;
int id = wop.Add();
process succeed.
2023-09-04 22:41:19 +08:00
before release
2023-11-21 19:18:23 +08:00
/*
if(toPlate.customerId!=wod.customerId)
{
toPlate.customerId = wod.customerId;
toPlate.Update();
}
*/
foreach (WmsOutPickPort port in lstExists)
{
if (port.pickCount <= port.seedsOutCount)
{
port.state = (int)enumPickState.已分播;
seedsDoneCnt++;
port.Update();
}
// WmsPlateStock_tmp t = new WmsPlateStock_tmp();
// t.getByOutPort(wop.ID);
// t.Delete();
}
// logTest.Debug(string.Format("2 seeds done cnt {0}, totalcnt of task{1}", seedsDoneCnt, dt.Rows.Count));
wmsflow.finishedTasksPlus(operId, true, seedsDoneCnt == dt.Rows.Count);
// log.Debug(" 2 WmsPlateStock_tmp lstUpdate count " + lstUpdate.Count);
foreach (WmsPlateStock_tmp tmp in lstUpdate)
{
// log.Debug("3 tmp.count " + tmp.count);
// log.Debug(tmpStk);
if (tmp.count == 0)
{
// log.Debug("deleted tmp stock, outPortId " + tmp.outPortId);
tmp.Delete();
}
else
{
tmp.Update();
}
}
if (lstUpdate.Count > 0)
process succeed.
2023-09-04 22:41:19 +08:00
{
before release
2023-11-21 19:18:23 +08:00
WmsPlateStock_tmp stk = lstUpdate[0]; //copy source tmp stk info
process succeed.
2023-09-04 22:41:19 +08:00
stk.outPortId = id;
stk.plateId = toFlowNo;
stk.count = seedCnt;
before release
2023-11-21 19:18:23 +08:00
stk.orderNo = wod.pickOrderNo;
stk.recordId = wsr.ID;
stk.skuId = skuId;
stk.productDate = productDate;
stk.customerId = wod.customerId;
process succeed.
2023-09-04 22:41:19 +08:00
stk.Add();
}
before release
2023-11-21 19:18:23 +08:00
scope.Complete();
}
process succeed.
2023-09-04 22:41:19 +08:00
初次提交
2023-05-23 16:13:17 +08:00
before release
2023-11-21 19:18:23 +08:00
return enumRepResult.成功;
}
private enumRepResult zhitongSeedOut(int inDetailId, int outDetailId, decimal seedCnt, string flowNo, string toFlowNo)
{
logOut.Debug("直通分货开始。。。。。。。。");
WmsPlateStock_tmp tmpStk = new WmsPlateStock_tmp();
WmsOutPickDetail wod = new WmsOutPickDetail(outDetailId);
WmsInRequestDetail wid = new WmsInRequestDetail(inDetailId);
WmsFlow flow = new WmsFlow(wid.taskNo);
enumRepResult rs = flow.checkFlow(operId, flow.type);
if (rs != enumRepResult.成功)
{
return rs;
}
DataTable dt = getWmsInUpPort.getJobsByFlowSku(flowNo, wid.goodsId, wid.productDate);
List<WmsInUpPort> lstExists = new List<WmsInUpPort>();
List<WmsPlateStock_tmp> lstUpdate = new List<WmsPlateStock_tmp>();
decimal tmpCnt = seedCnt;
foreach (DataRow dr in dt.Rows)
{
WmsInUpPort wip = new WmsInUpPort(dr);
decimal tmpCnt2 = 0;
if (wip.state == (int)enumInStockDetailStatus.已分配货位) //已经收货完毕
{
if (wip.upCount + tmpCnt <= wip.count)
{
tmpCnt2 = tmpCnt;
wip.upCount += tmpCnt;
lstExists.Add(wip);
tmpCnt = 0;
}
else
{
tmpCnt -= wip.count - wip.upCount;
wip.upCount = wip.count;
lstExists.Add(wip);
tmpCnt2 = wip.count;
}
/*
* 更新临时库数据
*
*/
DataTable dt1 = tmpStk.getByInPort(wip.ID);
foreach (DataRow dr1 in dt1.Rows)
{
if (tmpCnt2 <= 0)
{
break;
}
tmpStk = new WmsPlateStock_tmp(dr1);
// log.Debug("1 tmpStk.count " + tmpStk.count + ", tmpCnt2: " + tmpCnt2);
if (tmpStk.count >= tmpCnt2)
{
tmpStk.count -= tmpCnt2;
tmpCnt2 = 0;
}
else
{
tmpCnt2 -= tmpStk.count;
tmpStk.count = 0;
}
// log.Debug("2 tmpStk.count " + tmpStk.count + ", tmpCnt2: " + tmpCnt2);
// log.Debug(tmpStk);
lstUpdate.Add(tmpStk);
}
if (tmpCnt == 0)
{
break;
}
}
}
if (seedCnt > wid.validCount-wid.seedOutCnt)
{
seedCnt = wid.validCount - wid.seedOutCnt;
// return enumRepResult.分播数量大于剩余数量;
}
seedCnt = seedCnt > wod.count - wod.seeded ? wod.count - wod.seeded : seedCnt;
wod.seeded += seedCnt;
if (wod.count <= wod.seeded)
{
wod.state = (int)enumOutStockDetailStatus.播种完成;
}
// log.Debug(" 1 WmsPlateStock_tmp lstUpdate count " + lstUpdate.Count);
using (TransactionScope scope = new TransactionScope())
{
wid.seedOutCnt+=seedCnt;
wid.Update();
flow.finishedTasksPlus(operId,true,wid.seedOutCnt>=wid.validCount);
wod.Update();
if (wod.isAllPicked(wod.pickOrderNo))
process succeed.
2023-09-04 22:41:19 +08:00
{
before release
2023-11-21 19:18:23 +08:00
new lWmsOutPickRequest(operId).updateOrderStatus(wod.pickOrderNo, enumOutStockPickStatus.分拣完成);
}
logOut.Debug(string.Format("zhitong seeds out goodsId :{0}, seedCnt :{1}, wid seedOutCnt {2}, wod id {3}, seeded count {4}", wid.goodsId, seedCnt, wid.seedOutCnt, wod.ID, wod.seeded));
WmsStockRecord wsr = new WmsStockRecord();
wsr.orderNo = wod.pickOrderNo;
wsr.orderDetailId = wod.ID;
wsr.goodsId = wod.goodsId;
wsr.count = seedCnt;
wsr.locationId = flowNo;
wsr.operater = operId;
wsr.batch = wid.productDate;// wod.batch;
wsr.productDate = wid.productDate;
wsr.skuId = wid.skuId;
wsr.rectype = (int)enumStockRecordType.集货分播;
wsr.Add();
WmsOutPickPort wop = new WmsOutPickPort();
wop.recordId = wsr.ID;
wop.pickBy = operId;
wop.pickTime = wop.getDateTime();
wop.count= wop.pickCount = seedCnt;
wop.pickOrderNo = wod.pickOrderNo;
wop.state = (int)enumPickState.已分播;
wop.recType = (int)enumStockRecordType.集货分播;
wop.seedsFromFlowNo = flowNo;
wop.flowNo = toFlowNo;
wop.pickDetailId = wod.ID;
wop.operater = operId;
wop.jobNo = flow.task;
int id = wop.Add();
foreach (WmsInUpPort port in lstExists)
{
if (port.count <= port.upCount)
process succeed.
2023-09-04 22:41:19 +08:00
{
before release
2023-11-21 19:18:23 +08:00
port.state = (int)enumInStockDetailStatus.直通分货完成;
port.Update();
process succeed.
2023-09-04 22:41:19 +08:00
}
before release
2023-11-21 19:18:23 +08:00
}
/*
if(toPlate.customerId!=wod.customerId)
{
toPlate.customerId = wod.customerId;
toPlate.Update();
初次提交
2023-05-23 16:13:17 +08:00
}
before release
2023-11-21 19:18:23 +08:00
*/
// log.Debug(" 2 WmsPlateStock_tmp lstUpdate count " + lstUpdate.Count);
foreach (WmsPlateStock_tmp tmp in lstUpdate)
process succeed.
2023-09-04 22:41:19 +08:00
{
before release
2023-11-21 19:18:23 +08:00
// log.Debug("3 tmp.count " + tmp.count);
// log.Debug(tmpStk);
if (tmp.count == 0)
process succeed.
2023-09-04 22:41:19 +08:00
{
before release
2023-11-21 19:18:23 +08:00
// log.Debug("deleted tmp stock, outPortId " + tmp.outPortId);
process succeed.
2023-09-04 22:41:19 +08:00
tmp.Delete();
}
else
{
tmp.Update();
}
}
before release
2023-11-21 19:18:23 +08:00
if (lstUpdate.Count > 0)
{
WmsPlateStock_tmp stk = lstUpdate[0]; //copy source tmp stk info
stk.outPortId = id;
stk.plateId = toFlowNo;
stk.count = seedCnt;
stk.orderNo = wod.pickOrderNo;
stk.recordId = wsr.ID;
// stk.skuId = skuId;
// stk.productDate = productDate;
stk.customerId = wod.customerId;
stk.Add();
}
process succeed.
2023-09-04 22:41:19 +08:00
初次提交
2023-05-23 16:13:17 +08:00
scope.Complete();
}
before release
2023-11-21 19:18:23 +08:00
logOut.Debug("直通分货结束");
初次提交
2023-05-23 16:13:17 +08:00
return enumRepResult.成功;
}
process succeed.
2023-09-04 22:41:19 +08:00
internal enumRepResult stackDone(string preInNo, string flowNo)
{
throw new NotImplementedException();
}
初次提交
2023-05-23 16:13:17 +08:00
internal DataTable getSeedsPickDetail(string flowNo, bool isOrderByCust)
{
process succeed.
2023-09-04 22:41:19 +08:00
// return getWmsOutPickPort.getSeedsOutDetail(flowNo, isOrderByCust);
return getWmsOutPickPort.getSeedsOutPickDetail(flowNo, isOrderByCust);
初次提交
2023-05-23 16:13:17 +08:00
}
/*
* 取消拣货任务
*
*/
before release
2023-11-21 19:18:23 +08:00
public int taskRessign(int taskBy, int partion, int lineId, bool batchOnly = true, enumOrderType orderType = enumOrderType.销售出库)
初次提交
2023-05-23 16:13:17 +08:00
{
DataTable dt = getWmsOutPickPort.getAssignedTasks(taskBy, partion, lineId, batchOnly,orderType);
int i=0;
WmsOutPickPort wop;
using (TransactionScope scope = new TransactionScope())
{
foreach (DataRow dr in dt.Rows)
{
wop = new WmsOutPickPort(dr);
wop.takeBy = 0;
// wop.operater = operId;
if (wop.state == (int)enumPickState.未拣)
{
wop.Update();
i++;
LogHelper.debug("lWmsOutPickPort", " user " + taskBy + " task resign:" + wop.ID);
}
}
scope.Complete();
}
return i;
}
before release
2023-11-21 19:18:23 +08:00
public DataTable getAssignedTasks4Wince(int taskBy, int partion = 0, int lineId = -1, bool batchOnly = true,enumOrderType orderType = enumOrderType.销售出库)
初次提交
2023-05-23 16:13:17 +08:00
{
return getWmsOutPickPort.getAssignedTasks4Wince(taskBy, partion, lineId, batchOnly, orderType);
}
before release
2023-11-21 19:18:23 +08:00
public DataTable getAssignedOutTasks(int taskBy, int partion = 0, int lineId = -1, bool batchOnly = true, enumOrderType orderType = enumOrderType.销售出库)
初次提交
2023-05-23 16:13:17 +08:00
{
return getWmsOutPickPort.getAssignedTasks(taskBy, partion, lineId, batchOnly, orderType);
}
public DataTable getPartions(int userID)
{
return getWmsOutPickPort.getPartions(userID);
}
internal DataTable getRepTasks(int takeBy, int taskPartion )
{
return getWmsOutPickPort.getRepTasks(takeBy, taskPartion );
}
process succeed.
2023-09-04 22:41:19 +08:00
internal DataTable getFlows4SeedsOut()
{
return getWmsOutPickPort.getFlows4SeedsOut() ;
}
before release
2023-11-21 19:18:23 +08:00
internal DataTable getFlows4ZhitongSeedsOut()
{
return getWmsInRequestDetail.getFlows4ZhitongSeedsOut();
}
初次提交
2023-05-23 16:13:17 +08:00
}
}