/// <summary>
/// MaintainInhouseLogisticStandardInfo=>TranDetailsInfo
/// </summary>
/// <param name="maintainInhouseLogisticStandardInfo"></param>
/// <param name="tranDetailsInfo"></param>
/// <returns></returns>
public static void GetTranDetailsInfo(MaintainInhouseLogisticStandardInfo maintainInhouseLogisticStandardInfo,
string stockCheckLockMaterialSyncUpdatePartStockFlag,
ref TranDetailsInfo tranDetailsInfo)
{
if (maintainInhouseLogisticStandardInfo == null)
{
return;
}
///工位
tranDetailsInfo.Location = maintainInhouseLogisticStandardInfo.Location;
///库位
tranDetailsInfo.StorageLocation = maintainInhouseLogisticStandardInfo.StorageLocation;
/////是否排查锁定库存
//if (stockCheckLockMaterialSyncUpdatePartStockFlag.ToLower() == "true"
// && maintainInhouseLogisticStandardInfo.CheckMaterialStockFlag.GetValueOrDefault())
///是否排查锁定库存
if (stockCheckLockMaterialSyncUpdatePartStockFlag.ToLower() == "true")
{
///将物料出库交易类型变更为物料解冻
if (tranDetailsInfo.TranType.GetValueOrDefault() == (int)WmmTranTypeConstants.Outbound)
{
tranDetailsInfo.TranType = (int)WmmTranTypeConstants.MaterialThawing;
}
if (tranDetailsInfo.TranType.GetValueOrDefault() == (int)WmmTranTypeConstants.StateFreezing)
{
tranDetailsInfo.TranType = (int)WmmTranTypeConstants.None;
}
}
}
/// <summary>
/// MaintainInhouseLogisticStandardInfo -> TwdPullOrderDetailInfo
/// </summary>
/// <param name="logisticStandardInfo"></param>
/// <param name="info"></param>
public static void GetTwdPullOrderDetailInfo(MaintainInhouseLogisticStandardInfo logisticStandardInfo, ref TwdPullOrderDetailInfo info)
{
if (logisticStandardInfo == null)
{
return;
}
///SUPPLIER_NUM,供应商代码
info.SupplierNum = logisticStandardInfo.SupplierNum;
///WORKSHOP_SECTION,工段
info.WorkshopSection = logisticStandardInfo.WorkshopSection;
///LOCATION,工位
info.Location = logisticStandardInfo.Location;
///PART_NO,物料号
info.PartNo = logisticStandardInfo.PartNo;
///PART_CNAME,物料中文描述
info.PartCname = logisticStandardInfo.PartCname;
///PART_ENAME,物料英文描述
info.PartEname = logisticStandardInfo.PartEname;
///MEASURING_UNIT_NO,单位
//info.MeasuringUnitNo = logisticStandardInfo.PartUnits;
///PACKAGE,单包装数量
info.Package = logisticStandardInfo.InboundPackage;
///PACKAGE_MODEL,包装编号
info.PackageModel = logisticStandardInfo.InboundPackageModel;
}
/// <summary>
/// MaintainInhouseLogisticStandardInfo -> TwdCounterLogInfo
/// </summary>
/// <param name="maintainInhouseLogisticStandardInfo"></param>
/// <param name="twdCounterLogInfo"></param>
public static void GetTwdCounterLogInfo(MaintainInhouseLogisticStandardInfo maintainInhouseLogisticStandardInfo, ref TwdCounterLogInfo twdCounterLogInfo)
{
if (maintainInhouseLogisticStandardInfo == null)
{
return;
}
///PART_NO
twdCounterLogInfo.PartNo = maintainInhouseLogisticStandardInfo.PartNo;
///PART_CNAME
twdCounterLogInfo.PartCname = maintainInhouseLogisticStandardInfo.PartCname;
///SUPPLIER_NUM
twdCounterLogInfo.SupplierNum = maintainInhouseLogisticStandardInfo.SupplierNum;
///PLANT
twdCounterLogInfo.Plant = maintainInhouseLogisticStandardInfo.Plant;
///PLANT_ZONE
twdCounterLogInfo.PlantZone = maintainInhouseLogisticStandardInfo.PlantZone;
///WORKSHOP
twdCounterLogInfo.Workshop = maintainInhouseLogisticStandardInfo.Workshop;
///ASSEMBLY_LINE
twdCounterLogInfo.AssemblyLine = maintainInhouseLogisticStandardInfo.AssemblyLine;
///WORKSHOP_SECTION
twdCounterLogInfo.WorkshopSection = maintainInhouseLogisticStandardInfo.WorkshopSection;
///LOCATION
twdCounterLogInfo.Location = maintainInhouseLogisticStandardInfo.Location;
///PACKAGE
twdCounterLogInfo.Package = maintainInhouseLogisticStandardInfo.InboundPackage.GetValueOrDefault();
///PACKAGE_MODEL
twdCounterLogInfo.PackageModel = maintainInhouseLogisticStandardInfo.InboundPackageModel;
}
/// <summary>
/// MaintainInhouseLogisticStandardInfo -> TwdCounterInfo
/// </summary>
/// <param name="maintainInhouseLogisticStandardInfo"></param>
/// <param name="twdCounterInfo"></param>
public static void GetTwdCounterInfo(MaintainInhouseLogisticStandardInfo maintainInhouseLogisticStandardInfo, ref TwdCounterInfo twdCounterInfo)
{
if (maintainInhouseLogisticStandardInfo == null)
{
return;
}
twdCounterInfo.PartPullFid = maintainInhouseLogisticStandardInfo.Fid;
twdCounterInfo.PartBoxCode = maintainInhouseLogisticStandardInfo.InhousePartClass;
twdCounterInfo.Plant = maintainInhouseLogisticStandardInfo.Plant;
twdCounterInfo.PlantZone = maintainInhouseLogisticStandardInfo.PlantZone;
twdCounterInfo.Workshop = maintainInhouseLogisticStandardInfo.Workshop;
twdCounterInfo.AssemblyLine = maintainInhouseLogisticStandardInfo.AssemblyLine;
twdCounterInfo.SupplierNum = maintainInhouseLogisticStandardInfo.SupplierNum;
twdCounterInfo.PartNo = maintainInhouseLogisticStandardInfo.PartNo;
twdCounterInfo.PartCname = maintainInhouseLogisticStandardInfo.PartCname;
twdCounterInfo.WorkshopSection = maintainInhouseLogisticStandardInfo.WorkshopSection;
twdCounterInfo.Location = maintainInhouseLogisticStandardInfo.Location;
twdCounterInfo.Package = maintainInhouseLogisticStandardInfo.InboundPackage;
twdCounterInfo.PackageModel = maintainInhouseLogisticStandardInfo.InboundPackageModel;
}
/// <summary>
/// MaintainInhouseLogisticStandardInfo -> EmergencyPullingCartInfo
/// </summary>
/// <param name="maintainInhouseLogisticStandardInfo"></param>
/// <param name="info"></param>
public static void GetEmergencyPullingCartInfo(MaintainInhouseLogisticStandardInfo maintainInhouseLogisticStandardInfo, ref EmergencyPullingCartInfo info)
{
if (maintainInhouseLogisticStandardInfo == null)
{
return;
}
///LOGISTICSTANDARD_FID
info.LogisticStandardFid = maintainInhouseLogisticStandardInfo.Fid;
///PART_NO
info.PartNo = maintainInhouseLogisticStandardInfo.PartNo;
///PART_CNAME
info.PartCname = maintainInhouseLogisticStandardInfo.PartCname;
///PULL_PACKAGE_QTY
info.PullPackageQty = maintainInhouseLogisticStandardInfo.InboundPackage;
///PULL_PACKAGE_MODEL
info.PullPackageModel = maintainInhouseLogisticStandardInfo.InboundPackageModel;
///SUPPLIER_NUM
info.SupplierNum = maintainInhouseLogisticStandardInfo.SupplierNum;
///PULL_MODE
info.PullMode = Convert.ToInt32(maintainInhouseLogisticStandardInfo.InhouseSystemMode);
///PART_BOX_CODE
info.PartBoxCode = maintainInhouseLogisticStandardInfo.InhousePartClass;
///S_WM_NO
info.SWmNo = maintainInhouseLogisticStandardInfo.SWmNo;
///S_ZONE_NO
info.SZoneNo = maintainInhouseLogisticStandardInfo.SZoneNo;
///T_WM_NO
info.TWmNo = maintainInhouseLogisticStandardInfo.TWmNo;
///T_ZONE_NO
info.TZoneNo = maintainInhouseLogisticStandardInfo.TZoneNo;
///PLANT
info.Plant = maintainInhouseLogisticStandardInfo.Plant;
///WORKSHOP
info.Workshop = maintainInhouseLogisticStandardInfo.Workshop;
///ASSEMBLY_LINE
info.AssemblyLine = maintainInhouseLogisticStandardInfo.AssemblyLine;
///WORKSHOP_SECTION
info.WorkshopSection = maintainInhouseLogisticStandardInfo.WorkshopSection;
///LOCATION
info.Location = maintainInhouseLogisticStandardInfo.Location;
}
/// <summary>
/// MaintainInhouseLogisticStandardInfo-->PlanPullOrderDetailInfo
/// </summary>
/// <param name="logisticStandardInfo"></param>
/// <param name="info"></param>
public static void GetPlanPullOrderDetail(MaintainInhouseLogisticStandardInfo logisticStandardInfo, ref PlanPullOrderDetailInfo info)
{
if (logisticStandardInfo == null)
{
return;
}
///SupplierNum
info.SupplierNum = logisticStandardInfo.SupplierNum;
///PartNo
info.PartNo = logisticStandardInfo.PartNo;
///PartCname
info.PartCname = logisticStandardInfo.PartCname;
///PartEname
info.PartEname = logisticStandardInfo.PartEname;
///MeasuringUnitNo
//info.MeasuringUnitNo = logisticStandardInfo.PartUnits;
///InboundPackageModel
info.InboundPackageModel = logisticStandardInfo.InboundPackageModel;
///InboundPackageQty
info.InboundPackageQty = logisticStandardInfo.InboundPackage.GetValueOrDefault();
}
/// <summary>
/// 获取更新计数器的语句
/// </summary>
/// <param name="maintainInhouseLogisticStandardInfo"></param>
/// <param name="twdPartBoxInfo"></param>
/// <param name="requireQty"></param>
/// <param name="twdCounterId"></param>
/// <param name="loginUser"></param>
/// <returns></returns>
public static string UpdateTwdCounter(MaintainInhouseLogisticStandardInfo maintainInhouseLogisticStandardInfo, TwdPartBoxInfo twdPartBoxInfo, decimal requireQty, long twdCounterId, string loginUser)
{
return("update [LES].[TT_MPM_TWD_COUNTER] set " +
"[PART_BOX_CODE] = N'" + maintainInhouseLogisticStandardInfo.InhousePartClass + "'," +
"[PLANT] = N'" + maintainInhouseLogisticStandardInfo.Plant + "'," +
"[PLANT_ZONE] = N'" + maintainInhouseLogisticStandardInfo.PlantZone + "'," +
"[WORKSHOP] = N'" + maintainInhouseLogisticStandardInfo.Workshop + "'," +
"[ASSEMBLY_LINE] = N'" + maintainInhouseLogisticStandardInfo.AssemblyLine + "'," +
"[WORKSHOP_SECTION] = N'" + maintainInhouseLogisticStandardInfo.WorkshopSection + "'," +
"[LOCATION] = N'" + maintainInhouseLogisticStandardInfo.Location + "'," +
"[SUPPLIER_NUM] = N'" + maintainInhouseLogisticStandardInfo.SupplierNum + "'," +
"[REQUIREMENT_ACCUMULATE_MODE] = " + twdPartBoxInfo.RequirementAccumulateMode.GetValueOrDefault() + "," +
"[ROUNDNESS_MODE] = " + twdPartBoxInfo.RoundnessMode + "," +
"[PART_NO] = N'" + maintainInhouseLogisticStandardInfo.PartNo + "'," +
"[PART_CNAME] = N'" + maintainInhouseLogisticStandardInfo.PartCname + "'," +
"[PACKAGE] = " + maintainInhouseLogisticStandardInfo.InboundPackage.GetValueOrDefault() + "," +
"[PACKAGE_MODEL] = N'" + maintainInhouseLogisticStandardInfo.InboundPackageModel + "'," +
"[CURRENT_QTY] = isnull([CURRENT_QTY],0) + " + requireQty + "," +
"[MODIFY_DATE] = GETDATE()," +
"[MODIFY_USER] = N'" + loginUser + "' where " +
"[ID] = " + twdCounterId + ";");
}
/// <summary>
/// 根据生产线+物料号集合获取需要校验物料库存的基础数据
/// </summary>
/// <param name="assemblyLine"></param>
/// <param name="partNos"></param>
/// <returns></returns>
public List <MaintainInhouseLogisticStandardInfo> GetCheckMaterialStockList(string assemblyLine, List <string> partNos)
{
string sql = "select [PART_NO],[SUPPLIER_NUM],[S_ZONE_NO],[S_WM_NO] from [LES].[TM_BAS_MAINTAIN_INHOUSE_LOGISTIC_STANDARD] with(nolock) "
+ "where [VALID_FLAG] = 1 and [CHECK_MATERIAL_STOCK_FLAG] =1 and [ASSEMBLY_LINE] = @ASSEMBLY_LINE and [PART_NO] in ('" + string.Join("','", partNos.ToArray()) + "');";
Database db = DatabaseFactory.CreateDatabase();
DbCommand cmd = db.GetSqlStringCommand(sql);
db.AddInParameter(cmd, "@ASSEMBLY_LINE", DbType.AnsiString, assemblyLine);
List <MaintainInhouseLogisticStandardInfo> list = new List <MaintainInhouseLogisticStandardInfo>();
using (IDataReader dr = db.ExecuteReader(cmd))
{
while (dr.Read())
{
MaintainInhouseLogisticStandardInfo info = new MaintainInhouseLogisticStandardInfo();
info.PartNo = DBConvert.GetString(dr, dr.GetOrdinal("PART_NO"));
info.SupplierNum = DBConvert.GetString(dr, dr.GetOrdinal("SUPPLIER_NUM"));
info.SZoneNo = DBConvert.GetString(dr, dr.GetOrdinal("S_ZONE_NO"));
info.SWmNo = DBConvert.GetString(dr, dr.GetOrdinal("S_WM_NO"));
list.Add(info);
}
}
return(list);
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <param name="loginUser"></param>
/// <returns></returns>
public bool LogicDeleteInfo(long id, string loginUser)
{
///获取实体对象
MaintainInhouseLogisticStandardInfo info = dal.GetInfo(id);
if (info.Status != (int)BasicDataStatusConstants.Created)
{
throw new Exception("Err_:MC:0x00000415");/// 已创建状态才可进行删除
}
#region 当拉动方式为看板时进行校验
if (int.Parse(info.InhouseSystemMode) == (int)PullModeConstants.Kanban)
{
///零件拉动信息对应看板卡全部处于已作废状态或没有看板卡数据
int cnt = new KanbanCardDAL().GetCounts(string.Format("[STATUS] in (" + (int)BasicDataStatusConstants.Created + "," + (int)BasicDataStatusConstants.Enable + ") "///看板卡创建时的状态也应该是BASIC_DATA_STATUS对应的值
+ "and [PART_NO] = N'{0}' and [PART_BOX_CODE] = N'{1}'", info.PartNo, info.InhousePartClass));
if (cnt > 0)
{
throw new Exception("Err_:MC:0x00000309");///存在有效看板不可删除
}
}
#endregion
return(dal.LogicDelete(id, loginUser) > 0 ? true : false);
}
/// <summary>
///
/// </summary>
/// <param name="partNos"></param>
/// <returns></returns>
public List <MaintainInhouseLogisticStandardInfo> GetListForInterfaceDataSync(List <string> partNos)
{
string sql = "select [ID],[PART_NO],[SUPPLIER_NUM],[INHOUSE_SYSTEM_MODE],[INHOUSE_PART_CLASS] "
+ "from [LES].[TM_BAS_MAINTAIN_INHOUSE_LOGISTIC_STANDARD] with(nolock) "
+ "where [VALID_FLAG] = 1 and [PART_NO] in ('" + string.Join("','", partNos.ToArray()) + "');";
Database db = DatabaseFactory.CreateDatabase();
DbCommand cmd = db.GetSqlStringCommand(sql);
List <MaintainInhouseLogisticStandardInfo> list = new List <MaintainInhouseLogisticStandardInfo>();
using (IDataReader dr = db.ExecuteReader(cmd))
{
while (dr.Read())
{
MaintainInhouseLogisticStandardInfo info = new MaintainInhouseLogisticStandardInfo();
info.Id = DBConvert.GetInt64(dr, dr.GetOrdinal("ID"));
info.PartNo = DBConvert.GetString(dr, dr.GetOrdinal("PART_NO"));
info.SupplierNum = DBConvert.GetString(dr, dr.GetOrdinal("SUPPLIER_NUM"));
info.InhouseSystemMode = DBConvert.GetString(dr, dr.GetOrdinal("INHOUSE_SYSTEM_MODE"));
info.InhousePartClass = DBConvert.GetString(dr, dr.GetOrdinal("INHOUSE_PART_CLASS"));
list.Add(info);
}
}
return(list);
}
/// <summary>
/// 在线替换
/// </summary>
/// <param name="bomRepleaceConditionInfos"></param>
/// <param name="loginUser"></param>
public void OnlineReplacement(List <BomRepleaceConditionInfo> bomRepleaceConditionInfos, string loginUser)
{
if (bomRepleaceConditionInfos.Count == 0)
{
return;
}
///生产订单
List <PullOrdersInfo> pullOrdersInfos = new PullOrdersDAL().GetList("" +
" and [CHANGE_FLAG]=" + (int)ChangeFlagConstants.NotReplaced + "", string.Empty);
if (pullOrdersInfos.Count == 0)
{
return;
}
///车辆状态点信息集合
List <VehiclePointStatusInfo> vehiclePointStatusInfos = new VehiclePointStatusDAL().GetList("" +
"and [ORDER_NO] in ('" + string.Join("','", bomRepleaceConditionInfos.Select(d => d.StartPorderCode).ToArray()) + "')", string.Empty);
if (vehiclePointStatusInfos.Count == 0)
{
return;
}
///状态点集合
List <StatusPointInfo> statusPointInfos = new StatusPointDAL().GetList("" +
"[STATUS_POINT_CODE] in ('" + string.Join("','", vehiclePointStatusInfos.Select(d => d.StatusPointCode).ToArray()) + "')", string.Empty);
if (statusPointInfos.Count == 0)
{
return;
}
///时间窗（过点累计方式）零件类
List <TwdPartBoxInfo> twdPartBoxInfos = new TwdPartBoxDAL().GetList("" +
" and [STATUS] =" + (int)BasicDataStatusConstants.Enable + " " +
" and [REQUIREMENT_ACCUMULATE_MODE]=" + (int)RequirementAccumulateModeConstants.PassSpot + "" +
" and [STATUS_POINT_CODE] in ('" + string.Join("','", statusPointInfos.Select(d => d.StatusPointCode).ToArray()) + "')", string.Empty);
///排序拉动方式 零件类
List <JisPartBoxInfo> jisPartBoxInfos = new JisPartBoxDAL().GetList("" +
" and [STATUS] =" + (int)BasicDataStatusConstants.Enable + "" +
" and [STATUS_POINT_CODE] in ('" + string.Join("','", statusPointInfos.Select(d => d.StatusPointCode).ToArray()) + "')", string.Empty);
///相应的物料拉动信息
List <MaintainInhouseLogisticStandardInfo> maintainInhouseLogisticStandardInfos = new MaintainInhouseLogisticStandardDAL().GetList("" +
" and [STATUS] =" + (int)BasicDataStatusConstants.Enable + "" +
" (and [INHOUSE_PART_CLASS] in ('" + string.Join("','", twdPartBoxInfos.Select(d => d.PartBoxCode).ToArray()) + "')" +
" or [INHOUSE_PART_CLASS] in ('" + string.Join("','", jisPartBoxInfos.Select(d => d.PartBoxCode).ToArray()) + "'))", string.Empty);
if (maintainInhouseLogisticStandardInfos.Count == 0)
{
return;
}
foreach (BomRepleaceConditionInfo bomRepleaceConditionInfo in bomRepleaceConditionInfos)
{
///有效时间内
if (!(bomRepleaceConditionInfo.ExecuteStartTime <= DateTime.Now) || !(DateTime.Now <= bomRepleaceConditionInfo.ExecuteEndTime))
{
continue;
}
///根据起始生产订单号，获取车辆状态点信息判断其是否在线，若未上线则不执行以下逻辑
PullOrdersInfo pullOrdersInfo = pullOrdersInfos.FirstOrDefault(d => d.OrderNo == bomRepleaceConditionInfo.StartPorderCode);
if (pullOrdersInfo == null || pullOrdersInfo.OrderStatus != (int)OrderStatusConstants.AlreadOnline)
{
continue;
}
///若已上线或已下线则需要根据其获取顺序号之后的所有在线生产订单，依次循环进行逻辑处理 TODO:已下线的逻辑？
///同一起始生产订单号可能出现在多条生产线的状态点上，以下为单生产订单处理逻辑 TODO:多条生产线的逻辑？
///已上线的生产订单：
///本生产订单对应的车辆状态点信息
List <VehiclePointStatusInfo> vehiclePointStatuss = vehiclePointStatusInfos.Where(d => d.OrderNo == pullOrdersInfo.OrderNo).ToList();
if (vehiclePointStatuss.Count == 0)
{
continue;
}
///当前车辆最大状态点信息
VehiclePointStatusInfo vehiclePointStatusInfo = vehiclePointStatuss.Where(d => d.OrderNo == pullOrdersInfo.OrderNo).OrderByDescending(d => d.PassTime).FirstOrDefault();
if (vehiclePointStatusInfo == null)
{
continue;
}
///当前顺序号之后的所有的车辆状态点信息
List <VehiclePointStatusInfo> vehiclePoints = vehiclePointStatusInfos.Where(d => d.SeqNo >= vehiclePointStatusInfo.SeqNo).ToList();
///当前顺序号之后的所有在线生产订单
pullOrdersInfos = (from p in pullOrdersInfos
join v in vehiclePoints
on p.OrderNo equals v.OrderNo
select p).Distinct().ToList();
///依次循环进行逻辑处理
foreach (PullOrdersInfo pullOrder in pullOrdersInfos)
{
///根据生产订单号获取其物料清单，作为后续匹配更改单的源数据
List <PullOrderBomInfo> pullOrderBomInfos = new PullOrderBomDAL().GetList("" +
"and [ORDERFID]='" + pullOrdersInfo.Fid + "'", string.Empty);
if (pullOrderBomInfos.Count == 0)
{
continue;
}
///本生产订单对应的车辆状态点信息
List <VehiclePointStatusInfo> vehicles = vehiclePointStatusInfos.Where(d => d.OrderNo == pullOrdersInfo.OrderNo).ToList();
if (vehicles.Count == 0)
{
continue;
}
///本产生订单对应的所有状态点信息
List <StatusPointInfo> statusPoints = statusPointInfos.Where(d => vehicles.Select(v => v.StatusPointCode).Contains(d.StatusPointCode)).ToList();
if (statusPoints.Count == 0)
{
continue;
}
///已在线的生产订单在此时，需要根据所在状态点位置
VehiclePointStatusInfo vehiclePointStatus = vehiclePointStatusInfos.Where(d => d.OrderNo == pullOrder.OrderNo).OrderByDescending(d => d.PassTime).FirstOrDefault();
if (vehiclePointStatus == null)
{
continue;
}
StatusPointInfo statusPointInfo = statusPointInfos.FirstOrDefault(d => d.StatusPointCode == vehiclePointStatus.StatusPointCode);
if (statusPointInfo == null)
{
continue;
}
///将物料拉动的结果集分为三个部分，其一为未累计、其二为已累计未拉动、其三为已拉动
///该生产订单对应的其后状态点
List <StatusPointInfo> notStatusPoints = statusPoints.Where(d => d.StatusPointSeq > statusPointInfo.StatusPointSeq).ToList();
///该生产订单对应的状态点及之前的状态点
List <StatusPointInfo> yesStatusPoints = statusPoints.Where(d => d.StatusPointSeq <= statusPointInfo.StatusPointSeq).ToList();
///其后的状态点
if (notStatusPoints.Count > 0)
{
///其一为当前状态点位置之后的状态点对应的时间窗（过点累计方式）、排序拉动方式相应的物料拉动信息物料、供应商、工位
///该逻辑获取的数据在此不做后续处理，但此逻辑请事先在程序中实现，将会到离队归队时使用
List <TwdPartBoxInfo> twdPartBoxs = twdPartBoxInfos.Where(d => notStatusPoints.Select(s => s.StatusPointCode).Contains(d.StatusPointCode)).ToList();
List <JisPartBoxInfo> jisPartBoxs = jisPartBoxInfos.Where(d => notStatusPoints.Select(s => s.StatusPointCode).Contains(d.StatusPointCode)).ToList();
///零件类对应的物料拉动信息
if (twdPartBoxs.Count != 0 || jisPartBoxs.Count != 0)
{
///生产订单的产线下的物料拉动信息
List <MaintainInhouseLogisticStandardInfo> maintainInhouseLogisticStandards = maintainInhouseLogisticStandardInfos.
Where(d => d.AssemblyLine == pullOrder.AssemblyLine).Where(d =>
(twdPartBoxs.Select(t => t.PartBoxCode).Contains(d.InhousePartClass)) ||
(jisPartBoxs.Select(j => j.PartBoxCode).Contains(d.InhousePartClass))).ToList();
if (maintainInhouseLogisticStandards.Count != 0)
{
///拉动信息对应的Bom清单
List <PullOrderBomInfo> pullOrderBoms = pullOrderBomInfos.Where(d =>
maintainInhouseLogisticStandards.Select(m => m.PartNo).Contains(d.Zcomno) &&
maintainInhouseLogisticStandards.Select(m => m.SupplierNum).Contains(d.SupplierNum)).ToList();
}
}
}
///其二、其三目前没有较理想的方式区分开，暂时以已拉动处理、当前状态点位置之前包括该状态点位置对应的拉动方式相关物料拉动信息
if (yesStatusPoints.Count > 0)
{
List <TwdPartBoxInfo> twdPartBoxs = twdPartBoxInfos.Where(d => yesStatusPoints.Select(s => s.StatusPointCode).Contains(d.StatusPointCode)).ToList();
List <JisPartBoxInfo> jisPartBoxs = jisPartBoxInfos.Where(d => yesStatusPoints.Select(s => s.StatusPointCode).Contains(d.StatusPointCode)).ToList();
///零件类对应的物料拉动信息
if (twdPartBoxs.Count != 0 || jisPartBoxs.Count != 0)
{
///生产订单的产线下的物料拉动信息
List <MaintainInhouseLogisticStandardInfo> maintainInhouseLogisticStandards = maintainInhouseLogisticStandardInfos.
Where(d => d.AssemblyLine == pullOrder.AssemblyLine).Where(d =>
(twdPartBoxs.Select(t => t.PartBoxCode).Contains(d.InhousePartClass)) ||
(jisPartBoxs.Select(j => j.PartBoxCode).Contains(d.InhousePartClass))).ToList();
maintainInhouseLogisticStandards = maintainInhouseLogisticStandards.Where(d => d.PartNo == bomRepleaceConditionInfo.OldPartNo).ToList();
///根据已拉动的物料拉动信息，与替换条件中的旧物料号对比
///若不存在于已拉动物料中，则只需要执行生产订单物料清单替换逻辑即可
///否则需要进行新物料号的自动紧急拉动且生成旧物料号的余料退库单（退库地点为物料拉动信息中的来源库存地点）
///同时也需要执行生产订单物料清单替换逻辑
if (maintainInhouseLogisticStandards.Count > 0)
{
///拉动信息对应的Bom清单
List <PullOrderBomInfo> pullOrderBoms = pullOrderBomInfos.Where(d =>
maintainInhouseLogisticStandards.Select(m => m.PartNo).Contains(d.Zcomno) &&
maintainInhouseLogisticStandards.Select(m => m.SupplierNum).Contains(d.SupplierNum)).ToList();
foreach (PullOrderBomInfo pullOrderBom in pullOrderBoms)
{
MaintainInhouseLogisticStandardInfo maintainInhouseLogisticStandardInfo = maintainInhouseLogisticStandards.FirstOrDefault(d =>
d.PartNo == pullOrderBom.Zcomno && d.SupplierNum == pullOrderBom.SupplierNum);
if (maintainInhouseLogisticStandardInfo == null)
{
continue;
}
///进行新物料号的自动紧急拉动
///生成旧物料号的余料退库单（退库地点为物料拉动信息中的来源库存地点）
}
}
new BomRepleaceConditionBLL().ReplacementCriteria(pullOrder, loginUser);
}
}
}
}
}
/// <summary>
/// 对于MPM-036逻辑进行函数封装
/// </summary>
/// <param name="emergencyPullingCartInfos"></param>
/// <param name="loginUser"></param>
public static string Handler(List <EmergencyPullingCartInfo> emergencyPullingCartInfos, string loginUser)
{
///执行语句
StringBuilder @string = new StringBuilder();
///获取系统配置是否允许过量提前拉动
string allowedFlag = new ConfigDAL().GetValueByCode("ENABLE_EXCEED_COUNTER_QTY_WHEN_ADVANCE_PULL");
///接收紧急拉动购物车对象集合进行处理
if (emergencyPullingCartInfos.Count == 0)
{
throw new Exception("MC:0x00000084");///数据错误
}
///对应的物料拉动信息
List <MaintainInhouseLogisticStandardInfo> maintainInhouseLogisticStandardInfos = new MaintainInhouseLogisticStandardBLL().GetList("" +
" and [STATUS] =" + (int)BasicDataStatusConstants.Enable + "" +
" and [FID] in ('" + string.Join("','", emergencyPullingCartInfos.Select(d => d.LogisticStandardFid).ToArray()) + "')", string.Empty);
if (maintainInhouseLogisticStandardInfos.Count == 0)
{
throw new Exception("MC:0x00000213");///物料拉动信息数据错误
}
///首先需要将其按照拉动方式、零件类进行分组，每个分组产生一张紧急拉动单
var cartGroups = emergencyPullingCartInfos.GroupBy(d => new { d.PullMode, d.PartBoxCode }).ToList();
#region 手工拉动 PLAN
var planCartGroups = cartGroups.Where(d => d.Key.PullMode == (int)PullModeConstants.Plan).ToList();
///计划拉动零件类
List <PlanPartBoxInfo> planPartBoxInfos = new PlanPartBoxBLL().GetList("" +
" and [STATUS] = " + (int)BasicDataStatusConstants.Enable + "" +
" and [PART_BOX_CODE] in ('" + string.Join("','", planCartGroups.Select(d => d.Key.PartBoxCode).ToArray()) + "')", string.Empty);
foreach (var planCartGroup in planCartGroups)
{
///从参数集合从提取对应的紧急拉动购物车集合
List <EmergencyPullingCartInfo> pullingCartInfos = emergencyPullingCartInfos.Where(d =>
d.PullMode == planCartGroup.Key.PullMode && d.PartBoxCode == planCartGroup.Key.PartBoxCode).ToList();
if (pullingCartInfos.Count == 0)
{
continue;
}
///计划零件类
PlanPartBoxInfo planPartBoxInfo = planPartBoxInfos.FirstOrDefault(d => d.PartBoxCode == planCartGroup.Key.PartBoxCode);
if (planPartBoxInfo == null)
{
continue;
}
///计划拉动-->仓储衔接主表
MaterialPullingOrderInfo materialPulling = MaterialPullingCommonBLL.CreateMaterialPullingOrderInfo();
///计划拉动单主表
PlanPullOrderInfo planPullOrderInfo = PlanPullOrderBLL.CreatePlanPullOrder(loginUser);
///OrderType 拉动单类型
planPullOrderInfo.OrderType = (int)PullOrderTypeConstants.Emergency;
///PlanPartBoxInfo-->PlanPullOrderInfo
PlanPullOrderBLL.GetPlanPullOrder(planPartBoxInfo, ref planPullOrderInfo);
///计划拉动单主表sql
@string.AppendLine(PlanPullOrderDAL.GetInsertSql(planPullOrderInfo));
///PlanPullOrderInfo -> MaterialPullingOrderInfo
MaterialPullingCommonBLL.GetMaterialPlanPullingOrderInfo(planPullOrderInfo, ref materialPulling);
foreach (EmergencyPullingCartInfo planCartInfo in pullingCartInfos)
{
///物料拉动信息
MaintainInhouseLogisticStandardInfo maintainInhouseLogisticStandardInfo = maintainInhouseLogisticStandardInfos.FirstOrDefault(d => d.Fid == planCartInfo.LogisticStandardFid);
if (maintainInhouseLogisticStandardInfo == null)
{
continue;
}
///物料包装数量在此需要根据单包装数量以及物料需求数量进行向上圆整计算
///REQUIRED_BOX_QTY:物料包装数量 PULL_PACKAGE_QTY:单包装数量 REQUIRED_PART_QTY:物料需求数量
if (planCartInfo.PullPackageQty.GetValueOrDefault() == 0)
{
continue; ///O不能做被除数
}
planCartInfo.RequiredBoxQty = Convert.ToInt32(Math.Ceiling(planCartInfo.RequiredPartQty.GetValueOrDefault() / planCartInfo.PullPackageQty.GetValueOrDefault()));
///仓储衔接明细表
MaterialPullingOrderDetailInfo detailInfo = MaterialPullingCommonBLL.CreateMaterialPullingOrderDetailInfo();
///计划拉动单明细
PlanPullOrderDetailInfo planPullOrderDetailInfo = PlanPullOrderDetailBLL.CreatePlanPullOrderDetail(loginUser);
///MaintainInhouseLogisticStandardInfo -> PlanPullOrderDetailInfo
PlanPullOrderDetailBLL.GetPlanPullOrderDetail(maintainInhouseLogisticStandardInfo, ref planPullOrderDetailInfo);
///TwdPullOrderInfo -> TwdPullOrderDetailInfo
PlanPullOrderDetailBLL.GetPlanPullOrderDetailInfo(planPullOrderInfo, ref planPullOrderDetailInfo);
///RequiredPackageQty
planPullOrderDetailInfo.RequiredPackageQty = planCartInfo.RequiredBoxQty.GetValueOrDefault();
///RequiredPartQty
planPullOrderDetailInfo.RequiredPartQty = planCartInfo.RequiredPartQty.GetValueOrDefault();
///计划拉动明细sql
@string.AppendLine(PlanPullOrderDetailDAL.GetInsertSql(planPullOrderDetailInfo));
///PlanPullOrderDetailInfo -> MaterialPullingOrderDetailInfo
MaterialPullingCommonBLL.GetMaterialPullingOrderDetail(planPullOrderDetailInfo, ref detailInfo);
///仓储明细集合Add
materialPulling.MaterialPullingOrderDetailInfos.Add(detailInfo);
}
///拉动单生成后需要调用拉动仓储衔接函数获取语句
@string.AppendLine(MaterialPullingCommonBLL.Handler(materialPulling, loginUser));
}
#endregion
#region 提前拉动 TWD
var twdCartGroups = cartGroups.Where(d => d.Key.PullMode == (int)PullModeConstants.Pcs || d.Key.PullMode == (int)PullModeConstants.Twd).ToList();
///TWD计数器
List <TwdCounterInfo> twdCounterInfos = new TwdCounterBLL().GetList("" +
"[STATUS] =" + (int)BasicDataStatusConstants.Enable + " and " +
"[PART_PULL_FID] in ('" + string.Join("','", maintainInhouseLogisticStandardInfos.Select(d => d.Fid).ToArray()) + "') and " +
"isnull([CURRENT_QTY],0) > 0", string.Empty);
///TWD零件类
List <TwdPartBoxInfo> twdPartBoxInfos = new TwdPartBoxBLL().GetList("" +
"[STATUS] =" + (int)BasicDataStatusConstants.Enable + " and " +
"[PART_BOX_CODE] in ('" + string.Join("','", twdCartGroups.Select(d => d.Key.PartBoxCode).ToArray()) + "')", string.Empty);
foreach (var twdCartGroup in twdCartGroups)
{
///从参数集合从提取对应的紧急拉动购物车集合
List <EmergencyPullingCartInfo> pullingCartInfos = emergencyPullingCartInfos.Where(d =>
d.PullMode == twdCartGroup.Key.PullMode && d.PartBoxCode == twdCartGroup.Key.PartBoxCode).ToList();
if (pullingCartInfos.Count == 0)
{
continue;
}
///TWD零件类
TwdPartBoxInfo twdPartBoxInfo = twdPartBoxInfos.FirstOrDefault(d => d.PartBoxCode == twdCartGroup.Key.PartBoxCode);
if (twdPartBoxInfo == null)
{
continue;
}
///触发层级拉动的集合
List <EmergencyPullingCartInfo> pullingLevelCartInfos = pullingCartInfos.Where(d => d.TriggerPullFlag == true).ToList();
foreach (EmergencyPullingCartInfo pullingLevelCartInfo in pullingLevelCartInfos)
{
///需要根据其物料拉动信息外键获取对应的计数器数据（状态必须为已启用）
TwdCounterInfo twdCounterInfo = twdCounterInfos.FirstOrDefault(d =>
d.PartPullFid == pullingLevelCartInfo.LogisticStandardFid.GetValueOrDefault() &&
d.Status == (int)BasicDataStatusConstants.Enable);
if (twdCounterInfo == null)
{
continue;
}
///在此之前需要根据物料图号、供应商、层级仓库、层级存储区在物料拉动信息中获取匹配的目标仓库、目标存储区数据
MaintainInhouseLogisticStandardInfo maintainInhouseLogisticStandardInfo = maintainInhouseLogisticStandardInfos.FirstOrDefault(d =>
d.PartNo == pullingLevelCartInfo.PartNo &&
d.SupplierNum == pullingLevelCartInfo.SupplierNum &&
d.WmNo == pullingLevelCartInfo.TriggerWmNo &&
d.ZoneNo == pullingLevelCartInfo.TriggerZoneNo);
///触发层级拉动
@string.AppendFormat(TwdCounterBLL.LevelPullCounter(maintainInhouseLogisticStandardInfo, pullingLevelCartInfo.RequiredPartQty.GetValueOrDefault(), loginUser, twdCounterInfo.Fid.GetValueOrDefault(), twdPartBoxInfo));
}
///提前拉动的集合
List <EmergencyPullingCartInfo> advancePullCartInfos = pullingCartInfos.Where(d =>
d.TriggerPullFlag == false && d.EmergencyPullMode == (int)EmergencyPullModeConstants.AdvancePull).ToList();
if (advancePullCartInfos.Count == 0)
{
continue;
}
///仓储衔接主表
MaterialPullingOrderInfo materialPulling = MaterialPullingCommonBLL.CreateMaterialPullingOrderInfo();
///TWD拉动单主表
TwdPullOrderInfo twdPullOrderInfo = TwdPullOrderBLL.CreateTwdPullOrderInfo(loginUser);
///TwdPartBoxInfo -> TwdPullOrderInfo
TwdPullOrderBLL.GetTwdPullOrderInfo(twdPartBoxInfo, ref twdPullOrderInfo);
///TWD拉动单主表sql
@string.AppendLine(TwdPullOrderDAL.GetInsertSql(twdPullOrderInfo));
///TwdPullOrderInfo-->MaterialPullingOrderInfo
MaterialPullingCommonBLL.GetMaterialPullingOrderInfo(twdPullOrderInfo, ref materialPulling);
int rowNo = 0; ///行号
///逐条循环每个购物车
foreach (EmergencyPullingCartInfo advancePullCartInfo in advancePullCartInfos)
{
///需要根据其物料拉动信息外键获取对应的计数器数据（状态必须为已启用）
///TT_MPM_TWD_COUNTER TWD计数器
TwdCounterInfo twdCounterInfo = twdCounterInfos.FirstOrDefault(d =>
d.PartPullFid == advancePullCartInfo.LogisticStandardFid.GetValueOrDefault() &&
d.Status == (int)BasicDataStatusConstants.Enable);
if (twdCounterInfo == null)
{
continue;
}
///物料拉动信息
MaintainInhouseLogisticStandardInfo maintainInhouseLogisticStandardInfo = maintainInhouseLogisticStandardInfos.FirstOrDefault(d => d.Fid == advancePullCartInfo.LogisticStandardFid);
if (maintainInhouseLogisticStandardInfo == null)
{
continue;
}
///物料包装数量在此需要根据单包装数量以及物料需求数量进行向上圆整计算
///REQUIRED_BOX_QTY:物料包装数量 PULL_PACKAGE_QTY:单包装数量 REQUIRED_PART_QTY:物料需求数量
if (advancePullCartInfo.PullPackageQty.GetValueOrDefault() == 0)
{
continue; ///O不能做被除数
}
advancePullCartInfo.RequiredBoxQty = Convert.ToInt32(Math.Ceiling(advancePullCartInfo.RequiredPartQty.GetValueOrDefault() / advancePullCartInfo.PullPackageQty.GetValueOrDefault()));
///若该系统配置标记为false时、计数器当前累计数量不允许小于购物车物料需求数量，
if (allowedFlag.ToLower() == "false" && twdCounterInfo.CurrentQty.GetValueOrDefault() < advancePullCartInfo.RequiredPartQty.GetValueOrDefault())
{
continue;
}
///仓储衔接明细表
MaterialPullingOrderDetailInfo detailInfo = MaterialPullingCommonBLL.CreateMaterialPullingOrderDetailInfo();
///TWD明细表
TwdPullOrderDetailInfo pullOrderDetailInfo = TwdPullOrderDetailBLL.CreateTwdPullOrderDetailInfo(loginUser);
///MaintainInhouseLogisticStandardInfo -> TwdPullOrderDetailInfo
TwdPullOrderDetailBLL.GetTwdPullOrderDetailInfo(maintainInhouseLogisticStandardInfo, ref pullOrderDetailInfo);
///TwdPullOrderInfo -> TwdPullOrderDetailInfo
TwdPullOrderDetailBLL.GetTwdPullOrderDetailInfo(twdPullOrderInfo, ref pullOrderDetailInfo);
///ROW_NO,行号
pullOrderDetailInfo.RowNo = ++rowNo;
///REQUIRED_PACKAGE_QTY,需求包装数
pullOrderDetailInfo.RequiredPackageQty = advancePullCartInfo.RequiredBoxQty.GetValueOrDefault();
///REQUIRED_PART_QTY,需求物料数量
pullOrderDetailInfo.RequiredPartQty = advancePullCartInfo.RequiredPartQty.GetValueOrDefault();
///TWD明细表sql
@string.AppendLine(TwdPullOrderDetailDAL.GetInsertSql(pullOrderDetailInfo));
///TwdPullOrderDetailInfo -> MaterialPullingOrderDetailInfo
MaterialPullingCommonBLL.GetMaterialPullingOrderDetailInfo(pullOrderDetailInfo, ref detailInfo);
///仓储衔接集合Add
materialPulling.MaterialPullingOrderDetailInfos.Add(detailInfo);
///否则直接对计数器的当前累计数量按购物车物料需求数量进行扣减
@string.AppendLine("update [LES].[TT_MPM_TWD_COUNTER] " +
"set [CURRENT_QTY] = isnull([CURRENT_QTY],0) - " + advancePullCartInfo.RequiredPartQty.GetValueOrDefault() + "," +
"[MODIFY_DATE] = GETDATE()," +
"[MODIFY_USER] = N'" + loginUser + "' " +
"where [ID]= " + twdCounterInfo.Id + ";");
///同时记录计数器日志并标记其类型为提前拉动
TwdCounterLogInfo twdCounterLogInfo = TwdCounterLogBLL.CreateTwdCounterLogInfo(twdCounterInfo.Fid.GetValueOrDefault(), loginUser);
///TwdCounterInfo -> TwdCounterLogInfo
TwdCounterLogBLL.GetTwdCounterLogInfo(twdCounterInfo, ref twdCounterLogInfo);
///PART_QTY,物料数量
twdCounterLogInfo.PartQty = 0 - advancePullCartInfo.RequiredPartQty.GetValueOrDefault();
///SOURCE_DATA,目视来源数据
twdCounterLogInfo.SourceData = twdPullOrderInfo.OrderCode;
///SOURCE_DATA_FID,数据来源外键
twdCounterLogInfo.SourceDataFid = twdPullOrderInfo.Fid;
///SOURCE_DATA_TYPE,数据来源类型
twdCounterLogInfo.SourceDataType = (int)TwdCounterSourceDataTypeConstants.AdvancePull;
///计数器日志sql
@string.AppendLine(TwdCounterLogDAL.GetInsertSql(twdCounterLogInfo));
}
///拉动单生成后需要调用拉动仓储衔接函数获取语句
@string.AppendLine(MaterialPullingCommonBLL.Handler(materialPulling, loginUser));
}
#endregion
return(@string.ToString());
}
/// <summary>
///
/// </summary>
/// <param name="jisPartBoxInfo"></param>
/// <param name="jisCounterInfo"></param>
/// <param name="vehiclePointStatusInfo"></param>
/// <param name="maintainInhouseLogisticStandardInfo"></param>
/// <param name="currentQty"></param>
/// <returns></returns>
private string UpdateJisCounter(JisPartBoxInfo jisPartBoxInfo, JisCounterInfo jisCounterInfo, VehiclePointStatusInfo vehiclePointStatusInfo, MaintainInhouseLogisticStandardInfo maintainInhouseLogisticStandardInfo, decimal currentQty)
{
///创建计数器日志
JisCounterLogInfo jisCounterLogInfo = JisCounterLogBLL.CreateJisCounterLogInfo(jisCounterInfo.Fid.GetValueOrDefault(), loginUser);
///以车辆过点信息填充计数器日志
JisCounterLogBLL.GetJisCounterLogInfo(vehiclePointStatusInfo, ref jisCounterLogInfo);
///以零件类信息填充计数器日志
JisCounterLogBLL.GetJisCounterLogInfo(jisPartBoxInfo, ref jisCounterLogInfo);
///以物料拉动信息填充计数器日志
JisCounterLogBLL.GetJisCounterLogInfo(maintainInhouseLogisticStandardInfo, ref jisCounterLogInfo);
///PART_QTY
jisCounterLogInfo.PartQty = currentQty;
///
return(JisCounterLogDAL.GetInsertSql(jisCounterLogInfo));
}
/// <summary>
/// JIS
/// </summary>
/// <param name="vehiclePointStatusInfo"></param>
/// <param name="jisPartBoxInfos"></param>
/// <param name="jisCounterInfos"></param>
/// <param name="jisMaintainInhouseLogisticStandardInfos"></param>
/// <returns></returns>
private string JisCounterDeal(VehiclePointStatusInfo vehiclePointStatusInfo, List <JisPartBoxInfo> jisPartBoxInfos, List <MaintainInhouseLogisticStandardInfo> jisMaintainInhouseLogisticStandardInfos)
{
///
StringBuilder stringBuilder = new StringBuilder();
///根据车辆状态信息中的生产订单号①获取到对应的生产订单物料清单、此处为了保障执行效率，需要根据已获取的物料拉动信息过滤获取物料清单
List <PullOrderBomInfo> pullOrderBomInfos = new PullOrderBomBLL().GetList("" +
"[ZORDNO] = N'" + vehiclePointStatusInfo.OrderNo + "' and " +
"[ZCOMNO] in ('" + string.Join("','", jisMaintainInhouseLogisticStandardInfos.Select(d => d.PartNo).ToArray()) + "')", string.Empty);
if (pullOrderBomInfos.Count == 0)
{
return(string.Empty);
}
///
foreach (JisPartBoxInfo jisPartBoxInfo in jisPartBoxInfos)
{
///不是这个信息点的零件类忽略
if (vehiclePointStatusInfo.StatusPointCode != jisPartBoxInfo.StatusPointCode)
{
continue;
}
///根据物料拉动信息外键获取计数器，未能成功获取时需要创建
JisCounterInfo jisCounterInfo = new JisCounterBLL().GetInfoByPartBoxFid(jisPartBoxInfo.Fid.GetValueOrDefault());
if (jisCounterInfo == null)
{
jisCounterInfo = CreateJisCounterInfo(jisPartBoxInfo);
}
///零件类对应的物料拉动信息
List <MaintainInhouseLogisticStandardInfo> maintainInhouseLogisticStandards = jisMaintainInhouseLogisticStandardInfos.Where(d => d.InhousePartClass == jisPartBoxInfo.PartBoxCode).ToList();
if (maintainInhouseLogisticStandards.Count == 0)
{
continue;
}
///零件类过滤后的物料拉动信息对应的物料清单
List <PullOrderBomInfo> pullOrderBoms = pullOrderBomInfos.Where(d => maintainInhouseLogisticStandards.Select(m => m.PartNo).Contains(d.Zcomno)).ToList();
if (pullOrderBoms.Count == 0)
{
continue;
}
///当排序计数器的累计方式⑧为按车辆累计时
if (jisPartBoxInfo.AccumulativeType.GetValueOrDefault() == (int)JisAccumulativeTypeConstants.VehicleAccumulative)
{
///本次可累计车辆数量
decimal vehicleQty = jisCounterInfo.AccumulativeQty.GetValueOrDefault() - jisCounterInfo.CurrentQty.GetValueOrDefault();
int vehicleCounterStatus = (int)JisCounterStatusConstants.Accumulating;
if (vehicleQty == 1)
{
vehicleCounterStatus = (int)JisCounterStatusConstants.AccumulativeCompletion;
}
///
stringBuilder.AppendLine(UpdateJisCounter(jisPartBoxInfo, jisCounterInfo, 1, vehicleCounterStatus));
}
///
foreach (PullOrderBomInfo pullOrderBom in pullOrderBoms)
{
///匹配物料拉动信息的最小维度是 物料图号+供应商+工位，依次降低维度来获取唯一的物料拉动信息
MaintainInhouseLogisticStandardInfo maintainInhouseLogisticStandard = maintainInhouseLogisticStandards.FirstOrDefault(d =>
d.PartNo == pullOrderBom.Zcomno && d.SupplierNum == pullOrderBom.SupplierNum && d.Location == pullOrderBom.Zloc);
///物料图号+供应商
if (maintainInhouseLogisticStandard == null)
{
maintainInhouseLogisticStandard = maintainInhouseLogisticStandards.FirstOrDefault(d => d.PartNo == pullOrderBom.Zcomno && d.SupplierNum == pullOrderBom.SupplierNum);
}
///物料图号
if (maintainInhouseLogisticStandard == null)
{
maintainInhouseLogisticStandard = maintainInhouseLogisticStandards.FirstOrDefault(d => d.PartNo == pullOrderBom.Zcomno);
}
///未能成功获取到正确的物料拉动信息
if (maintainInhouseLogisticStandard == null)
{
continue;
}
///当排序计数器的累计方式⑧为按车辆累计时
if (jisPartBoxInfo.AccumulativeType.GetValueOrDefault() == (int)JisAccumulativeTypeConstants.VehicleAccumulative)
{
stringBuilder.AppendLine(UpdateJisCounter(jisPartBoxInfo, jisCounterInfo, vehiclePointStatusInfo, maintainInhouseLogisticStandard, pullOrderBom.Zqty.GetValueOrDefault()));
}
///当排序计数器的累计方式⑧为按器具累计时
if (jisPartBoxInfo.AccumulativeType.GetValueOrDefault() == (int)JisAccumulativeTypeConstants.UtensilAccumulative)
{
///物料需求数量
decimal requireQty = pullOrderBom.Zqty.GetValueOrDefault();
while (requireQty > 0)
{
int jisCounterStatus = (int)JisCounterStatusConstants.Accumulating;
///本次可累计数量
decimal currentQty = jisCounterInfo.AccumulativeQty.GetValueOrDefault() - jisCounterInfo.CurrentQty.GetValueOrDefault();
if (currentQty == 0)
{
break;
}
///需求大于本次可累计
if (currentQty <= requireQty)
{
///剩余需累计数量
requireQty -= currentQty;
///累计完成
jisCounterStatus = (int)JisCounterStatusConstants.AccumulativeCompletion;
}
else
{
///将需求赋予本次
currentQty = requireQty;
///需求清空
requireQty = 0;
}
///
stringBuilder.AppendLine(UpdateJisCounter(jisPartBoxInfo, jisCounterInfo, currentQty, jisCounterStatus));
///
stringBuilder.AppendLine(UpdateJisCounter(jisPartBoxInfo, jisCounterInfo, vehiclePointStatusInfo, maintainInhouseLogisticStandard, currentQty));
///当剩余需求数量大于零时，需要创建计数器
if (requireQty > 0)
{
jisCounterInfo = CreateJisCounterInfo(jisPartBoxInfo);
}
}
}
///触发层级拉动
stringBuilder.AppendLine(TwdCounterBLL.LevelPullRequirementCounter(
maintainInhouseLogisticStandard,
pullOrderBom.Zqty.GetValueOrDefault(),
loginUser,
jisCounterInfo.Fid.GetValueOrDefault(),
jisCounterInfo.PartBoxCode));
}
}
return(stringBuilder.ToString());
}
/// <summary>
/// TWD
/// </summary>
/// <param name="vehiclePointStatusInfo"></param>
/// <param name="twdCounterInfos"></param>
/// <param name="twdMaintainInhouseLogisticStandardInfos"></param>
/// <returns></returns>
private string TwdCounterDeal(VehiclePointStatusInfo vehiclePointStatusInfo, List <TwdPartBoxInfo> twdPartBoxInfos, List <MaintainInhouseLogisticStandardInfo> twdMaintainInhouseLogisticStandardInfos)
{
///
StringBuilder stringBuilder = new StringBuilder();
///根据车辆状态信息中的生产订单号①获取到对应的生产订单物料清单、此处为了保障执行效率，需要根据已获取的计数器的物料号⑩过滤获取物料清单
///ZORDNO = 生产订单号
///ZCOMNO = 物料图号
List <PullOrderBomInfo> pullOrderBomInfos = new PullOrderBomBLL().GetList("" +
"[ZORDNO] = N'" + vehiclePointStatusInfo.OrderNo + "' and " +
"[ZCOMNO] in ('" + string.Join("','", twdMaintainInhouseLogisticStandardInfos.Select(d => d.PartNo).ToArray()) + "')", string.Empty);
if (pullOrderBomInfos.Count == 0)
{
return(string.Empty);
}
///
foreach (TwdPartBoxInfo twdPartBoxInfo in twdPartBoxInfos)
{
///不是这个信息点的零件类忽略
if (vehiclePointStatusInfo.StatusPointCode != twdPartBoxInfo.StatusPointCode)
{
continue;
}
///本零件类对应的物料拉动信息
List <MaintainInhouseLogisticStandardInfo> maintainInhouseLogisticStandards = twdMaintainInhouseLogisticStandardInfos.Where(d => d.InhousePartClass == twdPartBoxInfo.PartBoxCode).ToList();
///若本零件类无物料拉动信息则返回
if (twdMaintainInhouseLogisticStandardInfos.Count == 0)
{
continue;
}
///零件类过滤后的物料拉动信息对应的物料清单
List <PullOrderBomInfo> pullOrderBoms = pullOrderBomInfos.Where(d => maintainInhouseLogisticStandards.Select(m => m.PartNo).Contains(d.Zcomno)).ToList();
///循环过滤后的物料清单
foreach (PullOrderBomInfo pullOrderBom in pullOrderBoms)
{
///匹配物料拉动信息的最小维度是 物料图号+供应商+工位，依次降低维度来获取唯一的物料拉动信息
MaintainInhouseLogisticStandardInfo maintainInhouseLogisticStandard = maintainInhouseLogisticStandards.FirstOrDefault(d =>
d.PartNo == pullOrderBom.Zcomno && d.SupplierNum == pullOrderBom.SupplierNum && d.Location == pullOrderBom.Zloc);
///物料图号+供应商
if (maintainInhouseLogisticStandard == null)
{
maintainInhouseLogisticStandard = maintainInhouseLogisticStandards.FirstOrDefault(d => d.PartNo == pullOrderBom.Zcomno && d.SupplierNum == pullOrderBom.SupplierNum);
}
///物料图号
if (maintainInhouseLogisticStandard == null)
{
maintainInhouseLogisticStandard = maintainInhouseLogisticStandards.FirstOrDefault(d => d.PartNo == pullOrderBom.Zcomno);
}
///未能成功获取到正确的物料拉动信息
if (maintainInhouseLogisticStandard == null)
{
continue;
}
///根据物料拉动信息外键获取计数器，未能成功获取时需要创建
TwdCounterInfo twdCounterInfo = TwdCounterBLL.GetInfoByPartPullFid(maintainInhouseLogisticStandard.Fid);
if (twdCounterInfo == null)
{
///创建计数器
twdCounterInfo = TwdCounterBLL.CreateTwdCounterInfo(loginUser);
///以物料拉动信息填充计数器
TwdCounterBLL.GetTwdCounterInfo(maintainInhouseLogisticStandard, ref twdCounterInfo);
///以零件类信息填充计数器
TwdCounterBLL.GetTwdCounterInfo(twdPartBoxInfo, ref twdCounterInfo);
///
twdCounterInfo.Id = new TwdCounterBLL().InsertInfo(twdCounterInfo);
if (twdCounterInfo.Id == 0)
{
throw new Exception("MC:0x00000453");///时间窗计数器创建失败
}
}
///计数器状态未处于启用
if (twdCounterInfo.Status != (int)BasicDataStatusConstants.Enable)
{
continue;
}
stringBuilder.AppendLine(TwdCounterBLL.UpdateTwdCounter(maintainInhouseLogisticStandard, twdPartBoxInfo, pullOrderBom.Zqty.GetValueOrDefault(), twdCounterInfo.Id, loginUser));
///创建计数器日志
TwdCounterLogInfo twdCounterLogInfo = TwdCounterLogBLL.CreateTwdCounterLogInfo(twdCounterInfo.Fid.GetValueOrDefault(), loginUser);
///以车辆过点信息填充计数器日志
TwdCounterLogBLL.GetTwdCounterLogInfo(vehiclePointStatusInfo, ref twdCounterLogInfo);
///以物料拉动信息填充计数器日志
TwdCounterLogBLL.GetTwdCounterLogInfo(maintainInhouseLogisticStandard, ref twdCounterLogInfo);
///以零件类信息填充计数器日志
TwdCounterLogBLL.GetTwdCounterLogInfo(twdPartBoxInfo, ref twdCounterLogInfo);
///PART_QTY
twdCounterLogInfo.PartQty = pullOrderBom.Zqty.GetValueOrDefault();
///
stringBuilder.AppendLine(TwdCounterLogDAL.GetInsertSql(twdCounterLogInfo));
///触发层级拉动
stringBuilder.AppendLine(TwdCounterBLL.LevelPullRequirementCounter(
maintainInhouseLogisticStandard,
pullOrderBom.Zqty.GetValueOrDefault(),
loginUser,
twdCounterInfo.Fid.GetValueOrDefault(),
twdCounterInfo.PartBoxCode));
}
}
return(stringBuilder.ToString());
}
/// <summary>
///
/// </summary>
/// <param name="info"></param>
/// <returns></returns>
public long InsertInfo(MaintainInhouseLogisticStandardInfo info)
{
///若拉动零件类⑥对应到生产线代码④，则所选工段代码⑤及工位代码⑥范围为该生产线下对应数据
///且工段代码⑤与工位代码⑥之间联动
///否则工段代码⑤可选范围为全部
///在数据保存时将工厂代码②、车间代码③、生产线代码④同时写入数据库
PartsBoxInfo partsBoxInfo = new PartsBoxDAL().GetInfoByPartBox(info.InhousePartClass);
if (partsBoxInfo == null)
{
throw new Exception("MC:0x00000225");///拉动零件类数据错误
}
info.Plant = partsBoxInfo.Plant;
info.Workshop = partsBoxInfo.Workshop;
info.AssemblyLine = partsBoxInfo.AssemblyLine;
///当所选拉动零件类⑥的拉动方式⑤为10时间窗且其配置为库存当量拉动时，MIN⑯和MAX⑰允许维护大于零的数据，且MIN⑯小于MAX⑰
if (int.Parse(info.InhouseSystemMode) == (int)PullModeConstants.Twd)///TODO:缺少库存当量拉动的判断，等TWD表结构
{
if (info.Min.GetValueOrDefault() > info.Max.GetValueOrDefault())
{
throw new Exception("MC:0x00000404");///MIN值必须小于MAX
}
}
///当其被选为是时，需要校验层级拉动仓库⑩、层级拉动存储区⑪为必选项
if (info.IsTriggerPull.GetValueOrDefault() == true)
{
if (string.IsNullOrEmpty(info.WmNo))
{
throw new Exception("MC:0x00000405");///层级拉动仓库不允许为空
}
if (string.IsNullOrEmpty(info.ZoneNo))
{
throw new Exception("MC:0x00000406");///层级拉动存储区不允许为空
}
}
///物料号①、拉动方式⑤、拉动零件类⑥、供应商代码⑦组合唯一
int cnt = dal.GetCounts(string.Format(@"[PART_NO] = N'{0}' and [INHOUSE_SYSTEM_MODE] = N'{1}' and [INHOUSE_PART_CLASS]= N'{2}' and [SUPPLIER_NUM] = N'{3}'", info.PartNo, info.InhouseSystemMode, info.InhousePartClass, info.SupplierNum));
if (cnt > 0)
{
throw new Exception("MC:0x00000407");///物料号、拉动方式、拉动零件类、供应商代码组合不唯一
}
///相同目标仓库存储区，同物料号同供应商，即使跨拉动方式也需要唯一
cnt = dal.GetCounts(string.Format(@"[PART_NO] = N'{0}' and [T_WM_NO] = N'{1}' and [T_ZONE_NO] = N'{2}' and [SUPPLIER_NUM] = N'{3}'", info.PartNo, info.SZoneNo, info.TZoneNo, info.SupplierNum));
if (cnt > 0)
{
throw new Exception("MC:0x00000408");///目标仓库、目标存储区、物料号、供应商组合不唯一
}
#region 板相关
///拉动方式为看板时看板环数必须大于等于一
if (int.Parse(info.InhouseSystemMode) == (int)PullModeConstants.Kanban)
{
if (info.KanbanCircleCnt.GetValueOrDefault() < 1)
{
throw new Exception("Err_:MC:0x00000307");///看板环数必须大于等于一
}
}
#endregion
return(dal.Add(info));
}
/// <summary>
/// 执行导入EXCEL数据
/// </summary>
/// <param name="dataTable"></param>
/// <param name="fieldNames"></param>
/// <returns></returns>
public bool ImportDataByExcel(DataTable dataTable, Dictionary <string, string> fieldNames, string loginUser)
{
List <MaintainInhouseLogisticStandardInfo> maintainInhouseLogisticStandardExcelInfos = CommonDAL.DatatableConvertToList <MaintainInhouseLogisticStandardInfo>(dataTable).ToList();
if (maintainInhouseLogisticStandardExcelInfos.Count == 0)
{
throw new Exception("MC:1x00000043");///数据格式不符合导入规范
}
///获取业务表中要变更的数据集合,准备对比
List <MaintainInhouseLogisticStandardInfo> maintainInhouseLogisticStandardInfos = new MaintainInhouseLogisticStandardDAL().GetListForInterfaceDataSync(maintainInhouseLogisticStandardExcelInfos.Select(d => d.PartNo).ToList());
List <MaintainPartsInfo> maintainPartsInfos = new MaintainPartsDAL().GetListForInterfaceDataSync(maintainInhouseLogisticStandardExcelInfos.Select(d => d.PartNo).ToList());
List <PartsStockInfo> partsStockInfos = new PartsStockDAL().GetListForInterfaceDataSync(maintainInhouseLogisticStandardExcelInfos.Select(d => d.PartNo).ToList());
List <PartsBoxInfo> partsBoxInfos = new PartsBoxDAL().GetList("", string.Empty);
///执行的SQL语句
string sql = string.Empty;
List <MaintainInhouseLogisticStandardInfo> standardInfos = new List <MaintainInhouseLogisticStandardInfo>();
fieldNames.Add("SWmNo", "S_WM_NO");
fieldNames.Add("SZoneNo", "S_ZONE_NO");
fieldNames.Add("TWmNo", "T_WM_NO");
fieldNames.Add("TZoneNo", "T_ZONE_NO");
fieldNames.Add("Plant", "PLANT");
fieldNames.Add("Workshop", "WORKSHOP");
fieldNames.Add("AssemblyLine", "ASSEMBLY_LINE");
List <string> fields = new List <string>(fieldNames.Keys);
///逐条处理中间表数据
foreach (var maintainInhouseLogisticStandardExcelInfo in maintainInhouseLogisticStandardExcelInfos)
{
///
MaintainPartsInfo maintainPartsInfo = maintainPartsInfos.FirstOrDefault(d => d.PartNo == maintainInhouseLogisticStandardExcelInfo.PartNo);
if (maintainPartsInfo == null)
{
throw new Exception("MC:0x00000224");///物料基础信息数据错误
}
maintainInhouseLogisticStandardExcelInfo.Status = (int)BasicDataStatusConstants.Created;
///物料简称、物料中文描述、物料英文描述由基础数据中同步
maintainInhouseLogisticStandardExcelInfo.PartCname = maintainPartsInfo.PartCname;
maintainInhouseLogisticStandardExcelInfo.PartEname = maintainPartsInfo.PartEname;
maintainInhouseLogisticStandardExcelInfo.PartNickname = maintainPartsInfo.PartNickname;
///
PartsBoxInfo partsBoxInfo = partsBoxInfos.FirstOrDefault(d => d.PullMode.ToString() == maintainInhouseLogisticStandardExcelInfo.InhouseSystemMode &&
d.BoxParts == maintainInhouseLogisticStandardExcelInfo.InhousePartClass);
if (partsBoxInfo == null)
{
throw new Exception("MC:0x00000225");///拉动零件类数据错误
}
maintainInhouseLogisticStandardExcelInfo.SWmNo = partsBoxInfo.SWmNo;
maintainInhouseLogisticStandardExcelInfo.SZoneNo = partsBoxInfo.SZoneNo;
maintainInhouseLogisticStandardExcelInfo.TWmNo = partsBoxInfo.TWmNo;
maintainInhouseLogisticStandardExcelInfo.TZoneNo = partsBoxInfo.TZoneNo;
maintainInhouseLogisticStandardExcelInfo.Plant = partsBoxInfo.Plant;
maintainInhouseLogisticStandardExcelInfo.Workshop = partsBoxInfo.Workshop;
maintainInhouseLogisticStandardExcelInfo.AssemblyLine = partsBoxInfo.AssemblyLine;
///目标地点
PartsStockInfo partsStockInfo = partsStockInfos.FirstOrDefault(d => d.PartNo == maintainInhouseLogisticStandardExcelInfo.PartNo &&
d.WmNo == maintainInhouseLogisticStandardExcelInfo.TWmNo &&
d.ZoneNo == maintainInhouseLogisticStandardExcelInfo.TZoneNo);
///无维护先后要求
if (partsStockInfo != null)
{
maintainInhouseLogisticStandardExcelInfo.InboundPackageModel = partsStockInfo.InboundPackageModel;
maintainInhouseLogisticStandardExcelInfo.InboundPackage = partsStockInfo.InboundPackage;
}
///当所选拉动零件类⑥的拉动方式⑤为10时间窗且其配置为库存当量拉动时，MIN⑯和MAX⑰允许维护大于零的数据，且MIN⑯小于MAX⑰
if (int.Parse(maintainInhouseLogisticStandardExcelInfo.InhouseSystemMode) == (int)PullModeConstants.Twd)///TODO:缺少库存当量拉动的判断，等TWD表结构
{
if (maintainInhouseLogisticStandardExcelInfo.Min.GetValueOrDefault() > maintainInhouseLogisticStandardExcelInfo.Max.GetValueOrDefault())
{
throw new Exception("MC:0x00000404");///MIN值必须小于MAX
}
}
if (maintainInhouseLogisticStandardExcelInfo.IsTriggerPull.GetValueOrDefault() == true)
{
if (string.IsNullOrEmpty(maintainInhouseLogisticStandardExcelInfo.WmNo))
{
throw new Exception("MC:0x00000405");///层级拉动仓库不允许为空
}
if (string.IsNullOrEmpty(maintainInhouseLogisticStandardExcelInfo.ZoneNo))
{
throw new Exception("MC:0x00000406");///层级拉动存储区不允许为空
}
}
///
MaintainInhouseLogisticStandardInfo maintainInhouseLogisticStandardInfo = maintainInhouseLogisticStandardInfos.FirstOrDefault(d =>
d.PartNo == maintainInhouseLogisticStandardExcelInfo.PartNo &&
d.InhouseSystemMode == maintainInhouseLogisticStandardExcelInfo.InhouseSystemMode &&
d.InhousePartClass == maintainInhouseLogisticStandardExcelInfo.InhousePartClass);
if (maintainInhouseLogisticStandardInfo == null)
{
if (string.IsNullOrEmpty(maintainInhouseLogisticStandardExcelInfo.PartNo) ||
string.IsNullOrEmpty(maintainInhouseLogisticStandardExcelInfo.InhouseSystemMode) ||
string.IsNullOrEmpty(maintainInhouseLogisticStandardExcelInfo.InhousePartClass))
{
throw new Exception("MC:0x00000226");///物料号、拉动模式、零件类为必填项
}
///相同目标仓库存储区，同物料号同供应商，即使跨拉动方式也需要唯一
int cnt = maintainInhouseLogisticStandardInfos.Where(d =>
d.PartNo == maintainInhouseLogisticStandardExcelInfo.PartNo &&
d.TWmNo == maintainInhouseLogisticStandardExcelInfo.TWmNo &&
d.TZoneNo == maintainInhouseLogisticStandardExcelInfo.TZoneNo &&
d.SupplierNum == maintainInhouseLogisticStandardExcelInfo.SupplierNum).Count();
if (cnt > 0)
{
throw new Exception("MC:0x00000408");///物料号、拉动方式、拉动零件类、供应商代码组合不唯一
}
///物料号①、拉动方式⑤、拉动零件类⑥、供应商代码⑦组合唯一
cnt = maintainInhouseLogisticStandardInfos.Where(d =>
d.PartNo == maintainInhouseLogisticStandardExcelInfo.PartNo &&
d.InhouseSystemMode == maintainInhouseLogisticStandardExcelInfo.InhouseSystemMode &&
d.InhousePartClass == maintainInhouseLogisticStandardExcelInfo.InhousePartClass &&
d.SupplierNum == maintainInhouseLogisticStandardExcelInfo.SupplierNum).Count();
if (cnt > 0)
{
throw new Exception("MC:0x00000407");///物料号、拉动方式、拉动零件类、供应商代码组合不唯一
}
///字段
string insertFieldString = string.Empty;
///值
string insertValueString = string.Empty;
for (int i = 0; i < fields.Count; i++)
{
string valueStr = CommonDAL.GetFieldValueForSql <MaintainInhouseLogisticStandardInfo>(maintainInhouseLogisticStandardExcelInfo, fields[i]);
if (string.IsNullOrEmpty(valueStr))
{
throw new Exception("MC:1x00000043");///数据格式不符合导入规范
}
insertFieldString += "[" + fieldNames[fields[i]] + "],";
insertValueString += valueStr + ",";
}
sql += "if not exists (select * from LES.TM_BAS_MAINTAIN_INHOUSE_LOGISTIC_STANDARD with(nolock) "
+ "where [PART_NO] = N'" + maintainInhouseLogisticStandardExcelInfo.PartNo + "' and [INHOUSE_SYSTEM_MODE] = N'" + maintainInhouseLogisticStandardExcelInfo.InhouseSystemMode + "' and [INHOUSE_PART_CLASS] = N'" + maintainInhouseLogisticStandardExcelInfo.InhousePartClass + "' and [VALID_FLAG] = 1) "
+ "insert into [LES].[TM_BAS_MAINTAIN_INHOUSE_LOGISTIC_STANDARD] ("
+ "[FID],"
+ insertFieldString
+ "[CREATE_USER],"
+ "[CREATE_DATE],"
+ "[VALID_FLAG]"
+ ") values ("
+ "NEWID()," ///FID
+ insertValueString
+ "N'" + loginUser + "'," ///CREATE_USER
+ "GETDATE()," ///CREATE_DATE
+ "1" ///VALID_FLAG
+ ");";
maintainInhouseLogisticStandardInfos.Add(maintainInhouseLogisticStandardExcelInfo);
continue;
}
///
if (string.IsNullOrEmpty(maintainInhouseLogisticStandardExcelInfo.PartNo) ||
string.IsNullOrEmpty(maintainInhouseLogisticStandardExcelInfo.InhouseSystemMode) ||
string.IsNullOrEmpty(maintainInhouseLogisticStandardExcelInfo.InhousePartClass))
{
throw new Exception("MC:0x00000226");///物料号、拉动模式、零件类为必填项
}
///相同目标仓库存储区，同物料号同供应商，即使跨拉动方式也需要唯一
int count = maintainInhouseLogisticStandardInfos.Where(d =>
d.PartNo == maintainInhouseLogisticStandardExcelInfo.PartNo &&
d.TWmNo == maintainInhouseLogisticStandardExcelInfo.TWmNo &&
d.TZoneNo == maintainInhouseLogisticStandardExcelInfo.TZoneNo &&
d.SupplierNum == maintainInhouseLogisticStandardExcelInfo.SupplierNum &&
d.Id != maintainInhouseLogisticStandardInfo.Id).Count();
if (count > 0)
{
throw new Exception("MC:0x00000408");///物料号、拉动方式、拉动零件类、供应商代码组合不唯一
}
///物料号①、拉动方式⑤、拉动零件类⑥、供应商代码⑦组合唯一
count = maintainInhouseLogisticStandardInfos.Where(d =>
d.PartNo == maintainInhouseLogisticStandardExcelInfo.PartNo &&
d.InhouseSystemMode == maintainInhouseLogisticStandardExcelInfo.InhouseSystemMode &&
d.InhousePartClass == maintainInhouseLogisticStandardExcelInfo.InhousePartClass &&
d.SupplierNum == maintainInhouseLogisticStandardExcelInfo.SupplierNum &&
d.Id != maintainInhouseLogisticStandardInfo.Id).Count();
if (count > 0)
{
throw new Exception("MC:0x00000407");///物料号、拉动方式、拉动零件类、供应商代码组合不唯一
}
///值
string valueString = string.Empty;
for (int i = 0; i < fields.Count; i++)
{
string valueStr = CommonDAL.GetFieldValueForSql <MaintainInhouseLogisticStandardInfo>(maintainInhouseLogisticStandardExcelInfo, fields[i]);
if (string.IsNullOrEmpty(valueStr))
{
throw new Exception("MC:1x00000043");///数据格式不符合导入规范
}
valueString += "[" + fieldNames[fields[i]] + "] = " + valueStr + ",";
}
sql += "update [LES].[TM_BAS_MAINTAIN_INHOUSE_LOGISTIC_STANDARD] set "
+ valueString
+ "[MODIFY_USER] = N'" + loginUser + "',"
+ "[MODIFY_DATE] = GETDATE() "
+ "where [ID] = " + maintainInhouseLogisticStandardInfo.Id + ";";
}
///
if (string.IsNullOrEmpty(sql))
{
return(false);
}
return(CommonDAL.ExecuteNonQueryBySql(sql));
}
/// <summary>
/// 生成拉动单
/// </summary>
/// <param name="twdPartBoxInfo"></param>
/// <param name="twdWindowTimeInfo"></param>
/// <param name="supplierInfo"></param>
/// <param name="twdCounterInfos"></param>
/// <param name="maintainInhouseLogisticStandardInfos"></param>
/// <returns></returns>
private string CreateTwdPullOrder(List <TwdCounterInfo> twdCounterInfos, TwdPartBoxInfo twdPartBoxInfo, List <SupplierInfo> supplierInfos, TwdWindowTimeInfo twdWindowTimeInfo,
List <MaintainInhouseLogisticStandardInfo> maintainInhouseLogisticStandardInfos)
{
///
StringBuilder @string = new StringBuilder();
///Create TwdPullOrderInfo
TwdPullOrderInfo twdPullOrderInfo = null;
///Create PcsPullOrderInfo
PcsPullOrderInfo pcsPullOrderInfo = null;
///仓储衔接主表
MaterialPullingOrderInfo materialPulling = MaterialPullingCommonBLL.CreateMaterialPullingOrderInfo();
if (twdPartBoxInfo.TwdPullMode.GetValueOrDefault() == (int)TwdPullModeConstants.Pcs)
{
pcsPullOrderInfo = PcsPullOrderBLL.CreatePcsPullOrderInfo(loginUser);
///TwdWindowTimeInfo -> PcsPullOrderInfo
PcsPullOrderBLL.GetPcsPullOrderInfo(twdWindowTimeInfo, ref pcsPullOrderInfo);
///TwdPartBoxInfo -> PcsPullOrderInfo
PcsPullOrderBLL.GetPcsPullOrderInfo(twdPartBoxInfo, ref pcsPullOrderInfo);
///SupplierInfo -> PcsPullOrderInfo
SupplierInfo supplierInfo = supplierInfos.FirstOrDefault(d => d.SupplierNum == twdPartBoxInfo.SupplierNum);
PcsPullOrderBLL.GetPcsPullOrderInfo(supplierInfo, ref pcsPullOrderInfo);
///
@string.AppendLine(PcsPullOrderDAL.GetInsertSql(pcsPullOrderInfo));
///PcsPullOrderInfo -> MaterialPullingOrderInfo
MaterialPullingCommonBLL.GetMaterialPullingOrderInfo(pcsPullOrderInfo, ref materialPulling);
}
else
{
twdPullOrderInfo = TwdPullOrderBLL.CreateTwdPullOrderInfo(loginUser);
///TwdWindowTimeInfo -> TwdPullOrderInfo
TwdPullOrderBLL.GetTwdPullOrderInfo(twdWindowTimeInfo, ref twdPullOrderInfo);
///TwdPartBoxInfo -> TwdPullOrderInfo
TwdPullOrderBLL.GetTwdPullOrderInfo(twdPartBoxInfo, ref twdPullOrderInfo);
///SupplierInfo -> TwdPullOrderInfo
SupplierInfo supplierInfo = supplierInfos.FirstOrDefault(d => d.SupplierNum == twdPartBoxInfo.SupplierNum);
TwdPullOrderBLL.GetTwdPullOrderInfo(supplierInfo, ref twdPullOrderInfo);
///
@string.AppendLine(TwdPullOrderDAL.GetInsertSql(twdPullOrderInfo));
///TwdPullOrderInfo -> MaterialPullingOrderInfo
MaterialPullingCommonBLL.GetMaterialPullingOrderInfo(twdPullOrderInfo, ref materialPulling);
}
///行号
int rowNo = 0;
///循环计数器
foreach (TwdCounterInfo twdCounterInfo in twdCounterInfos)
{
///物料需求数量
decimal requiredPartQty = 0;
///物料需求箱数
int packageQty = 0;
#region 圆整方式
///向上圆整
if (twdCounterInfo.RoundnessMode == (int)RoundnessModeConstants.Upward)
{
if (twdCounterInfo.Package.GetValueOrDefault() > 0)
{
///根据计数器中的圆整方式⑨，当圆整方式⑨为20.向上时以Math.Ceiling(当前计数⑮/箱内数量⑯)*箱内数量⑯作为本次的物料需求数量
requiredPartQty = Math.Ceiling(twdCounterInfo.CurrentQty.GetValueOrDefault() / twdCounterInfo.Package.GetValueOrDefault()) * twdCounterInfo.Package.GetValueOrDefault();
packageQty = Convert.ToInt32(Math.Ceiling(requiredPartQty / twdCounterInfo.Package.GetValueOrDefault()));
}
}
///向下圆整
if (twdCounterInfo.RoundnessMode == (int)RoundnessModeConstants.Downward)
{
if (twdCounterInfo.Package.GetValueOrDefault() > 0)
{
///根据计数器中的圆整方式⑨，当圆整方式⑨为20.向上时以Math.Ceiling(当前计数⑮/箱内数量⑯)*箱内数量⑯作为本次的物料需求数量
requiredPartQty = Math.Floor(twdCounterInfo.CurrentQty.GetValueOrDefault() / twdCounterInfo.Package.GetValueOrDefault()) * twdCounterInfo.Package.GetValueOrDefault();
packageQty = Convert.ToInt32(Math.Ceiling(requiredPartQty / twdCounterInfo.Package.GetValueOrDefault()));
}
}
///按需求数量
if (twdCounterInfo.RoundnessMode == (int)RoundnessModeConstants.Ondemand)
{
///当圆整方式⑨为按需时则当前计数⑮直接作为本次的物料需求数量
requiredPartQty = twdCounterInfo.CurrentQty.GetValueOrDefault();
packageQty = Convert.ToInt32(Math.Ceiling(requiredPartQty / twdCounterInfo.Package.GetValueOrDefault()));
}
#endregion
///获取物料拉动信息
MaintainInhouseLogisticStandardInfo logisticStandardInfo = maintainInhouseLogisticStandardInfos.FirstOrDefault(d => d.Fid == twdCounterInfo.PartPullFid.GetValueOrDefault());
if (logisticStandardInfo == null)
{
continue;
}
///若计数器对应的物料拉动信息中最小起订包装数为一个大于零的数字，则需要在此处比对物料需求箱数是否大于等于最小起订包装数，若不满足则不产生拉动
if (logisticStandardInfo.MinPullBox.GetValueOrDefault() > 0 && packageQty < logisticStandardInfo.MinPullBox.GetValueOrDefault())
{
continue;
}
///若计数器对应的物料拉动信息中批量包装数为一个大于零的数字，则需要Math.Floor(物料需求箱数 / 批量包装数) * 批量包装数，作为新的物料需求箱数，同时* 箱内数量⑯获得新的物料需求数量
if (logisticStandardInfo.BatchPullBox.GetValueOrDefault() > 0 && twdCounterInfo.Package.GetValueOrDefault() > 0)
{
packageQty = Convert.ToInt32(Math.Ceiling(Convert.ToDecimal(packageQty) / logisticStandardInfo.BatchPullBox.GetValueOrDefault())) * logisticStandardInfo.BatchPullBox.GetValueOrDefault();
requiredPartQty = packageQty * twdCounterInfo.Package.GetValueOrDefault();
}
///仓储衔接明细表
MaterialPullingOrderDetailInfo detailInfo = MaterialPullingCommonBLL.CreateMaterialPullingOrderDetailInfo();
if (twdPartBoxInfo.TwdPullMode.GetValueOrDefault() == (int)TwdPullModeConstants.Pcs)
{
///
PcsPullOrderDetailInfo pullOrderDetailInfo = PcsPullOrderDetailBLL.CreatePcsPullOrderDetailInfo(loginUser);
///MaintainInhouseLogisticStandardInfo -> TwdPullOrderDetailInfo
PcsPullOrderDetailBLL.GetPcsPullOrderDetailInfo(logisticStandardInfo, ref pullOrderDetailInfo);
///TwdPullOrderInfo -> TwdPullOrderDetailInfo
PcsPullOrderDetailBLL.GetPcsPullOrderDetailInfo(pcsPullOrderInfo, ref pullOrderDetailInfo);
///ROW_NO,行号
pullOrderDetailInfo.RowNo = ++rowNo;
///REQUIRED_PACKAGE_QTY,需求包装数
pullOrderDetailInfo.RequiredPackageQty = packageQty;
///REQUIRED_PART_QTY,需求物料数量
pullOrderDetailInfo.RequiredPartQty = requiredPartQty;
///
@string.AppendLine(PcsPullOrderDetailDAL.GetInsertSql(pullOrderDetailInfo));
///TwdPullOrderDetailInfo -> MaterialPullingOrderDetailInfo
MaterialPullingCommonBLL.GetMaterialPullingOrderDetailInfo(pullOrderDetailInfo, ref detailInfo);
}
else
{
///
TwdPullOrderDetailInfo pullOrderDetailInfo = TwdPullOrderDetailBLL.CreateTwdPullOrderDetailInfo(loginUser);
///MaintainInhouseLogisticStandardInfo -> TwdPullOrderDetailInfo
TwdPullOrderDetailBLL.GetTwdPullOrderDetailInfo(logisticStandardInfo, ref pullOrderDetailInfo);
///TwdPullOrderInfo -> TwdPullOrderDetailInfo
TwdPullOrderDetailBLL.GetTwdPullOrderDetailInfo(twdPullOrderInfo, ref pullOrderDetailInfo);
///ROW_NO,行号
pullOrderDetailInfo.RowNo = ++rowNo;
///REQUIRED_PACKAGE_QTY,需求包装数
pullOrderDetailInfo.RequiredPackageQty = packageQty;
///REQUIRED_PART_QTY,需求物料数量
pullOrderDetailInfo.RequiredPartQty = requiredPartQty;
///
@string.AppendLine(TwdPullOrderDetailDAL.GetInsertSql(pullOrderDetailInfo));
///TwdPullOrderDetailInfo -> MaterialPullingOrderDetailInfo
MaterialPullingCommonBLL.GetMaterialPullingOrderDetailInfo(pullOrderDetailInfo, ref detailInfo);
}
///
materialPulling.MaterialPullingOrderDetailInfos.Add(detailInfo);
#region 扣减计数器
///最后根据物料需求数量扣减对应的计数器的当前计数⑮
@string.AppendLine("update [LES].[TT_MPM_TWD_COUNTER] " +
"set [CURRENT_QTY] = isnull([CURRENT_QTY],0) - " + requiredPartQty + "," +
"[MODIFY_DATE] = GETDATE()," +
"[MODIFY_USER] = N'" + loginUser + "' " +
"where [ID]= " + twdCounterInfo.Id + ";");
///
TwdCounterLogInfo twdCounterLogInfo = TwdCounterLogBLL.CreateTwdCounterLogInfo(twdCounterInfo.Fid.GetValueOrDefault(), loginUser);
///TwdCounterInfo -> TwdCounterLogInfo
TwdCounterLogBLL.GetTwdCounterLogInfo(twdCounterInfo, ref twdCounterLogInfo);
///PART_QTY,物料数量
twdCounterLogInfo.PartQty = 0 - requiredPartQty;
///SOURCE_DATA,目视来源数据
twdCounterLogInfo.SourceData = twdPullOrderInfo.OrderCode;
///SOURCE_DATA_FID,数据来源外键
twdCounterLogInfo.SourceDataFid = twdPullOrderInfo.Fid;
///SOURCE_DATA_TYPE,数据来源类型
twdCounterLogInfo.SourceDataType = (int)TwdCounterSourceDataTypeConstants.CreateRunsheet;
///
@string.AppendLine(TwdCounterLogDAL.GetInsertSql(twdCounterLogInfo));
#endregion
}
///更新时间窗窗口时间为已发单状态
@string.AppendLine("update [LES].[TT_MPM_TWD_WINDOW_TIME] " +
"set [SEND_TIME_STATUS]= " + (int)SendTimeStatusConstants.Sent + "," +
"[MODIFY_DATE] = GETDATE()," +
"[MODIFY_USER] = N'" + loginUser + "' " +
"where [ID]= " + twdWindowTimeInfo.Id + ";");
///拉动单生成后需要调用拉动仓储衔接函数获取语句
@string.AppendLine(MaterialPullingCommonBLL.Handler(materialPulling, loginUser));
return(@string.ToString());
}
/// <summary>
/// 层级拉动
/// </summary>
/// <param name="maintainInhouseLogisticStandardInfo"></param>
/// <param name="requireQty"></param>
/// <param name="loginUser"></param>
/// <param name="counterFid"></param>
/// <param name="partBoxCode"></param>
/// <returns></returns>
public static string LevelPullCounter(MaintainInhouseLogisticStandardInfo maintainInhouseLogisticStandardInfo, decimal requireQty, string loginUser, Guid counterFid, TwdPartBoxInfo twdPartBoxInfo)
{
///未能成功获取零件类信息
if (twdPartBoxInfo == null)
{
return(string.Empty);
}
///零件类未启用
if (twdPartBoxInfo.Status.GetValueOrDefault() != (int)BasicDataStatusConstants.Enable)
{
return(string.Empty);
}
///根据物料拉动信息外键获取计数器，未能成功获取时需要创建
TwdCounterInfo twdCounterInfo = new TwdCounterDAL().GetInfoByPartPullFid(maintainInhouseLogisticStandardInfo.Fid.GetValueOrDefault());
if (twdCounterInfo == null)
{
///创建计数器
twdCounterInfo = CreateTwdCounterInfo(loginUser);
///以物料拉动信息填充计数器
GetTwdCounterInfo(maintainInhouseLogisticStandardInfo, ref twdCounterInfo);
///以零件类信息填充计数器
GetTwdCounterInfo(twdPartBoxInfo, ref twdCounterInfo);
///
twdCounterInfo.Id = new TwdCounterDAL().Add(twdCounterInfo);
if (twdCounterInfo.Id == 0)
{
throw new Exception("MC:0x00000453");///时间窗计数器创建失败
}
}
///计数器状态未处于启用
if (twdCounterInfo.Status != (int)BasicDataStatusConstants.Enable)
{
return(string.Empty);
}
///
StringBuilder stringBuilder = new StringBuilder();
///
stringBuilder.AppendLine(UpdateTwdCounter(maintainInhouseLogisticStandardInfo, twdPartBoxInfo, requireQty, twdCounterInfo.Id, loginUser));
///创建计数器日志
TwdCounterLogInfo twdCounterLogInfo = TwdCounterLogBLL.CreateTwdCounterLogInfo(twdCounterInfo.Fid.GetValueOrDefault(), loginUser);
///以物料拉动信息填充计数器日志
TwdCounterLogBLL.GetTwdCounterLogInfo(maintainInhouseLogisticStandardInfo, ref twdCounterLogInfo);
///以零件类信息填充计数器日志
TwdCounterLogBLL.GetTwdCounterLogInfo(twdPartBoxInfo, ref twdCounterLogInfo);
///PART_QTY
twdCounterLogInfo.PartQty = requireQty;
///SOURCE_DATA_FID
twdCounterLogInfo.SourceDataFid = counterFid;
///SOURCE_DATA_TYPE
twdCounterLogInfo.SourceDataType = (int)TwdCounterSourceDataTypeConstants.Calculator;
///SOURCE_DATA
twdCounterLogInfo.SourceData = twdPartBoxInfo.PartBoxCode;
///
stringBuilder.AppendLine(TwdCounterLogDAL.GetInsertSql(twdCounterLogInfo));
///触发层级拉动
stringBuilder.AppendLine(LevelPullCounter(
maintainInhouseLogisticStandardInfo,
requireQty,
loginUser,
twdCounterInfo.Fid.GetValueOrDefault(),
twdPartBoxInfo));
return(stringBuilder.ToString());
}
/// <summary>
/// 批量创建看板卡
/// </summary>
/// <param name="rowsKeyValues"></param>
/// <param name="loginUser"></param>
/// <returns></returns>
public bool BatchcreationInfos(List <string> rowsKeyValues, string loginUser)
{
///已选定的看板卡
var kanbanCardInfofirst = dal.GetList("[ID] in (" + string.Join(",", rowsKeyValues.ToArray()) + ")", string.Empty).GroupBy(w => new { w.PartNo, w.PartBoxCode }).Select(w => new { w.Key.PartNo, w.Key.PartBoxCode });
var kanbanCardInfosecend = dal.GetList(
"[PART_NO] IN ('" + string.Join("','", kanbanCardInfofirst.GroupBy(w => new { w.PartNo }).Select(w => w.Key.PartNo).ToArray()) + "')"
+ "AND [PART_BOX_CODE] IN ('" + string.Join("','", kanbanCardInfofirst.GroupBy(w => new { w.PartBoxCode }).Select(w => w.Key.PartBoxCode).ToArray()) + "')"
, string.Empty);
List <KanbanCardInfo> kanbanCardInfos = (from a in kanbanCardInfosecend
join b in kanbanCardInfofirst on new { a.PartNo, a.PartBoxCode } equals new { b.PartNo, b.PartBoxCode }
select a).ToList <KanbanCardInfo>();
if (kanbanCardInfos.Where(w => w.Status == (int)BasicDataStatusConstants.Disabled).Count() > 0)
{
throw new Exception("MC:0x00000242");///只能批量添加已创建或已启用状态的看板卡
}
///选定看板卡对应的零件类
List <KanbanPartBoxInfo> kanbanPartBoxInfos = new KanbanPartBoxDAL().GetList(
string.Format("[PART_BOX_CODE] in ('{0}')", string.Join("','", kanbanCardInfos.GroupBy(w => new { w.PartBoxCode }).Select(w => w.Key.PartBoxCode).ToArray()))
, string.Empty);
if (kanbanPartBoxInfos.Count == 0)
{
throw new Exception("MC:3x00000014");///看板零件类数据错误
}
///已看板卡对应的物料拉动信息
List <MaintainInhouseLogisticStandardInfo> maintainInhouseLogisticStandardInfos
= new MaintainInhouseLogisticStandardDAL().GetList("[PART_NO] in ('" + string.Join("','", kanbanCardInfos.GroupBy(w => new { w.PartNo }).Select(w => w.Key.PartNo).ToArray()) + "') "
+ "and [INHOUSE_PART_CLASS] in ('" + string.Join("','", kanbanPartBoxInfos.Select(d => d.PartBoxCode).ToArray()) + "') "
+ "and [STATUS] = " + (int)BasicDataStatusConstants.Enable + " "
+ "and [INHOUSE_SYSTEM_MODE] = N'" + (int)PullModeConstants.Kanban + "'", string.Empty);
if (maintainInhouseLogisticStandardInfos.Count == 0)
{
throw new Exception("MC:0x00000213");///物料拉动信息数据错误
}
StringBuilder sqlBuilder = new StringBuilder();
#region 板卡插入脚本
string sqlstr = @"insert into [LES].[TM_MPM_KANBAN_CARD] (
FID,
CARD_NO,
PART_BOX_CODE,
PART_BOX_NAME,
PART_NO,
PART_NAME,
SUPPLIER_CODE,
SUPPLIER_NAME,
PART_QTY,
PACKAGE_CODE,
STATUS,
PRINT_CNT,
PRINT_TIME,
PRINT_USER,
USED_STATUS,
SCANNED_USER,
SCANNED_DATE,
VALID_FLAG,
CREATE_DATE,
CREATE_USER,
MODIFY_DATE,
MODIFY_USER
) values ({0});" ;
#endregion
foreach (var kanbanCardInfo in kanbanCardInfos.GroupBy(w => new { w.PartNo, w.PartBoxCode }).Select(w => new { w.Key.PartBoxCode, w.Key.PartNo, SumCount = w.Count() }))
{
int eachcount = 0;
MaintainInhouseLogisticStandardInfo info = maintainInhouseLogisticStandardInfos.FirstOrDefault(w => w.PartNo == kanbanCardInfo.PartNo && w.InhousePartClass == kanbanCardInfo.PartBoxCode);
if (info != null)
{
eachcount = (info.KanbanCircleCnt ?? 0) - kanbanCardInfo.SumCount;
}
if (eachcount > 0)
{
for (int i = 0; i < eachcount; i++)
{
var kanbanpartboxinfo = kanbanPartBoxInfos.FirstOrDefault(w => w.PartBoxCode == kanbanCardInfo.PartBoxCode);
string sqlKanbanPullOrderDetailValue = "NEWID()"///FID
+ ",N'" + new SeqDefineDAL().GetCurrentCode("KANBAN_CARD_NO", "HOSPITAL") + "'"
+ ",N'" + kanbanCardInfo.PartBoxCode + "'"
+ ",N'" + kanbanpartboxinfo.PartBoxName + "'"
+ ",N'" + info.PartNo + "'"
+ ",N'" + info.PartCname + "'"
+ ",N'" + info.SupplierNum + "'"
+ ",N'" + kanbanCardInfos.FirstOrDefault(w => w.SupplierCode == info.SupplierNum).SupplierName + "'"///供应商名称
+ "," + info.InboundPackage.GetValueOrDefault()
+ ",N'" + info.InboundPackageModel + "'"
+ "," + (int)BasicDataStatusConstants.Enable
+ ",null"
+ ",null"
+ ",null"
+ ",10"
+ ",null"
+ ",null"
+ ",1" ///VALID_FLAG
+ ",GETDATE()" ///CREATE_DATE
+ ",N'" + loginUser + "'" ///CREATE_USER
+ ",null"
+ ",null";
sqlBuilder.AppendLine(string.Format(sqlstr, sqlKanbanPullOrderDetailValue));
}
}
}
if (sqlBuilder.Length == 0)
{
throw new Exception("MC:0x00000243");
}
sqlBuilder.AppendLine("SELECT @@IDENTITY;");
///数据保存时使用SQL拼接多条insert语句方式一次提交执行，执行失败需要同步返回至客户端
using (TransactionScope trans = new TransactionScope())
{
if (!CommonDAL.ExecuteNonQueryBySql(sqlBuilder.ToString()))
{
throw new Exception("MC:0x00000244");
}
trans.Complete();
}
return(true);
}
/// <summary>
/// 获取层级拉动需求累计语句
/// </summary>
/// <param name="maintainInhouseLogisticStandardInfo"></param>
/// <param name="requireQty"></param>
/// <param name="loginUser"></param>
/// <param name="counterFid"></param>
/// <param name="partBoxCode"></param>
/// <returns></returns>
public static string LevelPullRequirementCounter(MaintainInhouseLogisticStandardInfo maintainInhouseLogisticStandardInfo, decimal requireQty, string loginUser, Guid counterFid, string partBoxCode)
{
///当物料拉动信息中的是否层级拉动标记 =False或未设置时函数直接返回空
if (!maintainInhouseLogisticStandardInfo.IsTriggerPull.GetValueOrDefault())
{
return(string.Empty);
}
///根据物料拉动信息中的层级拉动仓库存储区以及物料号、供应商获取物料拉动信息表中目标仓库存储区对应的物料号、供应商数据
List <MaintainInhouseLogisticStandardInfo> maintainInhouseLogisticStandardInfos = new MaintainInhouseLogisticStandardDAL().GetList("" +
"[T_WM_NO] = N'" + maintainInhouseLogisticStandardInfo.WmNo + "' and " +
"[T_ZONE_NO] = N'" + maintainInhouseLogisticStandardInfo.ZoneNo + "' and " +
"[PART_NO] = N'" + maintainInhouseLogisticStandardInfo.PartNo + "' and " +
"[STATUS] = " + (int)BasicDataStatusConstants.Enable + " and " +
"[INHOUSE_SYSTEM_MODE] = N'" + (int)PullModeConstants.Twd + "'", string.Empty);
///若获取不成功则将供应商条件去除重新获取，此处在程序执行时可以先根据物料号获取，再过滤供应商
MaintainInhouseLogisticStandardInfo maintainInhouseLogisticStandard = maintainInhouseLogisticStandardInfos.FirstOrDefault(d => d.SupplierNum == maintainInhouseLogisticStandardInfo.SupplierNum);
if (maintainInhouseLogisticStandard == null)
{
maintainInhouseLogisticStandardInfo = maintainInhouseLogisticStandardInfos.FirstOrDefault();
}
///未能成功获取物料拉动信息
if (maintainInhouseLogisticStandard == null)
{
return(string.Empty);
}
///获取零件类信息
TwdPartBoxInfo twdPartBoxInfo = new TwdPartBoxDAL().GetInfo(maintainInhouseLogisticStandard.InhousePartClass);
///未能成功获取零件类信息
if (twdPartBoxInfo == null)
{
return(string.Empty);
}
///零件类未启用
if (twdPartBoxInfo.Status.GetValueOrDefault() != (int)BasicDataStatusConstants.Enable)
{
return(string.Empty);
}
///根据物料拉动信息外键获取计数器，未能成功获取时需要创建
TwdCounterInfo twdCounterInfo = new TwdCounterDAL().GetInfoByPartPullFid(maintainInhouseLogisticStandard.Fid.GetValueOrDefault());
if (twdCounterInfo == null)
{
///创建计数器
twdCounterInfo = CreateTwdCounterInfo(loginUser);
///以物料拉动信息填充计数器
GetTwdCounterInfo(maintainInhouseLogisticStandard, ref twdCounterInfo);
///以零件类信息填充计数器
GetTwdCounterInfo(twdPartBoxInfo, ref twdCounterInfo);
///
twdCounterInfo.Id = new TwdCounterDAL().Add(twdCounterInfo);
if (twdCounterInfo.Id == 0)
{
throw new Exception("MC:0x00000453");///时间窗计数器创建失败
}
}
///计数器状态未处于启用
if (twdCounterInfo.Status != (int)BasicDataStatusConstants.Enable)
{
return(string.Empty);
}
///
StringBuilder stringBuilder = new StringBuilder();
///
stringBuilder.AppendLine(UpdateTwdCounter(maintainInhouseLogisticStandard, twdPartBoxInfo, requireQty, twdCounterInfo.Id, loginUser));
///创建计数器日志
TwdCounterLogInfo twdCounterLogInfo = TwdCounterLogBLL.CreateTwdCounterLogInfo(twdCounterInfo.Fid.GetValueOrDefault(), loginUser);
///以物料拉动信息填充计数器日志
TwdCounterLogBLL.GetTwdCounterLogInfo(maintainInhouseLogisticStandard, ref twdCounterLogInfo);
///以零件类信息填充计数器日志
TwdCounterLogBLL.GetTwdCounterLogInfo(twdPartBoxInfo, ref twdCounterLogInfo);
///PART_QTY
twdCounterLogInfo.PartQty = requireQty;
///SOURCE_DATA_FID
twdCounterLogInfo.SourceDataFid = counterFid;
///SOURCE_DATA_TYPE
twdCounterLogInfo.SourceDataType = (int)TwdCounterSourceDataTypeConstants.Calculator;
///SOURCE_DATA
twdCounterLogInfo.SourceData = partBoxCode;
///
stringBuilder.AppendLine(TwdCounterLogDAL.GetInsertSql(twdCounterLogInfo));
///触发层级拉动
stringBuilder.AppendLine(LevelPullRequirementCounter(
maintainInhouseLogisticStandard,
requireQty,
loginUser,
twdCounterInfo.Fid.GetValueOrDefault(),
twdCounterInfo.PartBoxCode));
return(stringBuilder.ToString());
}
/// <summary>
/// 执行导入EXCEL数据
/// </summary>
/// <param name="dataTable"></param>
/// <param name="fieldNames"></param>
/// <returns></returns>
public bool ImportDataByExcel(DataTable dataTable, Dictionary <string, string> fieldNames, string loginUser)
{
List <TwdCounterInfo> twdCounterExcelInfos = CommonDAL.DatatableConvertToList <TwdCounterInfo>(dataTable).ToList();
if (twdCounterExcelInfos.Count == 0)
{
throw new Exception("MC:1x00000043");///数据格式不符合导入规范
}
List <TwdCounterInfo> twdCounterInfos = dal.GetList("" +
"[PART_BOX_CODE] in ('" + string.Join("','", twdCounterExcelInfos.Select(d => d.PartBoxCode).ToArray()) + "') and " +
"[PART_NO] in ('" + string.Join("','", twdCounterExcelInfos.Select(d => d.PartNo).ToArray()) + "') and " +
"[PACKAGE_MODEL] in ('" + string.Join("','", twdCounterExcelInfos.Select(d => d.PackageModel).ToArray()) + "')", string.Empty);
List <MaintainInhouseLogisticStandardInfo> maintainInhouseLogisticStandardInfos = new MaintainInhouseLogisticStandardDAL().GetList("" +
"[INHOUSE_SYSTEM_MODE] = N'" + (int)PullModeConstants.Twd + "' and " +
"[INHOUSE_PART_CLASS] in ('" + string.Join("','", twdCounterExcelInfos.Select(d => d.PartBoxCode).ToArray()) + "') and " +
"[PART_NO] in ('" + string.Join("','", twdCounterExcelInfos.Select(d => d.PartNo).ToArray()) + "')", string.Empty);
///获取零件类信息
List <TwdPartBoxInfo> twdPartBoxInfos = new TwdPartBoxDAL().GetList("" +
"[PART_BOX_CODE] in ('" + string.Join("','", twdCounterExcelInfos.Select(d => d.PartBoxCode).ToArray()) + "')", string.Empty);
StringBuilder @string = new StringBuilder();
foreach (TwdCounterInfo twdCounterExcelInfo in twdCounterExcelInfos)
{
/// 零件类代码②、工厂③车间⑤生产线⑥工段⑬工位⑭、物料号⑩、物料版本⑫、包装容器⑰为联合主键，差异数量DiffQty作为累加当前计数⑮的依据，备注直接更新
TwdCounterInfo twdCounterInfo = twdCounterInfos.FirstOrDefault(d =>
d.PartBoxCode == twdCounterExcelInfo.PartBoxCode &&
d.PartNo == twdCounterExcelInfo.PartNo &&
d.PackageModel == twdCounterExcelInfo.PackageModel &&
d.Plant == twdCounterExcelInfo.Plant &&
d.Workshop == twdCounterExcelInfo.Workshop &&
d.AssemblyLine == twdCounterExcelInfo.AssemblyLine &&
d.WorkshopSection == twdCounterExcelInfo.WorkshopSection &&
d.Location == twdCounterExcelInfo.Location &&
d.PartVersion == twdCounterExcelInfo.PartVersion);
#region 逐步减低维度处理
if (twdCounterInfo == null)
{
twdCounterInfo = twdCounterInfos.FirstOrDefault(d =>
d.PartBoxCode == twdCounterExcelInfo.PartBoxCode &&
d.PartNo == twdCounterExcelInfo.PartNo &&
d.PackageModel == twdCounterExcelInfo.PackageModel &&
d.Plant == twdCounterExcelInfo.Plant &&
d.Workshop == twdCounterExcelInfo.Workshop &&
d.AssemblyLine == twdCounterExcelInfo.AssemblyLine &&
d.WorkshopSection == twdCounterExcelInfo.WorkshopSection &&
d.Location == twdCounterExcelInfo.Location);
}
if (twdCounterInfo == null)
{
twdCounterInfo = twdCounterInfos.FirstOrDefault(d =>
d.PartBoxCode == twdCounterExcelInfo.PartBoxCode &&
d.PartNo == twdCounterExcelInfo.PartNo &&
d.PackageModel == twdCounterExcelInfo.PackageModel &&
d.Plant == twdCounterExcelInfo.Plant &&
d.Workshop == twdCounterExcelInfo.Workshop &&
d.AssemblyLine == twdCounterExcelInfo.AssemblyLine &&
d.WorkshopSection == twdCounterExcelInfo.WorkshopSection);
}
if (twdCounterInfo == null)
{
twdCounterInfo = twdCounterInfos.FirstOrDefault(d =>
d.PartBoxCode == twdCounterExcelInfo.PartBoxCode &&
d.PartNo == twdCounterExcelInfo.PartNo &&
d.PackageModel == twdCounterExcelInfo.PackageModel &&
d.Plant == twdCounterExcelInfo.Plant &&
d.Workshop == twdCounterExcelInfo.Workshop &&
d.AssemblyLine == twdCounterExcelInfo.AssemblyLine);
}
if (twdCounterInfo == null)
{
twdCounterInfo = twdCounterInfos.FirstOrDefault(d =>
d.PartBoxCode == twdCounterExcelInfo.PartBoxCode &&
d.PartNo == twdCounterExcelInfo.PartNo &&
d.PackageModel == twdCounterExcelInfo.PackageModel &&
d.Plant == twdCounterExcelInfo.Plant &&
d.Workshop == twdCounterExcelInfo.Workshop);
}
if (twdCounterInfo == null)
{
twdCounterInfo = twdCounterInfos.FirstOrDefault(d =>
d.PartBoxCode == twdCounterExcelInfo.PartBoxCode &&
d.PartNo == twdCounterExcelInfo.PartNo &&
d.PackageModel == twdCounterExcelInfo.PackageModel &&
d.Plant == twdCounterExcelInfo.Plant);
}
if (twdCounterInfo == null)
{
twdCounterInfo = twdCounterInfos.FirstOrDefault(d =>
d.PartBoxCode == twdCounterExcelInfo.PartBoxCode &&
d.PartNo == twdCounterExcelInfo.PartNo &&
d.PackageModel == twdCounterExcelInfo.PackageModel);
}
if (twdCounterInfo == null)
{
twdCounterInfo = twdCounterInfos.FirstOrDefault(d =>
d.PartBoxCode == twdCounterExcelInfo.PartBoxCode &&
d.PartNo == twdCounterExcelInfo.PartNo);
}
if (twdCounterInfo == null)
{
throw new Exception("MC:0x00000255");///数据格式不符合导入规范
}
#endregion
if (twdCounterInfo.Status.GetValueOrDefault() == (int)BasicDataStatusConstants.Disabled)
{
throw new Exception("MC:0x00000455");///计数器已作废不能修改数量
}
@string.AppendLine("update [LES].[TT_MPM_TWD_COUNTER] set " +
"[CURRENT_QTY] = isnull([CURRENT_QTY],0) + " + twdCounterExcelInfo.DiffQty + "," +
"[MODIFY_USER] = N'" + loginUser + "'," +
"[MODIFY_DATE] = GETDATE() where " +
"[ID] = " + twdCounterInfo.Id + ";");
///根据计数器的物料拉动信息外键获取物料拉动信息
MaintainInhouseLogisticStandardInfo maintainInhouseLogisticStandardInfo = maintainInhouseLogisticStandardInfos.FirstOrDefault(d => d.Fid == twdCounterInfo.PartPullFid.GetValueOrDefault());
if (maintainInhouseLogisticStandardInfo == null)
{
throw new Exception("MC:0x00000213");///物料拉动信息数据错误
}
if (maintainInhouseLogisticStandardInfo.Status.GetValueOrDefault() != (int)BasicDataStatusConstants.Enable)
{
throw new Exception("MC:0x00000233");///没有已启用的物料拉动信息
}
///获取零件类信息
TwdPartBoxInfo twdPartBoxInfo = twdPartBoxInfos.FirstOrDefault(d => d.PartBoxCode == maintainInhouseLogisticStandardInfo.InhousePartClass);
///未能成功获取零件类信息
if (twdPartBoxInfo == null)
{
throw new Exception("MC:0x00000225");///拉动零件类数据错误
}
///零件类未启用
if (twdPartBoxInfo.Status.GetValueOrDefault() != (int)BasicDataStatusConstants.Enable)
{
throw new Exception("MC:0x00000456");///零件类未启用
}
///创建计数器日志
TwdCounterLogInfo twdCounterLogInfo = TwdCounterLogBLL.CreateTwdCounterLogInfo(twdCounterInfo.Fid.GetValueOrDefault(), loginUser);
///以物料拉动信息填充计数器日志
TwdCounterLogBLL.GetTwdCounterLogInfo(maintainInhouseLogisticStandardInfo, ref twdCounterLogInfo);
///以零件类信息填充计数器日志
TwdCounterLogBLL.GetTwdCounterLogInfo(twdPartBoxInfo, ref twdCounterLogInfo);
///PART_QTY
twdCounterLogInfo.PartQty = twdCounterExcelInfo.DiffQty;
///SOURCE_DATA_FID
twdCounterLogInfo.SourceDataFid = twdCounterInfo.Fid;
///SOURCE_DATA_TYPE
twdCounterLogInfo.SourceDataType = (int)TwdCounterSourceDataTypeConstants.Manual;
///SOURCE_DATA
twdCounterLogInfo.SourceData = twdCounterInfo.PartBoxCode;
///Comments
twdCounterLogInfo.Comments = twdCounterExcelInfo.Comments;
///
@string.AppendLine(TwdCounterLogDAL.GetInsertSql(twdCounterLogInfo));
///触发层级拉动
@string.AppendLine(LevelPullRequirementCounter(
maintainInhouseLogisticStandardInfo,
twdCounterExcelInfo.DiffQty,
loginUser,
twdCounterInfo.Fid.GetValueOrDefault(),
twdCounterInfo.PartBoxCode));
}
///执行
using (var trans = new TransactionScope())
{
if (@string.Length == 0)
{
throw new Exception("MC:0x00000283");///没有可导入更新的数据
}
CommonDAL.ExecuteNonQueryBySql(@string.ToString());
trans.Complete();
}
///
return(true);
}
/// <summary>
/// Jis拉动
/// </summary>
/// <param name="jisPartBoxInfo"></param>
/// <param name="jisCounterInfo"></param>
/// <param name="jisCounterLogs"></param>
/// <param name="maintainInhouseLogistics"></param>
/// <param name="JisPullGuid"></param>
/// <param name="orderCode"></param>
/// <param name="pullOrdersInfos"></param>
/// <param name="isJis"></param>
/// <returns></returns>
public string JisPull(JisPartBoxInfo jisPartBoxInfo, JisCounterInfo jisCounterInfo, List <JisCounterLogInfo> jisCounterLogs, List <MaintainInhouseLogisticStandardInfo> maintainInhouseLogistics, List <PullOrdersInfo> pullOrdersInfos, bool isJis)
{
StringBuilder stringBuilder = new StringBuilder();
///拉动单Guid
Guid JisPullGuid = Guid.NewGuid();
///拉动单号
string orderCode = new SeqDefineBLL().GetCurrentCode("JIS_PULL_ORDER_CODE");
///单据衔接
MaterialPullingOrderInfo materialPullingOrderInfo = MaterialPullingCommonBLL.CreateMaterialPullingOrderInfo();
///jisPartBoxInfo -> MaterialPullingOrderInfo
MaterialPullingCommonBLL.GetJisMaterialPullingOrderInfo(jisPartBoxInfo, ref materialPullingOrderInfo);
///orderCode -> MaterialPullingOrderInfo
MaterialPullingCommonBLL.GetorderCodeMaterialPullingOrderInfo(orderCode, ref materialPullingOrderInfo);
foreach (JisCounterLogInfo jisCounterLog in jisCounterLogs)
{
///物料拉动信息
MaintainInhouseLogisticStandardInfo maintainInhouseLogisticStandardInfo = maintainInhouseLogistics.Where(d => d.PartNo == jisCounterLog.PartNo).FirstOrDefault();
if (maintainInhouseLogisticStandardInfo == null)
{
continue;
}
///生产订单信息
PullOrdersInfo pullOrdersInfo = pullOrdersInfos.FirstOrDefault(d => d.OrderNo == jisCounterLog.SourceData);
if (pullOrdersInfo == null)
{
continue;
}
///仓储衔接明细表
MaterialPullingOrderDetailInfo detailInfo = MaterialPullingCommonBLL.CreateMaterialPullingOrderDetailInfo();
///maintainInhouseLogisticStandardInfo -> MaterialPullingOrderDetailInfo
MaterialPullingCommonBLL.GetMainMaterialPullingOrderDetailInfo(maintainInhouseLogisticStandardInfo, jisCounterLog.PartQty.GetValueOrDefault(), ref detailInfo);
///jisPartBoxInfo-> MaterialPullingOrderDetailInfo
MaterialPullingCommonBLL.GetJisMaterialPullingOrderDetailInfo(jisPartBoxInfo, ref detailInfo);
///orderCode-> MaterialPullingOrderDetailInfo
MaterialPullingCommonBLL.GetOrderCodeMaterialPullingOrderDetailInfo(orderCode, ref detailInfo);
///pullOrdersInfo-> MaterialPullingOrderDetailInfo
MaterialPullingCommonBLL.GetPullOrderMaterialPullingOrderDetailInfo(pullOrdersInfo, ref detailInfo);
///Add
materialPullingOrderInfo.MaterialPullingOrderDetailInfos.Add(detailInfo);
if (isJis)
{
///排序拉动明细
stringBuilder.AppendFormat(CreateJisPullOrderDetailSql(JisPullGuid, materialPullingOrderInfo.MaterialPullingOrderDetailInfos));
}
else
{
///物料成套拉动明细
stringBuilder.AppendFormat(CreateCompletePullOrderDetailSql(JisPullGuid, materialPullingOrderInfo.MaterialPullingOrderDetailInfos));
}
if (stringBuilder.Length == 0)
{
continue;
}
}
if (isJis)
{
///开始车号
materialPullingOrderInfo.StartVehicheNo = materialPullingOrderInfo.MaterialPullingOrderDetailInfos.Min(d => d.DayVehicheSeqNo.GetValueOrDefault());
///结束车号
materialPullingOrderInfo.EndVehicheNo = materialPullingOrderInfo.MaterialPullingOrderDetailInfos.Max(d => d.DayVehicheSeqNo.GetValueOrDefault());
///排序拉动主表
stringBuilder.AppendFormat(CreateJisPullOrderSql(JisPullGuid, materialPullingOrderInfo));
}
else
{
///车辆编号
materialPullingOrderInfo.VehicheModelNo = materialPullingOrderInfo.MaterialPullingOrderDetailInfos.Select(d => d.VehicheModelNo).FirstOrDefault();
///生产订单号
materialPullingOrderInfo.OrderNo = materialPullingOrderInfo.MaterialPullingOrderDetailInfos.Select(d => d.OrderNo).FirstOrDefault();
///物料成套拉动主表
stringBuilder.AppendFormat(CreateCompletePullOrderSql(JisPullGuid, materialPullingOrderInfo));
}
///仓储衔接
stringBuilder.AppendFormat(MaterialPullingCommonBLL.Handler(materialPullingOrderInfo, loginUser));
return(stringBuilder.ToString());
}
