|
using DataAynchronization.HW.BLL;
|
using HH.WMS.Common;
|
using HH.WMS.Entitys.Algorithm;
|
using HH.WMS.Entitys.Autobom;
|
using HH.WMS.Entitys.Basic;
|
using HH.WMS.Entitys.Common;
|
using HH.WMS.Entitys.Func;
|
using HW.BLL;
|
using Newtonsoft.Json;
|
using System;
|
using System.Collections.Generic;
|
using System.ComponentModel;
|
using System.Data;
|
using System.Drawing;
|
using System.Linq;
|
using System.Text;
|
using System.Threading;
|
using System.Threading.Tasks;
|
using System.Windows.Forms;
|
|
namespace DataAynchronization
|
{
|
public partial class DataMove : Form
|
{
|
HH.WMS.Common.External.LogPara logPara;
|
public DataMove()
|
{
|
InitializeComponent();
|
}
|
private void DataMove_Load(object sender, EventArgs e)
|
{
|
try
|
{
|
string ToolName = System.Configuration.ConfigurationManager.AppSettings["ToolName"].ToString();
|
txt_ToolName.Text = ToolName;
|
}
|
catch (Exception)
|
{
|
txt_ToolName.Text = "… …";
|
}
|
timer1.Interval = 1000 * 10; //10秒
|
timer1.Enabled = true;
|
|
CheckForIllegalCrossThreadCalls = false;
|
|
|
runingPro = true;
|
DoTimerTickThread();
|
}
|
|
private Thread _thread;
|
private bool runingPro = false;//程序正在运行是跳过
|
|
private void btn_Move_Click(object sender, EventArgs e)
|
{
|
//runingPro = true;
|
//DoTimerTickThread();
|
}
|
|
private void DoTimerTickThread()
|
{
|
if (runingPro)
|
{
|
if (_thread != null && _thread.ThreadState != ThreadState.Stopped)
|
_thread.Abort();
|
|
_thread = new Thread(DoThread); //对照无值
|
_thread.Start();
|
}
|
}
|
|
|
private void DoThread()
|
{
|
logPara = HH.WMS.Common.External.LogType.LogPara("开始同步！");
|
try
|
{
|
btn_Move.Enabled = false;
|
btn_Move.Text = "正在同步…";
|
listBox1.Items.Clear();
|
|
|
TN_AB_ITEMBLL itemBll = new TN_AB_ITEMBLL();
|
TN_AB_B_SYNCH_LOGBLL synchLogBll = new TN_AB_B_SYNCH_LOGBLL();
|
|
//需要同步的数据
|
List<TN_AB_B_SYNCH_LOGEntity> synchDataList = synchLogBll.GetSynchDataList();
|
if (synchDataList.Count == 0)
|
{
|
Log("中间表暂无待同步数据，稍后再次检测……");
|
}
|
else
|
{
|
//需要删除的数据
|
List<TN_AB_B_SYNCH_LOGEntity> removeDataList = synchLogBll.GetRemoveDataList();
|
|
Log("中间表总共存在：" + removeDataList.Count + " 条需要删除的数据");
|
foreach (TableName item in Enum.GetValues(typeof(TableName)))
|
{
|
if (textBox1.Text != "")
|
{
|
if (item.ToString() != textBox1.Text)
|
{
|
continue;
|
}
|
}
|
//插入mongo成功标识
|
bool isOk = false;
|
bool flag = true;
|
switch (item.ToString())
|
{
|
#region //1、************************同步仓库表************************//
|
case "TN_AB_STOCK":
|
Log("TN_AB_STOCK");
|
TN_AB_STOCKBLL stockBll = new TN_AB_STOCKBLL();
|
List<TN_AB_B_SYNCH_LOGEntity> stockRemoveList = removeDataList.Where(o => o.CN_S_TABLE_NAME.Trim() == item.ToString()).ToList();
|
|
Log("中间表中：" + item.ToString() + "总共存在：" + stockRemoveList.Count + " 条需要删除的数据(状态4)");
|
if (stockRemoveList.Count > 0)
|
{
|
//根据获取的中间表已删除标识集合，删除Mongo数据
|
foreach (TN_AB_B_SYNCH_LOGEntity synchEntity in stockRemoveList)
|
{
|
if (!synchLogBll.RemoveDataByCode<TN_AB_STOCKEntity>(synchEntity.CN_S_GUID, "CN_GUID", item.ToString()))
|
{
|
flag = false;
|
break;
|
}
|
}
|
if (flag)
|
{
|
//将已删除的物料进行标识
|
SqlExecuteResult sr = synchLogBll.RemoveData(stockRemoveList, item.ToString());
|
if (sr.Success)
|
{
|
Log("中间表中：" + item.ToString() + " 需要删除的数据已全部删除");
|
}
|
else
|
{
|
Log("报错！报错！内容：" + sr.Exception.ToString());
|
}
|
}
|
}
|
List<TN_AB_STOCKEntity> stockList = stockBll.GetStockList(item.ToString());
|
Log("中间表中：" + item.ToString() + "总共存在：" + stockList.Count + " 条需要处理同步的数据(状态1，2)");
|
//插入mongo成功标识
|
for (int i = 0; i < stockList.Count; i++)
|
{
|
//判断当前是否已导入Mongo，如果已导入 则先删除Mongo中该条记录
|
if (synchLogBll.IsExistsMongo<TN_AB_STOCKEntity>(stockList[i].CN_S_STOCK_CODE, "CN_S_STOCK_CODE", item.ToString()))
|
{
|
Log("编码：" + stockList[i].CN_S_STOCK_CODE + " 在Mongo中已存在，先删除再新增");
|
synchLogBll.RemoveDataByCode<TN_AB_STOCKEntity>(stockList[i].CN_S_STOCK_CODE, "CN_S_STOCK_CODE", item.ToString());
|
}
|
}
|
isOk = synchLogBll.AddList(stockList, item.ToString());
|
Log("已成功向Mongo集合：" + item.ToString() + " 中插入：" + stockList.Count + " 条数据");
|
if (isOk)
|
{
|
SqlExecuteResult removeData = synchLogBll.RemoveSynchLogData(item.ToString());
|
Log("中间表中：表 " + item.ToString() + " 已处理完毕，已从中间表中删除");
|
}
|
break;
|
#endregion
|
|
#region //2、************************同步库区表************************//
|
case "TN_AB_B_STOCK_AREA":
|
Log("TN_AB_B_STOCK_AREA");
|
TN_AB_B_STOCK_AREABLL stockAreaBll = new TN_AB_B_STOCK_AREABLL();
|
List<TN_AB_B_SYNCH_LOGEntity> stockAreaRemoveList = removeDataList.Where(o => o.CN_S_TABLE_NAME.Trim() == item.ToString()).ToList();
|
Log("中间表中：" + item.ToString() + "总共存在：" + stockAreaRemoveList.Count + " 条需要删除的数据");
|
|
if (stockAreaRemoveList.Count > 0)
|
{
|
//根据获取的中间表已删除标识集合，删除Mongo数据
|
foreach (TN_AB_B_SYNCH_LOGEntity synchEntity in stockAreaRemoveList)
|
{
|
if (!synchLogBll.RemoveDataByCode<AutoBomStockAreaEntity>(synchEntity.CN_S_GUID, "CN_GUID", item.ToString()))
|
{
|
flag = false;
|
break;
|
}
|
}
|
if (flag)
|
{
|
//将已删除的进行标识
|
SqlExecuteResult sr = synchLogBll.RemoveData(stockAreaRemoveList, item.ToString());
|
if (sr.Success)
|
{
|
Log("中间表中：" + item.ToString() + " 需要删除的数据已全部删除");
|
}
|
else
|
{
|
Log("报错！报错！内容：" + sr.Exception.ToString());
|
}
|
}
|
}
|
List<AutoBomStockAreaEntity> stockAreaList = stockAreaBll.GetStockAreaMongoList(item.ToString());
|
Log("中间表中：" + item.ToString() + "总共存在：" + stockAreaList.Count + " 条需要处理同步的数据(状态1，2)");
|
|
for (int i = 0; i < stockAreaList.Count; i++)
|
{
|
//判断当前是否已导入Mongo，如果已导入 则先删除Mongo中该条记录
|
if (synchLogBll.IsExistsMongo<AutoBomStockAreaEntity>(stockAreaList[i].CN_S_AREA_CODE, "CN_S_AREA_CODE", item.ToString()))
|
{
|
Log("编码：" + stockAreaList[i].CN_S_AREA_CODE + " 在Mongo中已存在，先删除再新增");
|
synchLogBll.RemoveDataByCode<AutoBomStockAreaEntity>(stockAreaList[i].CN_S_AREA_CODE, "CN_S_AREA_CODE", item.ToString());
|
}
|
}
|
isOk = synchLogBll.AddList(stockAreaList, item.ToString());
|
Log("已成功向Mongo集合：" + item.ToString() + " 中插入：" + stockAreaList.Count + " 条数据");
|
if (isOk)
|
{
|
SqlExecuteResult removeData = synchLogBll.RemoveSynchLogData(item.ToString());
|
Log("中间表中：表 " + item.ToString() + " 已处理完毕，已从中间表中删除");
|
}
|
break;
|
#endregion
|
|
#region //3、************************同步货位表************************//
|
case "TN_AB_STOCK_LOCATION":
|
Log("TN_AB_STOCK_LOCATION");
|
TN_AB_STOCK_LOCATIONBLL stockLocationBll = new TN_AB_STOCK_LOCATIONBLL();
|
List<TN_AB_B_SYNCH_LOGEntity> stockLocationRemoveList = removeDataList.Where(o => o.CN_S_TABLE_NAME.Trim() == item.ToString()).ToList();
|
Log("中间表中：" + item.ToString() + "总共存在：" + stockLocationRemoveList.Count + " 条需要删除的数据(状态4)");
|
|
if (stockLocationRemoveList.Count > 0)
|
{
|
//根据获取的中间表已删除标识集合，删除Mongo数据
|
foreach (TN_AB_B_SYNCH_LOGEntity synchEntity in stockLocationRemoveList)
|
{
|
if (!synchLogBll.RemoveDataByCode<AutoBomLocationEntity>(synchEntity.CN_S_GUID, "CN_GUID", item.ToString()))
|
{
|
flag = false;
|
break;
|
}
|
}
|
if (flag)
|
{
|
//将已删除的进行标识
|
SqlExecuteResult sr = synchLogBll.RemoveData(stockLocationRemoveList, item.ToString());
|
if (sr.Success)
|
{
|
Log("中间表中：" + item.ToString() + " 需要删除的数据已全部删除");
|
}
|
else
|
{
|
Log("报错！报错！内容：" + sr.Exception.ToString());
|
}
|
}
|
|
//TODO 删除货位扩展表
|
}
|
List<AutoBomLocationEntity> stockLocationList = stockLocationBll.GetStockLocationList(item.ToString());//.Where(e=>!e.CN_S_STATUS.Equals("报废")).ToList();
|
Log("中间表中：" + item.ToString() + "总共存在：" + stockLocationList.Count + " 条需要处理同步的数据(状态1，2)");
|
|
//处理货位扩展表
|
if (ckb_locationext.Checked)
|
{
|
DoLocationExt(stockLocationList);
|
}
|
|
for (int i = 0; i < stockLocationList.Count; i++)
|
{
|
//判断当前是否已导入Mongo，如果已导入 则先删除Mongo中该条记录
|
if (synchLogBll.IsExistsMongo<AutoBomLocationEntity>(stockLocationList[i].CN_S_LOCATION_CODE, "CN_S_LOCATION_CODE", item.ToString()))
|
{
|
Log("编码：" + stockLocationList[i].CN_S_LOCATION_CODE + " 在Mongo中已存在，先删除再新增");
|
synchLogBll.RemoveDataByCode<AutoBomLocationEntity>(stockLocationList[i].CN_S_LOCATION_CODE, "CN_S_LOCATION_CODE", item.ToString());
|
}
|
}
|
isOk = synchLogBll.AddList(stockLocationList, item.ToString());
|
Log("已成功向Mongo集合：" + item.ToString() + " 中插入：" + stockLocationList.Count + " 条数据");
|
if (isOk)
|
{
|
SqlExecuteResult removeData = synchLogBll.RemoveSynchLogData(item.ToString());
|
Log("中间表中：表 " + item.ToString() + " 已处理完毕，已从中间表中删除");
|
}
|
|
break;
|
#endregion
|
|
#region //4、************************同步客户表************************//
|
case "TN_AB_CUSTOMER":
|
Log("TN_AB_CUSTOMER");
|
TN_AB_CUSTOMERBLL customBll = new TN_AB_CUSTOMERBLL();
|
List<TN_AB_B_SYNCH_LOGEntity> customRemoveList = removeDataList.Where(o => o.CN_S_TABLE_NAME.Trim() == item.ToString()).ToList();
|
Log("中间表中：" + item.ToString() + "总共存在：" + customRemoveList.Count + " 条需要删除的数据(状态4)");
|
|
if (customRemoveList.Count > 0)
|
{
|
//根据获取的中间表已删除标识集合，删除Mongo数据
|
foreach (TN_AB_B_SYNCH_LOGEntity synchEntity in customRemoveList)
|
{
|
if (!synchLogBll.RemoveDataByCode<TN_AB_CUSTOMEREntity>(synchEntity.CN_S_GUID, "CN_GUID", item.ToString()))
|
{
|
flag = false;
|
break;
|
}
|
}
|
if (flag)
|
{
|
//将已删除的进行标识
|
SqlExecuteResult sr = synchLogBll.RemoveData(customRemoveList, item.ToString());
|
if (sr.Success)
|
{
|
Log("中间表中：" + item.ToString() + " 需要删除的数据已全部删除");
|
}
|
else
|
{
|
Log("报错！报错！内容：" + sr.Exception.ToString());
|
}
|
}
|
}
|
List<TN_AB_CUSTOMEREntity> customList = customBll.GetCustomList(item.ToString());
|
Log("中间表中：" + item.ToString() + "总共存在：" + customList.Count + " 条需要处理同步的数据(状态1，2)");
|
|
for (int i = 0; i < customList.Count; i++)
|
{
|
//判断当前是否已导入Mongo，如果已导入 则先删除Mongo中该条记录
|
if (synchLogBll.IsExistsMongo<TN_AB_CUSTOMEREntity>(customList[i].CN_S_CUSTOMER_CODE, "CN_S_CUSTOMER_CODE", item.ToString()))
|
{
|
Log("编码：" + customList[i].CN_S_CUSTOMER_CODE + " 在Mongo中已存在，先删除再新增");
|
synchLogBll.RemoveDataByCode<TN_AB_CUSTOMEREntity>(customList[i].CN_S_CUSTOMER_CODE, "CN_S_CUSTOMER_CODE", item.ToString());
|
}
|
}
|
isOk = synchLogBll.AddList(customList, item.ToString());
|
Log("已成功向Mongo集合：" + item.ToString() + " 中插入：" + customList.Count + " 条数据");
|
if (isOk)
|
{
|
SqlExecuteResult removeData = synchLogBll.RemoveSynchLogData(item.ToString());
|
Log("中间表中：表 " + item.ToString() + " 已处理完毕，已从中间表中删除");
|
}
|
break;
|
#endregion
|
|
#region //5、***********************同步供应商表***********************//
|
case "TN_AB_SUPPLIER":
|
Log("TN_AB_SUPPLIER");
|
TN_AB_SUPPLIERBLL supplierBll = new TN_AB_SUPPLIERBLL();
|
List<TN_AB_B_SYNCH_LOGEntity> supplierRemoveList = removeDataList.Where(o => o.CN_S_TABLE_NAME.Trim() == item.ToString()).ToList();
|
Log("中间表中：" + item.ToString() + "总共存在：" + supplierRemoveList.Count + " 条需要删除的数据(状态4)");
|
|
if (supplierRemoveList.Count > 0)
|
{
|
//根据获取的中间表已删除标识集合，删除Mongo数据
|
foreach (TN_AB_B_SYNCH_LOGEntity synchEntity in supplierRemoveList)
|
{
|
if (!synchLogBll.RemoveDataByCode<TN_AB_SUPPLIEREntity>(synchEntity.CN_S_GUID, "CN_GUID", item.ToString()))
|
{
|
flag = false;
|
break;
|
}
|
}
|
if (flag)
|
{
|
//将已删除的进行标识
|
SqlExecuteResult sr = synchLogBll.RemoveData(supplierRemoveList, item.ToString());
|
if (sr.Success)
|
{
|
Log("中间表中：" + item.ToString() + " 需要删除的数据已全部删除");
|
}
|
else
|
{
|
Log("报错！报错！内容：" + sr.Exception.ToString());
|
}
|
}
|
}
|
List<TN_AB_SUPPLIEREntity> supplierList = supplierBll.GetSupplierList(item.ToString());
|
Log("中间表中：" + item.ToString() + "总共存在：" + supplierList.Count + " 条需要处理同步的数据(状态1，2)");
|
|
for (int i = 0; i < supplierList.Count; i++)
|
{
|
//判断当前是否已导入Mongo，如果已导入 则先删除Mongo中该条记录
|
if (synchLogBll.IsExistsMongo<TN_AB_SUPPLIEREntity>(supplierList[i].CN_S_VENDOR_CODE, "CN_S_VENDOR_CODE", item.ToString()))
|
{
|
Log("编码：" + supplierList[i].CN_S_VENDOR_CODE + " 在Mongo中已存在，先删除再新增");
|
synchLogBll.RemoveDataByCode<TN_AB_SUPPLIEREntity>(supplierList[i].CN_S_VENDOR_CODE, "CN_S_VENDOR_CODE", item.ToString());
|
}
|
}
|
isOk = synchLogBll.AddList(supplierList, item.ToString());
|
Log("已成功向Mongo集合：" + item.ToString() + " 中插入：" + supplierList.Count + " 条数据");
|
if (isOk)
|
{
|
SqlExecuteResult removeData = synchLogBll.RemoveSynchLogData(item.ToString());
|
Log("中间表中：表 " + item.ToString() + " 已处理完毕，已从中间表中删除");
|
}
|
break;
|
#endregion
|
|
#region //6、**********************同步编码规则表**********************//
|
case "TN_AB_B_NUMRULE":
|
Log("TN_AB_B_NUMRULE");
|
TN_AB_B_NUMRULEBLL numruleBll = new TN_AB_B_NUMRULEBLL();
|
List<TN_AB_B_SYNCH_LOGEntity> numruleRemoveList = removeDataList.Where(o => o.CN_S_TABLE_NAME.Trim() == item.ToString()).ToList();
|
Log("中间表中：" + item.ToString() + "总共存在：" + numruleRemoveList.Count + " 条需要删除的数据(状态4)");
|
|
if (numruleRemoveList.Count > 0)
|
{
|
//根据获取的中间表已删除标识集合，删除Mongo数据
|
foreach (TN_AB_B_SYNCH_LOGEntity synchEntity in numruleRemoveList)
|
{
|
if (!synchLogBll.RemoveDataByCode<TN_AB_B_NUMRULEEntity>(synchEntity.CN_S_GUID, "CN_GUID", item.ToString()))
|
{
|
flag = false;
|
break;
|
}
|
}
|
if (flag)
|
{
|
//将已删除的进行标识
|
SqlExecuteResult sr = synchLogBll.RemoveData(numruleRemoveList, item.ToString());
|
if (sr.Success)
|
{
|
Log("中间表中：" + item.ToString() + " 需要删除的数据已全部删除");
|
}
|
else
|
{
|
Log("报错！报错！内容：" + sr.Exception.ToString());
|
}
|
}
|
}
|
List<TN_AB_B_NUMRULEEntity> numruleList = numruleBll.GetNumRuleList(item.ToString());
|
Log("中间表中：" + item.ToString() + "总共存在：" + numruleList.Count + " 条需要处理同步的数据(状态1，2)");
|
|
for (int i = 0; i < numruleList.Count; i++)
|
{
|
//判断当前是否已导入Mongo，如果已导入 则先删除Mongo中该条记录
|
if (synchLogBll.IsExistsMongo<TN_AB_B_NUMRULEEntity>(numruleList[i].CN_S_RULE_NAME, "CN_S_RULE_NAME", item.ToString()))
|
{
|
Log("规则名称：" + numruleList[i].CN_S_RULE_NAME + " 在Mongo中已存在，先删除再新增");
|
synchLogBll.RemoveDataByCode<TN_AB_B_NUMRULEEntity>(numruleList[i].CN_S_RULE_NAME, "CN_S_RULE_NAME", item.ToString());
|
}
|
}
|
isOk = synchLogBll.AddList(numruleList, item.ToString());
|
Log("已成功向Mongo集合：" + item.ToString() + " 中插入：" + numruleList.Count + " 条数据");
|
if (isOk)
|
{
|
SqlExecuteResult removeData = synchLogBll.RemoveSynchLogData(item.ToString());
|
Log("中间表中：表 " + item.ToString() + " 已处理完毕，已从中间表中删除");
|
}
|
break;
|
#endregion
|
|
#region //7、**********************同步物流公司表**********************//
|
case "TN_AB_LOGISTICS":
|
Log("TN_AB_LOGISTICS");
|
TN_AB_LOGISTICSBLL logisticBll = new TN_AB_LOGISTICSBLL();
|
List<TN_AB_B_SYNCH_LOGEntity> logisticRemoveList = removeDataList.Where(o => o.CN_S_TABLE_NAME.Trim() == item.ToString()).ToList();
|
Log("中间表中：" + item.ToString() + "总共存在：" + logisticRemoveList.Count + " 条需要删除的数据(状态4)");
|
|
if (logisticRemoveList.Count > 0)
|
{
|
//根据获取的中间表已删除标识集合，删除Mongo数据
|
foreach (TN_AB_B_SYNCH_LOGEntity synchEntity in logisticRemoveList)
|
{
|
if (!synchLogBll.RemoveDataByCode<TN_AB_LOGISTICSEntity>(synchEntity.CN_S_GUID, "CN_GUID", item.ToString()))
|
{
|
flag = false;
|
break;
|
}
|
}
|
if (flag)
|
{
|
//将已删除的进行标识
|
SqlExecuteResult sr = synchLogBll.RemoveData(logisticRemoveList, item.ToString());
|
if (sr.Success)
|
{
|
Log("中间表中：" + item.ToString() + " 需要删除的数据已全部删除");
|
}
|
else
|
{
|
Log("报错！报错！内容：" + sr.Exception.ToString());
|
}
|
}
|
}
|
List<TN_AB_LOGISTICSEntity> logisticList = logisticBll.GetLogisticList(item.ToString());
|
Log("中间表中：" + item.ToString() + "总共存在：" + logisticList.Count + " 条需要处理同步的数据(状态1，2)");
|
|
for (int i = 0; i < logisticList.Count; i++)
|
{
|
//判断当前是否已导入Mongo，如果已导入 则先删除Mongo中该条记录
|
if (synchLogBll.IsExistsMongo<TN_AB_LOGISTICSEntity>(logisticList[i].CN_S_LOGISTICS_FLAG, "CN_S_LOGISTICS_FLAG", item.ToString()))
|
{
|
Log("物流名称：" + logisticList[i].CN_S_LOGISTICS_NAME + " 在Mongo中已存在，先删除再新增");
|
synchLogBll.RemoveDataByCode<TN_AB_LOGISTICSEntity>(logisticList[i].CN_S_LOGISTICS_FLAG, "CN_S_LOGISTICS_FLAG", item.ToString());
|
}
|
}
|
isOk = synchLogBll.AddList(logisticList, item.ToString());
|
Log("已成功向Mongo集合：" + item.ToString() + " 中插入：" + logisticList.Count + " 条数据");
|
if (isOk)
|
{
|
SqlExecuteResult removeData = synchLogBll.RemoveSynchLogData(item.ToString());
|
Log("中间表中：表 " + item.ToString() + " 已处理完毕，已从中间表中删除");
|
}
|
break;
|
#endregion
|
|
#region //8、*********************同步作业区流程表*********************//
|
case "TN_AB_B_WORK_AREA_PRO":
|
Log("TN_AB_B_WORK_AREA_PRO");
|
TN_AB_B_WORK_AREA_PROBLL workareaproBll = new TN_AB_B_WORK_AREA_PROBLL();
|
List<TN_AB_B_SYNCH_LOGEntity> workareaproRemoveList = removeDataList.Where(o => o.CN_S_TABLE_NAME.Trim() == item.ToString()).ToList();
|
Log("中间表中：" + item.ToString() + "总共存在：" + workareaproRemoveList.Count + " 条需要删除的数据(状态4)");
|
|
if (workareaproRemoveList.Count > 0)
|
{
|
//根据获取的中间表已删除标识集合，删除Mongo数据
|
foreach (TN_AB_B_SYNCH_LOGEntity synchEntity in workareaproRemoveList)
|
{
|
if (!synchLogBll.RemoveDataByCode<TN_AB_B_WORK_AREA_PROEntity>(synchEntity.CN_S_GUID, "CN_GUID", item.ToString()))
|
{
|
flag = false;
|
break;
|
}
|
}
|
if (flag)
|
{
|
//将已删除的进行标识
|
SqlExecuteResult sr = synchLogBll.RemoveData(workareaproRemoveList, item.ToString());
|
if (sr.Success)
|
{
|
Log("中间表中：" + item.ToString() + " 需要删除的数据已全部删除");
|
}
|
else
|
{
|
Log("报错！报错！内容：" + sr.Exception.ToString());
|
}
|
}
|
}
|
List<TN_AB_B_WORK_AREA_PROEntity> workareaproList = workareaproBll.GetWorkAreaProList(item.ToString());
|
Log("中间表中：" + item.ToString() + "总共存在：" + workareaproList.Count + " 条需要处理同步的数据(状态1，2)");
|
|
for (int i = 0; i < workareaproList.Count; i++)
|
{
|
//判断当前是否已导入Mongo，如果已导入 则先删除Mongo中该条记录
|
if (synchLogBll.IsExistsMongo<TN_AB_B_WORK_AREA_PROEntity>(workareaproList[i].CN_GUID, "CN_GUID", item.ToString()))
|
{
|
Log("作业区流程主键：" + workareaproList[i].CN_GUID + " 在Mongo中已存在，先删除再新增");
|
synchLogBll.RemoveDataByCode<TN_AB_B_WORK_AREA_PROEntity>(workareaproList[i].CN_GUID, "CN_GUID", item.ToString());
|
}
|
}
|
isOk = synchLogBll.AddList(workareaproList, item.ToString());
|
Log("已成功向Mongo集合：" + item.ToString() + " 中插入：" + workareaproList.Count + " 条数据");
|
if (isOk)
|
{
|
SqlExecuteResult removeData = synchLogBll.RemoveSynchLogData(item.ToString());
|
Log("中间表中：表 " + item.ToString() + " 已处理完毕，已从中间表中删除");
|
}
|
break;
|
#endregion
|
|
#region //9、************************同步字典表************************//
|
case "TN_AB_B_DICT":
|
Log("TN_AB_B_DICT");
|
TN_AB_B_DICTBLL dictBll = new TN_AB_B_DICTBLL();
|
List<TN_AB_B_SYNCH_LOGEntity> dicRemoveList = removeDataList.Where(o => o.CN_S_TABLE_NAME.Trim() == item.ToString()).ToList();
|
|
Log("中间表中：" + item.ToString() + "总共存在：" + dicRemoveList.Count + " 条需要删除的数据(状态4)");
|
if (dicRemoveList.Count > 0)
|
{
|
//根据获取的中间表已删除标识集合，删除Mongo数据
|
foreach (TN_AB_B_SYNCH_LOGEntity synchEntity in dicRemoveList)
|
{
|
if (!synchLogBll.RemoveDataByCode<TN_AB_B_DICTEntity>(synchEntity.CN_S_GUID, "CN_S_GUID", item.ToString()))
|
{
|
flag = false;
|
break;
|
}
|
}
|
if (flag)
|
{
|
//将已删除的物料进行标识
|
SqlExecuteResult sr = synchLogBll.RemoveData(dicRemoveList, item.ToString());
|
if (sr.Success)
|
{
|
Log("中间表中：" + item.ToString() + " 需要删除的数据已全部删除");
|
}
|
else
|
{
|
Log("报错！报错！内容：" + sr.Exception.ToString());
|
}
|
}
|
}
|
List<TN_AB_B_DICTEntity> dictList = dictBll.GetDicList(item.ToString());
|
Log("中间表中：" + item.ToString() + "总共存在：" + dictList.Count + " 条需要处理同步的数据(状态1，2)");
|
//插入mongo成功标识
|
for (int i = 0; i < dictList.Count; i++)
|
{
|
//判断当前是否已导入Mongo，如果已导入 则先删除Mongo中该条记录
|
if (synchLogBll.IsExistsMongo<TN_AB_B_DICTEntity>(dictList[i].CN_S_GUID, "CN_S_GUID", item.ToString()))
|
{
|
Log("编码：" + dictList[i].CN_S_GUID + " 在Mongo中已存在，先删除再新增");
|
synchLogBll.RemoveDataByCode<TN_AB_B_DICTEntity>(dictList[i].CN_S_GUID, "CN_S_GUID", item.ToString());
|
}
|
}
|
isOk = synchLogBll.AddList(dictList, item.ToString());
|
Log("已成功向Mongo集合：" + item.ToString() + " 中插入：" + dictList.Count + " 条数据");
|
if (isOk)
|
{
|
SqlExecuteResult removeData = synchLogBll.RemoveSynchLogData(item.ToString());
|
Log("中间表中：表 " + item.ToString() + " 已处理完毕，已从中间表中删除");
|
}
|
break;
|
#endregion
|
|
#region //10、************同步仓库库区/逻辑分区与货位关联表************//
|
case "TN_AB_B_AREA_LOCATION_R":
|
Log("TN_AB_B_AREA_LOCATION_R");
|
TN_AB_B_AREA_LOCATION_RBLL area_location_rBll = new TN_AB_B_AREA_LOCATION_RBLL();
|
List<TN_AB_B_SYNCH_LOGEntity> area_location_rRemoveList = removeDataList.Where(o => o.CN_S_TABLE_NAME.Trim() == item.ToString()).ToList();
|
|
Log("中间表中：" + item.ToString() + "总共存在：" + area_location_rRemoveList.Count + " 条需要删除的数据(状态4)");
|
if (area_location_rRemoveList.Count > 0)
|
{
|
//根据获取的中间表已删除标识集合，删除Mongo数据
|
foreach (TN_AB_B_SYNCH_LOGEntity synchEntity in area_location_rRemoveList)
|
{
|
if (!synchLogBll.RemoveDataByCode<AutoBomAreaLocation_REntity>(synchEntity.CN_S_GUID, "CN_GUID", item.ToString()))
|
{
|
flag = false;
|
break;
|
}
|
}
|
if (flag)
|
{
|
//将已删除的物料进行标识
|
SqlExecuteResult sr = synchLogBll.RemoveData(area_location_rRemoveList, item.ToString());
|
if (sr.Success)
|
{
|
Log("中间表中：" + item.ToString() + " 需要删除的数据已全部删除");
|
}
|
else
|
{
|
Log("报错！报错！内容：" + sr.Exception.ToString());
|
}
|
}
|
}
|
List<AutoBomAreaLocation_REntity> area_location_rList = area_location_rBll.GetAreaLocationRList(item.ToString());
|
Log("中间表中：" + item.ToString() + "总共存在：" + area_location_rList.Count + " 条需要处理同步的数据(状态1，2)");
|
//插入mongo成功标识
|
for (int i = 0; i < area_location_rList.Count; i++)
|
{
|
//判断当前是否已导入Mongo，如果已导入 则先删除Mongo中该条记录
|
if (synchLogBll.IsExistsMongo<AutoBomAreaLocation_REntity>(area_location_rList[i].CN_GUID, "CN_GUID", item.ToString()))
|
{
|
Log("编码：" + area_location_rList[i].CN_GUID + " 在Mongo中已存在，先删除再新增");
|
synchLogBll.RemoveDataByCode<AutoBomAreaLocation_REntity>(area_location_rList[i].CN_GUID, "CN_GUID", item.ToString());
|
}
|
}
|
isOk = synchLogBll.AddList(area_location_rList, item.ToString());
|
Log("已成功向Mongo集合：" + item.ToString() + " 中插入：" + area_location_rList.Count + " 条数据");
|
if (isOk)
|
{
|
SqlExecuteResult removeData = synchLogBll.RemoveSynchLogData(item.ToString());
|
Log("中间表中：表 " + item.ToString() + " 已处理完毕，已从中间表中删除");
|
}
|
break;
|
#endregion
|
|
#region //11、***********************同步物料表************************//
|
case "TN_AB_ITEM":
|
Log("TN_AB_ITEM");
|
List<TN_AB_B_SYNCH_LOGEntity> itemRemoveList = removeDataList.Where(o => o.CN_S_TABLE_NAME.Trim() == item.ToString()).ToList();
|
|
Log("中间表中：" + item.ToString() + "总共存在：" + itemRemoveList.Count + " 条需要删除的数据(状态4)");
|
if (itemRemoveList.Count > 0)
|
{
|
//根据获取的中间表已删除标识集合，删除Mongo数据
|
foreach (TN_AB_B_SYNCH_LOGEntity synchEntity in itemRemoveList)
|
{
|
if (!synchLogBll.RemoveDataByCode<AutoBomItemEntity>(synchEntity.CN_S_GUID, "CN_GUID", item.ToString()))
|
{
|
flag = false;
|
break;
|
}
|
}
|
if (flag)
|
{
|
//将已删除的物料进行标识
|
SqlExecuteResult sr = synchLogBll.RemoveData(itemRemoveList, item.ToString());
|
if (sr.Success)
|
{
|
Log("中间表中：" + item.ToString() + " 需要删除的数据已全部删除");
|
}
|
else
|
{
|
Log("报错！报错！内容：" + sr.Exception.ToString());
|
}
|
}
|
}
|
int timer = 0;
|
while (true)
|
{
|
timer++;
|
List<AutoBomItemEntity> items = itemBll.GetItemList(item.ToString());
|
List<AutoBomItemEntity> itemsUse = items.Where(e => !e.CN_S_STATUS.Equals("报废")).ToList();
|
|
#region 删除报废
|
List<AutoBomItemEntity> itemsNoUse = items.Where(e => e.CN_S_STATUS.Equals("报废")).ToList();
|
foreach (var itemNoUse in itemsNoUse)
|
{
|
synchLogBll.RemoveDataByCode<AutoBomItemEntity>(itemNoUse.CN_S_ITEM_CODE, "CN_S_ITEM_CODE", item.ToString());
|
synchLogBll.RemoveDataByCode<MONGO_KEYTYPE_MAP>(itemNoUse.CN_S_ITEM_CODE, "Key", "MONGO_KEYTYPE_MAP");
|
itemBll.RemoveSynchLogData(itemsNoUse);
|
}
|
#endregion
|
|
if (itemsUse.Count == 0)
|
break;
|
Log("第 " + timer + " 次循环，中间表中：" + item.ToString() + "存在：" + itemsUse.Count + " 条需要处理同步的数据(状态1，2)");
|
|
var Group_List = itemsUse.GroupBy(x => new
|
{
|
x.CN_S_ITEM_CODE
|
}).Select(g => new ItemRow
|
{
|
CN_S_ITEM_CODE = g.FirstOrDefault().CN_S_ITEM_CODE.Trim()
|
}).ToList();
|
|
if (Group_List.Count == itemsUse.Count)
|
{
|
//插入mongo成功标识
|
for (int i = 0; i < itemsUse.Count; i++)
|
{
|
//判断当前是否已导入Mongo，如果已导入 则先删除Mongo中该条记录
|
if (synchLogBll.IsExistsMongo<AutoBomItemEntity>(itemsUse[i].CN_S_ITEM_CODE, "CN_S_ITEM_CODE", item.ToString()))
|
{
|
Log("编码：" + itemsUse[i].CN_S_ITEM_CODE + " 在Mongo中已存在，先删除再新增");
|
synchLogBll.RemoveDataByCode<AutoBomItemEntity>(itemsUse[i].CN_S_ITEM_CODE, "CN_S_ITEM_CODE", item.ToString());
|
}
|
|
//判断当前是否已导入Mongo，如果已导入 则先删除Mongo中该条记录
|
if (synchLogBll.IsExistsMongo<MONGO_KEYTYPE_MAP>(itemsUse[i].CN_S_ITEM_CODE, "Key", "MONGO_KEYTYPE_MAP"))
|
{
|
Log("编码：" + itemsUse[i].CN_S_ITEM_CODE + " 在MONGO_KEYTYPE_MAP中已存在，先删除再新增");
|
synchLogBll.RemoveDataByCode<MONGO_KEYTYPE_MAP>(itemsUse[i].CN_S_ITEM_CODE, "Key", "MONGO_KEYTYPE_MAP");
|
}
|
List<MONGO_KEYTYPE_MAP> TempList = new List<MONGO_KEYTYPE_MAP>() { };
|
TempList.Add(new MONGO_KEYTYPE_MAP { Key = itemsUse[i].CN_S_ITEM_CODE, Type = "4" });
|
synchLogBll.AddList(TempList, "MONGO_KEYTYPE_MAP");
|
Log("已成功向Mongo集合：MONGO_KEYTYPE_MAP 中插入：" + JsonConvert.SerializeObject(TempList));
|
|
}
|
isOk = synchLogBll.AddList(itemsUse, item.ToString());
|
}
|
else
|
{
|
//插入mongo成功标识
|
for (int i = 0; i < itemsUse.Count; i++)
|
{
|
//判断当前是否已导入Mongo，如果已导入 则先删除Mongo中该条记录
|
if (synchLogBll.IsExistsMongo<AutoBomItemEntity>(itemsUse[i].CN_S_ITEM_CODE, "CN_S_ITEM_CODE", item.ToString()))
|
{
|
Log("编码：" + itemsUse[i].CN_S_ITEM_CODE + " 在Mongo中已存在，先删除再新增");
|
synchLogBll.RemoveDataByCode<AutoBomItemEntity>(itemsUse[i].CN_S_ITEM_CODE, "CN_S_ITEM_CODE", item.ToString());
|
}
|
|
//判断当前是否已导入Mongo，如果已导入 则先删除Mongo中该条记录
|
if (synchLogBll.IsExistsMongo<MONGO_KEYTYPE_MAP>(itemsUse[i].CN_S_ITEM_CODE, "Key", "MONGO_KEYTYPE_MAP"))
|
{
|
Log("编码：" + itemsUse[i].CN_S_ITEM_CODE + " 在MONGO_KEYTYPE_MAP中已存在，先删除再新增");
|
synchLogBll.RemoveDataByCode<MONGO_KEYTYPE_MAP>(itemsUse[i].CN_S_ITEM_CODE, "Key", "MONGO_KEYTYPE_MAP");
|
}
|
List<MONGO_KEYTYPE_MAP> TempList = new List<MONGO_KEYTYPE_MAP>() { };
|
TempList.Add(new MONGO_KEYTYPE_MAP { Key = itemsUse[i].CN_S_ITEM_CODE, Type = "4" });
|
synchLogBll.AddList(TempList, "MONGO_KEYTYPE_MAP");
|
Log("已成功向Mongo集合：MONGO_KEYTYPE_MAP 中插入：" + JsonConvert.SerializeObject(TempList));
|
|
List<AutoBomItemEntity> lst = new List<AutoBomItemEntity>();
|
lst.Add(itemsUse[i]);
|
isOk = synchLogBll.AddList(lst, item.ToString());
|
}
|
|
}
|
|
SqlExecuteResult isUp = itemBll.UpdateUnitItemList(itemsUse);
|
|
|
Log("已成功向Mongo集合：" + item.ToString() + " 中插入：" + itemsUse.Count + " 条数据");
|
|
//更新物料包装规格表
|
if (ckb_specif.Checked)
|
{
|
Log("更新物料包装规格表");
|
List<TN_AB_PACK_SPECEntity> packList = new List<TN_AB_PACK_SPECEntity>();
|
foreach (var entity in itemsUse)
|
{
|
TN_AB_PACK_SPECEntity packentity = new TN_AB_PACK_SPECEntity();
|
packentity = new TN_AB_PACK_SPECEntity()
|
{
|
CN_GUID = Guid.NewGuid().ToString().ToUpper(),
|
CN_S_ITEM_CODE = entity.CN_S_ITEM_CODE,
|
CN_S_PACK_NAME = "包",
|
CN_S_PACK_NUM = entity.CN_F_MIN_PACK_QTY.ToString(),
|
CN_S_CODE_SUFFIX = "*" + entity.CN_F_MIN_PACK_QTY.ToString(),
|
CN_S_STATUS = "启用",
|
CN_S_CREATOR = entity.CN_S_CREATOR,
|
CN_S_CREATOR_BY = entity.CN_S_CREATOR_BY,
|
CN_S_MODIFY = entity.CN_S_MODIFY,
|
CN_S_MODIFY_BY = entity.CN_S_MODIFY_BY
|
};
|
|
if (!string.IsNullOrEmpty(entity.CN_T_CREATE.ToString()))
|
{
|
packentity.CN_T_CREATE = Convert.ToDateTime(entity.CN_T_CREATE.ToString());
|
}
|
else
|
{
|
packentity.CN_T_CREATE = DateTime.Now;
|
}
|
if (!string.IsNullOrEmpty(entity.CN_T_MODIFY.ToString()))
|
{
|
packentity.CN_T_MODIFY = Convert.ToDateTime(entity.CN_T_MODIFY.ToString());
|
}
|
else
|
{
|
packentity.CN_T_MODIFY = DateTime.Now;
|
}
|
packList.Add(packentity);
|
}
|
var jsonString = JsonConvert.SerializeObject(packList);
|
string sucess = WebApiManager.HttpAutoBomTool_Post("Api/ItemPacking/AddList", jsonString);
|
MsgEntity msgEntity = JsonConvert.DeserializeObject<MsgEntity>(sucess);
|
|
if (msgEntity.Success)
|
{
|
Log("更新物料包装规格表成功！");
|
}
|
}
|
|
//更新物料托盘容量关联表
|
if (ckb_captif.Checked)
|
{
|
Log("更新物料托盘容量关联表");
|
|
//SqlExecuteResult reuslt = BLLCreator.Create<HH.WMS.BLL.Basic.TN_WM_B_TRAY_CAPACITYBLL>().AddList(itemList);
|
|
string reuslt = WebApiManager.HttpWMSTool_Post("Api/TrayCapacity/AddList", itemsUse);
|
Log("更新物料托盘容量关联表返回结果：" + reuslt);
|
MsgEntity msgEntity = JsonConvert.DeserializeObject<MsgEntity>(reuslt);
|
|
if (msgEntity.Success)
|
{
|
Log("更新物料托盘容量关联表成功！");
|
}
|
}
|
|
SqlExecuteResult removeData = itemBll.RemoveSynchLogData(itemsUse);
|
Log("第 " + timer + " 次循环，中间表中：表 " + item.ToString() + " 已处理完毕，已从中间表中删除 " + itemsUse.Count + " 条");
|
|
}
|
//if (isOk)
|
//{
|
// SqlExecuteResult removeData = synchLogBll.RemoveSynchLogData(item.ToString());
|
// Log("中间表中：表 " + item.ToString() + " 已处理完毕，已从中间表中删除");
|
//}
|
break;
|
#endregion
|
|
#region //12、*******************逻辑分区物料关联表********************//
|
case "TN_AB_B_PARTITION_ITEM_R":
|
Log("TN_AB_B_PARTITION_ITEM_R");
|
TN_AB_B_PARTITION_ITEM_RBLL partitionItemRBll = new TN_AB_B_PARTITION_ITEM_RBLL();
|
List<TN_AB_B_SYNCH_LOGEntity> partitionItemRemoveList = removeDataList.Where(o => o.CN_S_TABLE_NAME.Trim() == item.ToString()).ToList();
|
|
Log("中间表中：" + item.ToString() + "总共存在：" + partitionItemRemoveList.Count + " 条需要删除的数据(状态4)");
|
if (partitionItemRemoveList.Count > 0)
|
{
|
//根据获取的中间表已删除标识集合，删除Mongo数据
|
foreach (TN_AB_B_SYNCH_LOGEntity synchEntity in partitionItemRemoveList)
|
{
|
if (!synchLogBll.RemoveDataByCode<AutoBomPartition_Item_REntity>(synchEntity.CN_S_GUID, "CN_GUID", item.ToString()))
|
{
|
flag = false;
|
break;
|
}
|
}
|
if (flag)
|
{
|
//将已删除的物料进行标识
|
SqlExecuteResult sr = synchLogBll.RemoveData(partitionItemRemoveList, item.ToString());
|
if (sr.Success)
|
{
|
Log("中间表中：" + item.ToString() + " 需要删除的数据已全部删除");
|
}
|
else
|
{
|
Log("报错！报错！内容：" + sr.Exception.ToString());
|
}
|
}
|
}
|
List<AutoBomPartition_Item_REntity> partitionItemList = partitionItemRBll.GetPartionItemRList(item.ToString());
|
Log("中间表中：" + item.ToString() + "总共存在：" + partitionItemList.Count + " 条需要处理同步的数据(状态1，2)");
|
//插入mongo成功标识
|
for (int i = 0; i < partitionItemList.Count; i++)
|
{
|
//判断当前是否已导入Mongo，如果已导入 则先删除Mongo中该条记录
|
if (synchLogBll.IsExistsMongo<AutoBomPartition_Item_REntity>(partitionItemList[i].CN_S_NAME, "CN_S_NAME", item.ToString()))
|
{
|
Log("编码：" + partitionItemList[i].CN_GUID + " 在Mongo中已存在，先删除再新增");
|
synchLogBll.RemoveDataByCode<AutoBomPartition_Item_REntity>(partitionItemList[i].CN_S_NAME, "CN_S_NAME", item.ToString());
|
}
|
}
|
isOk = synchLogBll.AddList(partitionItemList, item.ToString());
|
Log("已成功向Mongo集合：" + item.ToString() + " 中插入：" + partitionItemList.Count + " 条数据");
|
if (isOk)
|
{
|
SqlExecuteResult removeData = synchLogBll.RemoveSynchLogData(item.ToString());
|
Log("中间表中：表 " + item.ToString() + " 已处理完毕，已从中间表中删除");
|
}
|
break;
|
#endregion
|
|
#region //13、*********************同步仓库结构表**********************//
|
case "TN_AB_B_STOCK_STRUCTURE":
|
Log("TN_AB_B_STOCK_STRUCTURE");
|
TN_AB_B_STOCK_STRUCTUREBLL stockStructBll = new TN_AB_B_STOCK_STRUCTUREBLL();
|
List<TN_AB_B_SYNCH_LOGEntity> stockStructRemoveList = removeDataList.Where(o => o.CN_S_TABLE_NAME.Trim() == item.ToString()).ToList();
|
|
Log("中间表中：" + item.ToString() + "总共存在：" + stockStructRemoveList.Count + " 条需要删除的数据(状态4)");
|
if (stockStructRemoveList.Count > 0)
|
{
|
//根据获取的中间表已删除标识集合，删除Mongo数据
|
foreach (TN_AB_B_SYNCH_LOGEntity synchEntity in stockStructRemoveList)
|
{
|
if (!synchLogBll.RemoveDataByCode<TN_AB_B_STOCK_STRUCTUREEntity>(synchEntity.CN_S_GUID, "CN_GUID", item.ToString()))
|
{
|
flag = false;
|
break;
|
}
|
}
|
if (flag)
|
{
|
//将已删除的物料进行标识
|
SqlExecuteResult sr = synchLogBll.RemoveData(stockStructRemoveList, item.ToString());
|
if (sr.Success)
|
{
|
Log("中间表中：" + item.ToString() + " 需要删除的数据已全部删除");
|
}
|
else
|
{
|
Log("报错！报错！内容：" + sr.Exception.ToString());
|
}
|
}
|
}
|
List<TN_AB_B_STOCK_STRUCTUREEntity> stockStructList = stockStructBll.GetStockStructList(item.ToString());
|
Log("中间表中：" + item.ToString() + "总共存在：" + stockStructList.Count + " 条需要处理同步的数据(状态1，2)");
|
//插入mongo成功标识
|
for (int i = 0; i < stockStructList.Count; i++)
|
{
|
//判断当前是否已导入Mongo，如果已导入 则先删除Mongo中该条记录
|
if (synchLogBll.IsExistsMongo<TN_AB_B_STOCK_STRUCTUREEntity>(stockStructList[i].CN_GUID, "CN_GUID", item.ToString()))
|
{
|
Log("编码：" + stockStructList[i].CN_GUID + " 在Mongo中已存在，先删除再新增");
|
synchLogBll.RemoveDataByCode<TN_AB_B_STOCK_STRUCTUREEntity>(stockStructList[i].CN_GUID, "CN_GUID", item.ToString());
|
}
|
}
|
isOk = synchLogBll.AddList(stockStructList, item.ToString());
|
Log("已成功向Mongo集合：" + item.ToString() + " 中插入：" + stockStructList.Count + " 条数据");
|
if (isOk)
|
{
|
SqlExecuteResult removeData = synchLogBll.RemoveSynchLogData(item.ToString());
|
Log("中间表中：表 " + item.ToString() + " 已处理完毕，已从中间表中删除");
|
}
|
break;
|
#endregion
|
|
#region //14、******************同步站点对应AGV编号表******************//
|
case "TN_AB_B_LOCATION_AGVCODE":
|
Log("TN_AB_B_LOCATION_AGVCODE");
|
TN_AB_B_LOCATION_AGVCODEBLL locationAgvBll = new TN_AB_B_LOCATION_AGVCODEBLL();
|
List<TN_AB_B_SYNCH_LOGEntity> locationAgvRemoveList = removeDataList.Where(o => o.CN_S_TABLE_NAME.Trim() == item.ToString()).ToList();
|
|
Log("中间表中：" + item.ToString() + "总共存在：" + locationAgvRemoveList.Count + " 条需要删除的数据(状态4)");
|
if (locationAgvRemoveList.Count > 0)
|
{
|
//根据获取的中间表已删除标识集合，删除Mongo数据
|
foreach (TN_AB_B_SYNCH_LOGEntity synchEntity in locationAgvRemoveList)
|
{
|
if (!synchLogBll.RemoveDataByCode<TN_AB_B_LOCATION_AGVCODEEntity>(synchEntity.CN_S_GUID, "CN_GUID", item.ToString()))
|
{
|
flag = false;
|
break;
|
}
|
}
|
if (flag)
|
{
|
//将已删除的物料进行标识
|
SqlExecuteResult sr = synchLogBll.RemoveData(locationAgvRemoveList, item.ToString());
|
if (sr.Success)
|
{
|
Log("中间表中：" + item.ToString() + " 需要删除的数据已全部删除");
|
}
|
else
|
{
|
Log("报错！报错！内容：" + sr.Exception.ToString());
|
}
|
}
|
}
|
List<TN_AB_B_LOCATION_AGVCODEEntity> locationAgvList = locationAgvBll.GetlocationAgvList(item.ToString());
|
Log("中间表中：" + item.ToString() + "总共存在：" + locationAgvList.Count + " 条需要处理同步的数据(状态1，2)");
|
//插入mongo成功标识
|
for (int i = 0; i < locationAgvList.Count; i++)
|
{
|
//判断当前是否已导入Mongo，如果已导入 则先删除Mongo中该条记录
|
if (synchLogBll.IsExistsMongo<TN_AB_B_LOCATION_AGVCODEEntity>(locationAgvList[i].CN_GUID, "CN_GUID", item.ToString()))
|
{
|
Log("编码：" + locationAgvList[i].CN_GUID + " 在Mongo中已存在，先删除再新增");
|
synchLogBll.RemoveDataByCode<TN_AB_B_LOCATION_AGVCODEEntity>(locationAgvList[i].CN_GUID, "CN_GUID", item.ToString());
|
}
|
}
|
isOk = synchLogBll.AddList(locationAgvList, item.ToString());
|
Log("已成功向Mongo集合：" + item.ToString() + " 中插入：" + locationAgvList.Count + " 条数据");
|
if (isOk)
|
{
|
SqlExecuteResult removeData = synchLogBll.RemoveSynchLogData(item.ToString());
|
Log("中间表中：表 " + item.ToString() + " 已处理完毕，已从中间表中删除");
|
}
|
break;
|
#endregion
|
|
#region //15、***********************入区条件表************************//
|
case "TN_AB_B_IN_AREA_CONDITION":
|
//Log("TN_AB_B_IN_AREA_CONDITION");
|
//TN_AB_B_IN_AREA_CONDITIONBLL inAreaLocationBll = new TN_AB_B_IN_AREA_CONDITIONBLL();
|
//List<TN_AB_B_SYNCH_LOGEntity> inAreaLocationRemoveList = removeDataList.Where(o => o.CN_S_TABLE_NAME.Trim() == item.ToString()).ToList();
|
|
//Log("中间表中：" + item.ToString() + "总共存在：" + inAreaLocationRemoveList.Count + " 条需要删除的数据(状态4)");
|
//if (inAreaLocationRemoveList.Count > 0)
|
//{
|
// //根据获取的中间表已删除标识集合，删除Mongo数据
|
// foreach (TN_AB_B_SYNCH_LOGEntity synchEntity in inAreaLocationRemoveList)
|
// {
|
// if (!synchLogBll.RemoveDataByCode<TN_AB_B_IN_AREA_CONDITIONEntity>(synchEntity.CN_S_GUID, "CN_GUID", item.ToString()))
|
// {
|
// flag = false;
|
// break;
|
// }
|
// }
|
// if (flag)
|
// {
|
// //将已删除的物料进行标识
|
// SqlExecuteResult sr = synchLogBll.RemoveData(inAreaLocationRemoveList, item.ToString());
|
// if (sr.Success)
|
// {
|
// Log("中间表中：" + item.ToString() + " 需要删除的数据已全部删除");
|
// }
|
// else
|
// {
|
// Log("报错！报错！内容：" + sr.Exception.ToString());
|
// }
|
// }
|
//}
|
//List<TN_AB_B_IN_AREA_CONDITIONEntity> inAreaLocationList = inAreaLocationBll.GetInAreaConditionList(item.ToString());
|
//Log("中间表中：" + item.ToString() + "总共存在：" + inAreaLocationList.Count + " 条需要处理同步的数据(状态1，2)");
|
////插入mongo成功标识
|
//for (int i = 0; i < inAreaLocationList.Count; i++)
|
//{
|
// //判断当前是否已导入Mongo，如果已导入 则先删除Mongo中该条记录
|
// if (synchLogBll.IsExistsMongo<TN_AB_B_IN_AREA_CONDITIONEntity>(inAreaLocationList[i].CN_GUID, "CN_GUID", item.ToString()))
|
// {
|
// Log("编码：" + inAreaLocationList[i].CN_GUID + " 在Mongo中已存在，先删除再新增");
|
// synchLogBll.RemoveDataByCode<TN_AB_B_IN_AREA_CONDITIONEntity>(inAreaLocationList[i].CN_GUID, "CN_GUID", item.ToString());
|
// }
|
//}
|
//isOk = synchLogBll.AddList(inAreaLocationList, item.ToString());
|
//Log("已成功向Mongo集合：" + item.ToString() + " 中插入：" + inAreaLocationList.Count + " 条数据");
|
//if (isOk)
|
//{
|
// SqlExecuteResult removeData = synchLogBll.RemoveSynchLogData(item.ToString());
|
// Log("中间表中：表 " + item.ToString() + " 已处理完毕，已从中间表中删除");
|
//}
|
break;
|
#endregion
|
|
#region //16、***********************条件定义表************************//
|
case "TN_AB_B_CONDITION_DEF":
|
//Log("TN_AB_B_CONDITION_DEF");
|
//TN_AB_B_CONDITION_DEFBLL conditionDefBll = new TN_AB_B_CONDITION_DEFBLL();
|
//List<TN_AB_B_SYNCH_LOGEntity> conditionDefRemoveList = removeDataList.Where(o => o.CN_S_TABLE_NAME.Trim() == item.ToString()).ToList();
|
|
//Log("中间表中：" + item.ToString() + "总共存在：" + conditionDefRemoveList.Count + " 条需要删除的数据(状态4)");
|
//if (conditionDefRemoveList.Count > 0)
|
//{
|
// //根据获取的中间表已删除标识集合，删除Mongo数据
|
// foreach (TN_AB_B_SYNCH_LOGEntity synchEntity in conditionDefRemoveList)
|
// {
|
// if (!synchLogBll.RemoveDataByCode<TN_AB_B_CONDITION_DEFEntity>(synchEntity.CN_S_GUID, "CN_GUID", item.ToString()))
|
// {
|
// flag = false;
|
// break;
|
// }
|
// }
|
// if (flag)
|
// {
|
// //将已删除的物料进行标识
|
// SqlExecuteResult sr = synchLogBll.RemoveData(conditionDefRemoveList, item.ToString());
|
// if (sr.Success)
|
// {
|
// Log("中间表中：" + item.ToString() + " 需要删除的数据已全部删除");
|
// }
|
// else
|
// {
|
// Log("报错！报错！内容：" + sr.Exception.ToString());
|
// }
|
// }
|
//}
|
//List<TN_AB_B_CONDITION_DEFEntity> conditionDefList = conditionDefBll.GetConditionDefList(item.ToString());
|
//Log("中间表中：" + item.ToString() + "总共存在：" + conditionDefList.Count + " 条需要处理同步的数据(状态1，2)");
|
////插入mongo成功标识
|
//for (int i = 0; i < conditionDefList.Count; i++)
|
//{
|
// //判断当前是否已导入Mongo，如果已导入 则先删除Mongo中该条记录
|
// if (synchLogBll.IsExistsMongo<TN_AB_B_CONDITION_DEFEntity>(conditionDefList[i].CN_GUID, "CN_GUID", item.ToString()))
|
// {
|
// Log("编码：" + conditionDefList[i].CN_GUID + " 在Mongo中已存在，先删除再新增");
|
// synchLogBll.RemoveDataByCode<TN_AB_B_CONDITION_DEFEntity>(conditionDefList[i].CN_GUID, "CN_GUID", item.ToString());
|
// }
|
//}
|
//isOk = synchLogBll.AddList(conditionDefList, item.ToString());
|
//Log("已成功向Mongo集合：" + item.ToString() + " 中插入：" + conditionDefList.Count + " 条数据");
|
//if (isOk)
|
//{
|
// SqlExecuteResult removeData = synchLogBll.RemoveSynchLogData(item.ToString());
|
// Log("中间表中：表 " + item.ToString() + " 已处理完毕，已从中间表中删除");
|
//}
|
break;
|
#endregion
|
|
#region //17、***********************工作类型表************************//
|
case "TN_AB_B_WORK_TYPE":
|
Log("TN_AB_B_WORK_TYPE");
|
TN_AB_B_WORK_TYPEBLL workTypeBll = new TN_AB_B_WORK_TYPEBLL();
|
List<TN_AB_B_SYNCH_LOGEntity> workTypeRemoveList = removeDataList.Where(o => o.CN_S_TABLE_NAME.Trim() == item.ToString()).ToList();
|
|
Log("中间表中：" + item.ToString() + "总共存在：" + workTypeRemoveList.Count + " 条需要删除的数据(状态4)");
|
if (workTypeRemoveList.Count > 0)
|
{
|
//根据获取的中间表已删除标识集合，删除Mongo数据
|
foreach (TN_AB_B_SYNCH_LOGEntity synchEntity in workTypeRemoveList)
|
{
|
if (!synchLogBll.RemoveDataByCode<TN_AB_B_WORK_TYPEEntity>(synchEntity.CN_S_GUID, "CN_GUID", item.ToString()))
|
{
|
flag = false;
|
break;
|
}
|
}
|
if (flag)
|
{
|
//将已删除的物料进行标识
|
SqlExecuteResult sr = synchLogBll.RemoveData(workTypeRemoveList, item.ToString());
|
if (sr.Success)
|
{
|
Log("中间表中：" + item.ToString() + " 需要删除的数据已全部删除");
|
}
|
else
|
{
|
Log("报错！报错！内容：" + sr.Exception.ToString());
|
}
|
}
|
}
|
List<TN_AB_B_WORK_TYPEEntity> workTypeList = workTypeBll.GetWorkTypeList(item.ToString());
|
Log("中间表中：" + item.ToString() + "总共存在：" + workTypeList.Count + " 条需要处理同步的数据(状态1，2)");
|
//插入mongo成功标识
|
for (int i = 0; i < workTypeList.Count; i++)
|
{
|
//判断当前是否已导入Mongo，如果已导入 则先删除Mongo中该条记录
|
if (synchLogBll.IsExistsMongo<TN_AB_B_WORK_TYPEEntity>(workTypeList[i].CN_S_TYPE_CODE, "CN_S_TYPE_CODE", item.ToString()))
|
{
|
Log("编码：" + workTypeList[i].CN_GUID + " 在Mongo中已存在，先删除再新增");
|
synchLogBll.RemoveDataByCode<TN_AB_B_WORK_TYPEEntity>(workTypeList[i].CN_S_TYPE_CODE, "CN_S_TYPE_CODE", item.ToString());
|
}
|
}
|
isOk = synchLogBll.AddList(workTypeList, item.ToString());
|
Log("已成功向Mongo集合：" + item.ToString() + " 中插入：" + workTypeList.Count + " 条数据");
|
if (isOk)
|
{
|
SqlExecuteResult removeData = synchLogBll.RemoveSynchLogData(item.ToString());
|
Log("中间表中：表 " + item.ToString() + " 已处理完毕，已从中间表中删除");
|
}
|
break;
|
#endregion
|
|
#region //18、*********************流程事件定义表**********************//
|
case "TN_AB_B_PRO_EVENT_DEF":
|
//Log("TN_AB_B_PRO_EVENT_DEF");
|
//TN_AB_B_PRO_EVENT_DEFBLL proEventDefBll = new TN_AB_B_PRO_EVENT_DEFBLL();
|
//List<TN_AB_B_SYNCH_LOGEntity> proEventDefRemoveList = removeDataList.Where(o => o.CN_S_TABLE_NAME.Trim() == item.ToString()).ToList();
|
|
//Log("中间表中：" + item.ToString() + "总共存在：" + proEventDefRemoveList.Count + " 条需要删除的数据(状态4)");
|
//if (proEventDefRemoveList.Count > 0)
|
//{
|
// //根据获取的中间表已删除标识集合，删除Mongo数据
|
// foreach (TN_AB_B_SYNCH_LOGEntity synchEntity in proEventDefRemoveList)
|
// {
|
// if (!synchLogBll.RemoveDataByCode<TN_AB_B_PRO_EVENT_DEFEntity>(synchEntity.CN_S_GUID, "CN_GUID", item.ToString()))
|
// {
|
// flag = false;
|
// break;
|
// }
|
// }
|
// if (flag)
|
// {
|
// //将已删除的物料进行标识
|
// SqlExecuteResult sr = synchLogBll.RemoveData(proEventDefRemoveList, item.ToString());
|
// if (sr.Success)
|
// {
|
// Log("中间表中：" + item.ToString() + " 需要删除的数据已全部删除");
|
// }
|
// else
|
// {
|
// Log("报错！报错！内容：" + sr.Exception.ToString());
|
// }
|
// }
|
//}
|
//List<TN_AB_B_PRO_EVENT_DEFEntity> proEventDefList = proEventDefBll.GetProEventDefList(item.ToString());
|
//Log("中间表中：" + item.ToString() + "总共存在：" + proEventDefList.Count + " 条需要处理同步的数据(状态1，2)");
|
////插入mongo成功标识
|
//for (int i = 0; i < proEventDefList.Count; i++)
|
//{
|
// //判断当前是否已导入Mongo，如果已导入 则先删除Mongo中该条记录
|
// if (synchLogBll.IsExistsMongo<TN_AB_B_PRO_EVENT_DEFEntity>(proEventDefList[i].CN_GUID, "CN_GUID", item.ToString()))
|
// {
|
// Log("编码：" + proEventDefList[i].CN_GUID + " 在Mongo中已存在，先删除再新增");
|
// synchLogBll.RemoveDataByCode<TN_AB_B_PRO_EVENT_DEFEntity>(proEventDefList[i].CN_GUID, "CN_GUID", item.ToString());
|
// }
|
//}
|
//isOk = synchLogBll.AddList(proEventDefList, item.ToString());
|
//Log("已成功向Mongo集合：" + item.ToString() + " 中插入：" + proEventDefList.Count + " 条数据");
|
//if (isOk)
|
//{
|
// SqlExecuteResult removeData = synchLogBll.RemoveSynchLogData(item.ToString());
|
// Log("中间表中：表 " + item.ToString() + " 已处理完毕，已从中间表中删除");
|
//}
|
break;
|
#endregion
|
|
#region //19、***********************物料价格表************************//
|
case "TN_AB_B_ITEM_PRICE":
|
//Log("TN_AB_B_ITEM_PRICE");
|
//TN_AB_B_ITEM_PRICEBLL itemPriceBll = new TN_AB_B_ITEM_PRICEBLL();
|
//List<TN_AB_B_SYNCH_LOGEntity> itemPriceRemoveList = removeDataList.Where(o => o.CN_S_TABLE_NAME.Trim() == item.ToString()).ToList();
|
|
//Log("中间表中：" + item.ToString() + "总共存在：" + itemPriceRemoveList.Count + " 条需要删除的数据(状态4)");
|
//if (itemPriceRemoveList.Count > 0)
|
//{
|
// //根据获取的中间表已删除标识集合，删除Mongo数据
|
// foreach (TN_AB_B_SYNCH_LOGEntity synchEntity in itemPriceRemoveList)
|
// {
|
// if (!synchLogBll.RemoveDataByCode<TN_AB_B_ITEM_PRICEEntity>(synchEntity.CN_S_GUID, "CN_GUID", item.ToString()))
|
// {
|
// flag = false;
|
// break;
|
// }
|
// }
|
// if (flag)
|
// {
|
// //将已删除的物料进行标识
|
// SqlExecuteResult sr = synchLogBll.RemoveData(itemPriceRemoveList, item.ToString());
|
// if (sr.Success)
|
// {
|
// Log("中间表中：" + item.ToString() + " 需要删除的数据已全部删除");
|
// }
|
// else
|
// {
|
// Log("报错！报错！内容：" + sr.Exception.ToString());
|
// }
|
// }
|
//}
|
//int timerp = 0;
|
//while (true)
|
//{
|
// timerp++;
|
// List<TN_AB_B_ITEM_PRICEEntity> itemPriceList = itemPriceBll.GetItemPricetList(item.ToString());
|
// if (itemPriceList.Count == 0)
|
// break;
|
// Log("第 " + timerp + " 次循环，中间表中：" + item.ToString() + "总共存在：" + itemPriceList.Count + " 条需要处理同步的数据(状态1，2)");
|
// //插入mongo成功标识
|
// for (int i = 0; i < itemPriceList.Count; i++)
|
// {
|
// //判断当前是否已导入Mongo，如果已导入 则先删除Mongo中该条记录
|
// if (synchLogBll.IsExistsMongo<TN_AB_B_ITEM_PRICEEntity>(itemPriceList[i].CN_GUID, "CN_GUID", item.ToString()))
|
// {
|
// Log("编码：" + itemPriceList[i].CN_GUID + " 在Mongo中已存在，先删除再新增");
|
// synchLogBll.RemoveDataByCode<TN_AB_B_ITEM_PRICEEntity>(itemPriceList[i].CN_GUID, "CN_GUID", item.ToString());
|
// }
|
// }
|
// isOk = synchLogBll.AddList(itemPriceList, item.ToString());
|
// Log("已成功向Mongo集合：" + item.ToString() + " 中插入：" + itemPriceList.Count + " 条数据");
|
|
// SqlExecuteResult removeData = synchLogBll.RemoveSynchLogData(item.ToString());
|
// Log("第 " + timerp + " 次循环，中间表中：表 " + item.ToString() + " 已处理完毕，已从中间表中删除");
|
|
//}
|
break;
|
#endregion
|
|
#region //20、*********************货位站点互联表**********************//
|
case "TN_AB_B_LOCATION_LINK":
|
//Log("TN_AB_B_LOCATION_LINK");
|
//TN_AB_B_LOCATION_LINKBLL locationLinkBll = new TN_AB_B_LOCATION_LINKBLL();
|
//List<TN_AB_B_SYNCH_LOGEntity> locationLinkRemoveList = removeDataList.Where(o => o.CN_S_TABLE_NAME.Trim() == item.ToString()).ToList();
|
|
//Log("中间表中：" + item.ToString() + "总共存在：" + locationLinkRemoveList.Count + " 条需要删除的数据(状态4)");
|
//if (locationLinkRemoveList.Count > 0)
|
//{
|
// //根据获取的中间表已删除标识集合，删除Mongo数据
|
// foreach (TN_AB_B_SYNCH_LOGEntity synchEntity in locationLinkRemoveList)
|
// {
|
// if (!synchLogBll.RemoveDataByCode<TN_AB_B_LOCATION_LINKEntity>(synchEntity.CN_S_GUID, "CN_GUID", item.ToString()))
|
// {
|
// flag = false;
|
// break;
|
// }
|
// }
|
// if (flag)
|
// {
|
// //将已删除的物料进行标识
|
// SqlExecuteResult sr = synchLogBll.RemoveData(locationLinkRemoveList, item.ToString());
|
// if (sr.Success)
|
// {
|
// Log("中间表中：" + item.ToString() + " 需要删除的数据已全部删除");
|
// }
|
// else
|
// {
|
// Log("报错！报错！内容：" + sr.Exception.ToString());
|
// }
|
// }
|
//}
|
//List<TN_AB_B_LOCATION_LINKEntity> locationLinkList = locationLinkBll.GetLocationLinkList(item.ToString());
|
//Log("中间表中：" + item.ToString() + "总共存在：" + locationLinkList.Count + " 条需要处理同步的数据(状态1，2)");
|
////插入mongo成功标识
|
//for (int i = 0; i < locationLinkList.Count; i++)
|
//{
|
// //判断当前是否已导入Mongo，如果已导入 则先删除Mongo中该条记录
|
// if (synchLogBll.IsExistsMongo<TN_AB_B_LOCATION_LINKEntity>(locationLinkList[i].CN_GUID, "CN_GUID", item.ToString()))
|
// {
|
// Log("编码：" + locationLinkList[i].CN_GUID + " 在Mongo中已存在，先删除再新增");
|
// synchLogBll.RemoveDataByCode<TN_AB_B_LOCATION_LINKEntity>(locationLinkList[i].CN_GUID, "CN_GUID", item.ToString());
|
// }
|
//}
|
//isOk = synchLogBll.AddList(locationLinkList, item.ToString());
|
//Log("已成功向Mongo集合：" + item.ToString() + " 中插入：" + locationLinkList.Count + " 条数据");
|
//if (isOk)
|
//{
|
// SqlExecuteResult removeData = synchLogBll.RemoveSynchLogData(item.ToString());
|
// Log("中间表中：表 " + item.ToString() + " 已处理完毕，已从中间表中删除");
|
//}
|
break;
|
#endregion
|
|
#region //21、***********************安全库存表************************//
|
case "TN_AB_B_ITEM_SAFETY":
|
//Log("TN_AB_B_ITEM_SAFETY");
|
//TN_AB_B_ITEM_SAFETYBLL itemSaftyBll = new TN_AB_B_ITEM_SAFETYBLL();
|
//List<TN_AB_B_SYNCH_LOGEntity> itemSaftyRemoveList = removeDataList.Where(o => o.CN_S_TABLE_NAME.Trim() == item.ToString()).ToList();
|
|
//Log("中间表中：" + item.ToString() + "总共存在：" + itemSaftyRemoveList.Count + " 条需要删除的数据(状态4)");
|
//if (itemSaftyRemoveList.Count > 0)
|
//{
|
// //根据获取的中间表已删除标识集合，删除Mongo数据
|
// foreach (TN_AB_B_SYNCH_LOGEntity synchEntity in itemSaftyRemoveList)
|
// {
|
// if (!synchLogBll.RemoveDataByCode<TN_AB_B_ITEM_SAFETYEntity>(synchEntity.CN_S_GUID, "CN_GUID", item.ToString()))
|
// {
|
// flag = false;
|
// break;
|
// }
|
// }
|
// if (flag)
|
// {
|
// //将已删除的物料进行标识
|
// SqlExecuteResult sr = synchLogBll.RemoveData(itemSaftyRemoveList, item.ToString());
|
// if (sr.Success)
|
// {
|
// Log("中间表中：" + item.ToString() + " 需要删除的数据已全部删除");
|
// }
|
// else
|
// {
|
// Log("报错！报错！内容：" + sr.Exception.ToString());
|
// }
|
// }
|
//}
|
//List<TN_AB_B_ITEM_SAFETYEntity> itemSaftyList = itemSaftyBll.GetItemSaftyList(item.ToString());
|
//Log("中间表中：" + item.ToString() + "总共存在：" + itemSaftyList.Count + " 条需要处理同步的数据(状态1，2)");
|
////插入mongo成功标识
|
//for (int i = 0; i < itemSaftyList.Count; i++)
|
//{
|
// //判断当前是否已导入Mongo，如果已导入 则先删除Mongo中该条记录
|
// if (synchLogBll.IsExistsMongoSafty<TN_AB_B_ITEM_SAFETYEntity>(itemSaftyList[i], item.ToString()))
|
// {
|
// Log("编码：" + itemSaftyList[i].CN_S_ITEM_CODE + "和库区：" + itemSaftyList[i].CN_S_AREA_CODE + " 在Mongo中已存在，先删除再新增");
|
// synchLogBll.RemoveDataByCodeSafty<TN_AB_B_ITEM_SAFETYEntity>(itemSaftyList[i], item.ToString());
|
// }
|
//}
|
//isOk = synchLogBll.AddList(itemSaftyList, item.ToString());
|
//Log("已成功向Mongo集合：" + item.ToString() + " 中插入：" + itemSaftyList.Count + " 条数据");
|
//if (isOk)
|
//{
|
// SqlExecuteResult removeData = synchLogBll.RemoveSynchLogData(item.ToString());
|
// Log("中间表中：表 " + item.ToString() + " 已处理完毕，已从中间表中删除");
|
//}
|
break;
|
#endregion
|
|
#region //22、*********************物料包装规格表**********************//
|
case "TN_AB_PACK_SPEC":
|
Log("TN_AB_PACK_SPEC");
|
TN_AB_PACK_SPECBLL itemSpecBll = new TN_AB_PACK_SPECBLL();
|
List<TN_AB_B_SYNCH_LOGEntity> itemSpecRemoveList = removeDataList.Where(o => o.CN_S_TABLE_NAME.Trim() == item.ToString()).ToList();
|
|
Log("中间表中：" + item.ToString() + "总共存在：" + itemSpecRemoveList.Count + " 条需要删除的数据(状态4)");
|
if (itemSpecRemoveList.Count > 0)
|
{
|
//根据获取的中间表已删除标识集合，删除Mongo数据
|
foreach (TN_AB_B_SYNCH_LOGEntity synchEntity in itemSpecRemoveList)
|
{
|
if (!synchLogBll.RemoveDataByCode<TN_AB_PACK_SPECEntity>(synchEntity.CN_S_GUID, "CN_GUID", item.ToString()))
|
{
|
flag = false;
|
break;
|
}
|
}
|
if (flag)
|
{
|
//将已删除的物料进行标识
|
SqlExecuteResult sr = synchLogBll.RemoveData(itemSpecRemoveList, item.ToString());
|
if (sr.Success)
|
{
|
Log("中间表中：" + item.ToString() + " 需要删除的数据已全部删除");
|
}
|
else
|
{
|
Log("报错！报错！内容：" + sr.Exception.ToString());
|
}
|
}
|
}
|
//List<TN_AB_PACK_SPECEntity> itemSpecList = itemSpecBll.GetPackSpecList(item.ToString());
|
//Log("中间表中：" + item.ToString() + "总共存在：" + itemSpecList.Count + " 条需要处理同步的数据(状态1，2)");
|
////插入mongo成功标识
|
//for (int i = 0; i < itemSpecList.Count; i++)
|
//{
|
// //判断当前是否已导入Mongo，如果已导入 则先删除Mongo中该条记录
|
// if (synchLogBll.IsExistsMongo<TN_AB_B_IN_AREA_CONDITIONEntity>(itemSpecList[i].CN_S_ITEM_CODE, "CN_S_ITEM_CODE", item.ToString()))
|
// {
|
// Log("编码：" + itemSpecList[i].CN_GUID + " 在Mongo中已存在，先删除再新增");
|
// synchLogBll.RemoveDataByCode<TN_AB_B_IN_AREA_CONDITIONEntity>(itemSpecList[i].CN_S_ITEM_CODE, "CN_S_ITEM_CODE", item.ToString());
|
// }
|
//}
|
//isOk = synchLogBll.AddList(itemSpecList, item.ToString());
|
//Log("已成功向Mongo集合：" + item.ToString() + " 中插入：" + itemSpecList.Count + " 条数据");
|
//if (isOk)
|
//{
|
// SqlExecuteResult removeData = synchLogBll.RemoveSynchLogData(item.ToString());
|
// Log("中间表中：表 " + item.ToString() + " 已处理完毕，已从中间表中删除");
|
//}
|
|
int timer1 = 0;
|
while (true)
|
{
|
timer1++;
|
List<TN_AB_PACK_SPECEntity> itemSpecList = itemSpecBll.GetPackSpecList(item.ToString());
|
if (itemSpecList.Count == 0)
|
break;
|
Log("第 " + timer1 + " 次循环，中间表中：" + item.ToString() + "存在：" + itemSpecList.Count + " 条需要处理同步的数据(状态1，2)");
|
//插入mongo成功标识
|
for (int i = 0; i < itemSpecList.Count; i++)
|
{
|
//判断当前是否已导入Mongo，如果已导入 则先删除Mongo中该条记录
|
if (synchLogBll.IsExistsMongo<TN_AB_PACK_SPECEntity>(itemSpecList[i].CN_S_ITEM_CODE, "CN_S_ITEM_CODE", item.ToString()))
|
{
|
Log("编码：" + itemSpecList[i].CN_S_ITEM_CODE + " 在Mongo中已存在，先删除再新增");
|
synchLogBll.RemoveDataByCode<TN_AB_PACK_SPECEntity>(itemSpecList[i].CN_S_ITEM_CODE, "CN_S_ITEM_CODE", item.ToString());
|
}
|
}
|
isOk = synchLogBll.AddList(itemSpecList, item.ToString());
|
Log("已成功向Mongo集合：" + item.ToString() + " 中插入：" + itemSpecList.Count + " 条数据");
|
|
SqlExecuteResult removeData = itemSpecBll.RemoveSynchLogData(itemSpecList);
|
Log("第 " + timer1 + " 次循环，中间表中：表 " + item.ToString() + " 已处理完毕，已从中间表中删除 " + itemSpecList.Count + " 条");
|
|
}
|
break;
|
#endregion
|
|
#region //23、*********************物料辅助单位表**********************//
|
case "TN_AB_B_AUXILIARY_UNIT":
|
//Log("TN_AB_B_AUXILIARY_UNIT");
|
//TN_AB_B_AUXILIARY_UNITBLL auxiliaryUnitBll = new TN_AB_B_AUXILIARY_UNITBLL();
|
//List<TN_AB_B_SYNCH_LOGEntity> auxiliaryUnitRemoveList = removeDataList.Where(o => o.CN_S_TABLE_NAME.Trim() == item.ToString()).ToList();
|
|
//Log("中间表中：" + item.ToString() + "总共存在：" + auxiliaryUnitRemoveList.Count + " 条需要删除的数据(状态4)");
|
//if (auxiliaryUnitRemoveList.Count > 0)
|
//{
|
// //根据获取的中间表已删除标识集合，删除Mongo数据
|
// foreach (TN_AB_B_SYNCH_LOGEntity synchEntity in auxiliaryUnitRemoveList)
|
// {
|
// // TN_AB_B_AUXILIARY_UNITEntity
|
|
// AutoBomItemEntity itemEntity = itemBll.GetItemModelByAuxi(synchEntity.CN_S_GUID);
|
// if (itemEntity != null)
|
// {
|
// List<AuxiliaryEntity> auxiList = itemEntity.AuxiliaryUnitList;
|
// if (auxiList != null)
|
// {
|
// if (auxiList.Any())
|
// {
|
// var newAuxiList = auxiList.Except(auxiList.Where(x => x.CN_GUID == synchEntity.CN_S_GUID)).ToList();
|
|
// if (!itemBll.UpdateAuxiData(newAuxiList, itemEntity.CN_S_ITEM_CODE))
|
// {
|
// Log("删除失败！");
|
// flag = false;
|
// break;
|
// }
|
// else
|
// {
|
// Log("删除成功！");
|
// }
|
// }
|
|
// }
|
// }
|
// }
|
// if (flag)
|
// {
|
// //将已删除的物料进行标识
|
// SqlExecuteResult sr = synchLogBll.RemoveData(auxiliaryUnitRemoveList, item.ToString());
|
// if (sr.Success)
|
// {
|
// Log("中间表中：" + item.ToString() + " 需要删除的数据已全部删除");
|
// }
|
// else
|
// {
|
// Log("报错！报错！内容：" + sr.Exception.ToString());
|
// }
|
// }
|
//}
|
//List<TN_AB_B_AUXILIARY_UNITEntity> itemAuxiList = auxiliaryUnitBll.GetitemAuxiList(item.ToString());
|
|
////插入mongo成功标识
|
//bool isOK = false;
|
//for (int i = 0; i < itemAuxiList.Count; i++)
|
//{
|
// AutoBomItemEntity itemEntity = itemBll.GetItemModel(itemAuxiList[i].CN_S_ITEM_CODE);
|
// if (itemEntity != null)
|
// {
|
// var itemAuxiliaryUnit = itemEntity.AuxiliaryUnitList;
|
// Log("处理物料：" + itemAuxiList[i].CN_S_ITEM_CODE + "，原单位：" + JsonConvert.SerializeObject(itemAuxiliaryUnit));
|
|
// if (itemAuxiliaryUnit != null)
|
// {
|
// var isExist = itemAuxiliaryUnit.Where(x => x.CN_S_UNIT == itemAuxiList[i].CN_S_UNIT).ToList();
|
// if (isExist.Any())
|
// {
|
// itemAuxiliaryUnit.RemoveAll(x => x.CN_S_UNIT == itemAuxiList[i].CN_S_UNIT);
|
// itemAuxiliaryUnit.Add(new AuxiliaryEntity()
|
// {
|
// CN_GUID = itemAuxiList[i].CN_GUID,
|
// CN_S_UNIT = itemAuxiList[i].CN_S_UNIT,
|
// CN_F_CONVERT_QTY = itemAuxiList[i].CN_F_CONVERT_QTY.ToString()
|
// });
|
// }
|
// else
|
// {
|
// itemAuxiliaryUnit.Add(new AuxiliaryEntity()
|
// {
|
// CN_GUID = itemAuxiList[i].CN_GUID,
|
// CN_S_UNIT = itemAuxiList[i].CN_S_UNIT,
|
// CN_F_CONVERT_QTY = itemAuxiList[i].CN_F_CONVERT_QTY.ToString()
|
// });
|
// }
|
// Log("处理物料-修改：" + itemAuxiList[i].CN_S_ITEM_CODE + "，新单位：" + JsonConvert.SerializeObject(itemAuxiliaryUnit));
|
|
// isOK = itemBll.UpdateAuxiData(itemAuxiliaryUnit, itemAuxiList[i].CN_S_ITEM_CODE);
|
// }
|
// else
|
// {
|
|
// List<AuxiliaryEntity> AuxiliaryUnitList = new List<AuxiliaryEntity>();
|
// AuxiliaryEntity Aentity = new AuxiliaryEntity();
|
// Aentity.CN_GUID = itemAuxiList[i].CN_GUID;
|
// Aentity.CN_S_UNIT = itemAuxiList[i].CN_S_UNIT;
|
// Aentity.CN_F_CONVERT_QTY = itemAuxiList[i].CN_F_CONVERT_QTY.ToString();
|
// AuxiliaryUnitList.Add(Aentity);
|
// isOK = itemBll.UpdateAuxiData(AuxiliaryUnitList, itemAuxiList[i].CN_S_ITEM_CODE);
|
|
// Log("处理物料-新增：" + itemAuxiList[i].CN_S_ITEM_CODE + "，新单位：" + JsonConvert.SerializeObject(AuxiliaryUnitList));
|
|
// }
|
// }
|
// if (isOK)
|
// {
|
// SqlExecuteResult removeData = synchLogBll.RemoveSynchLogData(item.ToString());
|
// }
|
//}
|
break;
|
#endregion
|
|
#region //24、***********************客户地址表************************//
|
case "TN_AB_B_ADDRESS_INFO":
|
Log("TN_AB_B_ADDRESS_INFO");
|
TN_AB_B_ADDRESS_INFOBLL adressInfoBll = new TN_AB_B_ADDRESS_INFOBLL();
|
List<TN_AB_B_SYNCH_LOGEntity> adressInfoRemoveList = removeDataList.Where(o => o.CN_S_TABLE_NAME.Trim() == item.ToString()).ToList();
|
|
Log("中间表中：" + item.ToString() + "总共存在：" + adressInfoRemoveList.Count + " 条需要删除的数据(状态4)");
|
if (adressInfoRemoveList.Count > 0)
|
{
|
//根据获取的中间表已删除标识集合，删除Mongo数据
|
foreach (TN_AB_B_SYNCH_LOGEntity synchEntity in adressInfoRemoveList)
|
{
|
if (!synchLogBll.RemoveDataByCode<TN_AB_B_ADDRESS_INFOEntity>(synchEntity.CN_S_GUID, "CN_GUID", item.ToString()))
|
{
|
flag = false;
|
break;
|
}
|
}
|
if (flag)
|
{
|
//将已删除的物料进行标识
|
SqlExecuteResult sr = synchLogBll.RemoveData(adressInfoRemoveList, item.ToString());
|
if (sr.Success)
|
{
|
Log("中间表中：" + item.ToString() + " 需要删除的数据已全部删除");
|
}
|
else
|
{
|
Log("报错！报错！内容：" + sr.Exception.ToString());
|
}
|
}
|
}
|
List<TN_AB_B_ADDRESS_INFOEntity> adressInfoList = adressInfoBll.GetAddressInfoList(item.ToString());
|
Log("中间表中：" + item.ToString() + "总共存在：" + adressInfoList.Count + " 条需要处理同步的数据(状态1，2)");
|
//插入mongo成功标识
|
for (int i = 0; i < adressInfoList.Count; i++)
|
{
|
//判断当前是否已导入Mongo，如果已导入 则先删除Mongo中该条记录
|
if (synchLogBll.IsExistsMongo<TN_AB_B_IN_AREA_CONDITIONEntity>(adressInfoList[i].CN_GUID, "CN_GUID", item.ToString()))
|
{
|
Log("编码：" + adressInfoList[i].CN_GUID + " 在Mongo中已存在，先删除再新增");
|
synchLogBll.RemoveDataByCode<TN_AB_B_IN_AREA_CONDITIONEntity>(adressInfoList[i].CN_GUID, "CN_GUID", item.ToString());
|
}
|
}
|
isOk = synchLogBll.AddList(adressInfoList, item.ToString());
|
Log("已成功向Mongo集合：" + item.ToString() + " 中插入：" + adressInfoList.Count + " 条数据");
|
if (isOk)
|
{
|
SqlExecuteResult removeData = synchLogBll.RemoveSynchLogData(item.ToString());
|
Log("中间表中：表 " + item.ToString() + " 已处理完毕，已从中间表中删除");
|
}
|
break;
|
#endregion
|
|
default:
|
break;
|
}
|
}
|
|
}
|
//更新货位扩展表
|
//if (ckb_locationext.Checked)
|
//{
|
// DoLocationExt();
|
//}
|
|
|
Log("==============================全部结束！==============================");
|
|
btn_Move.Text = "一键同步";
|
btn_Move.Enabled = true;
|
}
|
catch (Exception ex)
|
{
|
|
btn_Move.Text = "一键同步";
|
btn_Move.Enabled = true;
|
Log("抛出异常！：" + ex.Message.ToString());
|
checkBox1.Checked = false;
|
}
|
runingPro = false;
|
}
|
|
#region 更新货位扩展表
|
/// <summary>
|
/// 更新货位扩展表
|
/// </summary>
|
private void DoLocationExt(List<AutoBomLocationEntity> locations)
|
{
|
Log("开始同步货位至货位扩展表");
|
//string Location = WebApiManager.HttpAutoBomTool_Post("Api/StockLocation/GetSyncLocationList", "");
|
//Log("获取AutoBom返回结果：" + Location);
|
//List<TN_AB_STOCK_LOCATIONEntity> LocationEntity = JsonHelper.JSONStringToList<TN_AB_STOCK_LOCATIONEntity>(Location);
|
Log("待同步货位个数：" + locations.Count + " 个");
|
foreach (AutoBomLocationEntity location in locations)
|
{
|
string Where = "where CN_S_STOCK_CODE='" + location.CN_S_STOCK_CODE + "' and CN_S_LOCATION_CODE='" + location.CN_S_LOCATION_CODE + "'";
|
var obj = new
|
{
|
Set = " CN_N_SYNC=1 ",
|
Where = Where
|
};
|
var jsonString = JsonConvert.SerializeObject(obj);
|
if (location.CN_S_STATUS == "报废")
|
{
|
#region 处理报废货位
|
Log("处理报废货位");
|
string LocationEtxStr = WebApiManager.HttpWMSTool_Get("Api/LocationExt/GetModel?Where=" + Where); //BLLCreator.Create<HH.WMS.BLL.Basic.TN_WM_LOCATION_EXTBLL>().GetModel(Where);
|
TN_WM_LOCATION_EXTEntity LocationEtxEntity = JsonConvert.DeserializeObject<TN_WM_LOCATION_EXTEntity>(LocationEtxStr);
|
|
Log("LocationEtxEntity实体：" + JsonConvert.SerializeObject(LocationEtxEntity));
|
if (LocationEtxEntity != null)
|
{
|
if (LocationEtxEntity.CN_S_USE_STATE == "空" && LocationEtxEntity.CN_S_LOCATION_STATE == "正常")
|
{
|
string result = WebApiManager.HttpWMSTool_Get("Api/LocationExt/UpdateLocationState?locationCode=" + location.CN_S_LOCATION_CODE + "&state=报废");
|
|
Log("货位报废结果：" + result);
|
//HH.WMS.Entitys.OperateResult reuslt = JsonConvert.DeserializeObject<HH.WMS.Entitys.OperateResult>(deleteStr);
|
//if (reuslt.Success == true)
|
//{
|
// Log("UpdateLocationSync" + jsonString);
|
// string sucess = WebApiManager.HttpAutoBomTool_Post("Api/StockLocation/UpdateLocationSync", jsonString);
|
|
// Log("UpdateLocationSync结果：" + sucess);
|
//}
|
}
|
}
|
else
|
{
|
TN_WM_LOCATION_EXTEntity Entity = new TN_WM_LOCATION_EXTEntity();
|
Entity.CN_S_STOCK_CODE = location.CN_S_STOCK_CODE;
|
Entity.CN_S_LOCATION_CODE = location.CN_S_LOCATION_CODE;
|
Entity.CN_S_ROW = location.CN_S_ROW;
|
Entity.CN_S_FLOOR = location.CN_S_FLOOR;
|
Entity.CN_S_COL = location.CN_S_COL;
|
Entity.CN_S_LOCATION_STATE = "报废";
|
Entity.CN_S_BEF_FAULT_STATE = "正常";
|
Entity.CN_S_USE_STATE = "空";
|
Entity.CN_N_DELIVERY_BEAT = 0;
|
Entity.CN_S_ROADWAY = location.CN_S_ROADWAY;
|
Entity.CN_S_AREA_CODE = location.CN_S_AREA_CODE;
|
Entity.CN_S_CREATOR = location.CN_S_CREATOR;
|
Entity.CN_S_CREATOR_BY = location.CN_S_CREATOR_BY;
|
Entity.CN_T_CREATE = DateTime.Now; //Convert.ToDateTime(item.CN_T_MODIFY);
|
|
var objEntity = new
|
{
|
ExtEntity = Entity
|
};
|
string entityStr = JsonConvert.SerializeObject(objEntity);
|
Log("拼接实体：" + entityStr);
|
string resultStr = WebApiManager.HttpWMSTool_Post("Api/LocationExt/Add", entityStr);
|
//SqlExecuteResult reuslt = JsonConvert.DeserializeObject<SqlExecuteResult>(resultStr);
|
//if (reuslt.Success == true)
|
//{
|
// string sucess = WebApiManager.HttpAutoBomTool_Post("Api/StockLocation/UpdateLocationSync", jsonString);
|
//}
|
Log("处理结果：" + resultStr);
|
|
//Log("直接UpdateLocationSync"+ jsonString);
|
//string sucess = WebApiManager.HttpAutoBomTool_Post("Api/StockLocation/UpdateLocationSync", jsonString);
|
//Log("UpdateLocationSync结果：" + sucess);
|
}
|
#endregion
|
}
|
else
|
{
|
#region 处理新增货位
|
string LocationEtxStr = WebApiManager.HttpWMSTool_Get("Api/LocationExt/GetModel?Where=" + Where); //BLLCreator.Create<HH.WMS.BLL.Basic.TN_WM_LOCATION_EXTBLL>().GetModel(Where);
|
TN_WM_LOCATION_EXTEntity LocationEtxEntity = JsonConvert.DeserializeObject<TN_WM_LOCATION_EXTEntity>(LocationEtxStr);
|
Log("处理新增货位CN_S_LOCATION_CODE:" + location.CN_S_LOCATION_CODE + ",查询结果：" + JsonConvert.SerializeObject(LocationEtxEntity));
|
if (LocationEtxEntity == null)
|
{
|
TN_WM_LOCATION_EXTEntity Entity = new TN_WM_LOCATION_EXTEntity();
|
Entity.CN_S_STOCK_CODE = location.CN_S_STOCK_CODE;
|
Entity.CN_S_LOCATION_CODE = location.CN_S_LOCATION_CODE;
|
Entity.CN_S_ROW = location.CN_S_ROW;
|
Entity.CN_S_FLOOR = location.CN_S_FLOOR;
|
Entity.CN_S_COL = location.CN_S_COL;
|
Entity.CN_S_LOCATION_STATE = "正常";
|
Entity.CN_S_BEF_FAULT_STATE = "正常";
|
Entity.CN_S_USE_STATE = "空";
|
Entity.CN_N_DELIVERY_BEAT = 0;
|
Entity.CN_S_ROADWAY = location.CN_S_ROADWAY;
|
Entity.CN_S_AREA_CODE = location.CN_S_AREA_CODE;
|
Entity.CN_S_CREATOR = location.CN_S_CREATOR;
|
Entity.CN_S_CREATOR_BY = location.CN_S_CREATOR_BY;
|
Entity.CN_T_CREATE = DateTime.Now; //Convert.ToDateTime(item.CN_T_MODIFY);
|
|
var objEntity = new
|
{
|
ExtEntity = Entity
|
};
|
string entityStr = JsonConvert.SerializeObject(objEntity);
|
Log("拼接实体：" + entityStr);
|
|
string resultStr = WebApiManager.HttpWMSTool_Post("Api/LocationExt/Add", entityStr);// BLLCreator.Create<HH.WMS.BLL.Basic.TN_WM_LOCATION_EXTBLL>().Add(Entity);
|
//SqlExecuteResult reuslt = JsonConvert.DeserializeObject<SqlExecuteResult>(resultStr);
|
//if (reuslt.Success == true)
|
//{
|
// string sucess = WebApiManager.HttpAutoBomTool_Post("Api/StockLocation/UpdateLocationSync", jsonString);
|
//}
|
Log("处理结果：" + resultStr);
|
}
|
else
|
{
|
if (LocationEtxEntity.CN_S_AREA_CODE != location.CN_S_AREA_CODE || LocationEtxEntity.CN_S_LOCATION_STATE != location.CN_S_STATUS)
|
{
|
Log("库区编码发生变化,Etx_CN_S_AREA_CODE" + LocationEtxEntity.CN_S_AREA_CODE + ",itemAreacode:" + location.CN_S_AREA_CODE);
|
|
#region 当库区编码发生变化时 修改扩展表库区编码
|
TN_WM_LOCATION_EXTEntity Entity = new TN_WM_LOCATION_EXTEntity();
|
Entity.CN_S_STOCK_CODE = location.CN_S_STOCK_CODE;
|
Entity.CN_S_LOCATION_CODE = location.CN_S_LOCATION_CODE;
|
Entity.CN_S_AREA_CODE = location.CN_S_AREA_CODE;
|
Entity.CN_S_ROADWAY = location.CN_S_ROADWAY;
|
Entity.CN_N_DELIVERY_BEAT = 0;
|
Entity.CN_S_LOCATION_STATE = location.CN_S_STATUS == "新建" ? "正常" : location.CN_S_STATUS;
|
var objEntity = new
|
{
|
ExtEntity = Entity
|
};
|
string entityStr = JsonConvert.SerializeObject(objEntity);
|
string resultStr = WebApiManager.HttpWMSTool_Post("Api/LocationExt/UpdateSync", entityStr);
|
//SqlExecuteResult reuslt = JsonConvert.DeserializeObject<SqlExecuteResult>(resultStr);
|
//if (reuslt.Success == true)
|
//{
|
// string sucess = WebApiManager.HttpAutoBomTool_Post("Api/StockLocation/UpdateLocationSync", jsonString);
|
//}
|
Log("处理结果：" + resultStr);
|
#endregion
|
}
|
//else
|
//{
|
// string sucess = WebApiManager.HttpAutoBomTool_Post("Api/StockLocation/UpdateLocationSync", jsonString);
|
// if (LocationEtxEntity.CN_S_LOCATION_STATE.Equals("报废"))
|
// {
|
// WebApiManager.HttpWMSTool_Get("Api/LocationExt/UpdateLocationState?locationCode=" + location.CN_S_LOCATION_CODE + "&state=正常");
|
// }
|
//}
|
}
|
#endregion
|
}
|
}
|
}
|
#endregion
|
|
public enum TableName
|
{
|
TN_AB_STOCK, //仓库表
|
TN_AB_B_STOCK_AREA, //库区表
|
TN_AB_STOCK_LOCATION, //货位表
|
TN_AB_CUSTOMER, //客户表
|
TN_AB_SUPPLIER, //供应商表
|
TN_AB_B_NUMRULE, //编码规则表
|
TN_AB_LOGISTICS, //物流公司表
|
TN_AB_B_WORK_AREA_PRO, //作业区流程表
|
TN_AB_B_DICT, //字典表
|
TN_AB_B_AREA_LOCATION_R, //仓库库区/逻辑分区与货位关联表
|
TN_AB_ITEM, //物料表
|
TN_AB_B_PARTITION_ITEM_R, //逻辑分区物料关联表
|
TN_AB_B_STOCK_STRUCTURE, //仓库结构
|
//TN_AB_B_LOCATION_AGVCODE, //站点对应AGV编号 李长好说跟他有冲突，暂停同步
|
TN_AB_B_IN_AREA_CONDITION, //入区条件表
|
TN_AB_B_CONDITION_DEF, //条件定义表
|
TN_AB_B_WORK_TYPE, //工作类型表
|
TN_AB_B_PRO_EVENT_DEF, //流程事件定义表
|
TN_AB_B_ITEM_PRICE, //物料价格
|
TN_AB_B_LOCATION_LINK, //货位站点互联表,
|
TN_AB_B_ITEM_SAFETY, //安全库存表
|
TN_AB_PACK_SPEC, //物料包装规格表
|
TN_AB_B_AUXILIARY_UNIT, //物料辅助单位表
|
TN_AB_B_ADDRESS_INFO //客户地址表
|
}
|
|
|
private void Log(string msg)
|
{
|
HH.WMS.Common.Log.Detail(logPara, msg);
|
listBox1.Items.Insert(0, DateTime.Now.ToString("[yyyy-MM-dd HH:mm:ss]") + msg);
|
listBox1.Items.Insert(0, "---------------------");
|
listBox1.Refresh();
|
}
|
|
private void timer1_Tick(object sender, EventArgs e)
|
{
|
if (checkBox1.Checked)
|
{
|
if (!runingPro)
|
{
|
runingPro = true;
|
DoTimerTickThread();
|
}
|
}
|
}
|
|
private void txt_ToolName_TextChanged(object sender, EventArgs e)
|
{
|
|
}
|
|
}
|
}
|
