public IActionResult GetSupportInfo(int id)
{
DataAccess.TASM_SUPPORT_Da manager = new DataAccess.TASM_SUPPORT_Da();
TASM_SUPPORT model = manager.CurrentDb.GetById(id);
return(SuccessResult(model));
}
public IActionResult SupportUpdate(TASM_SUPPORT info)
{
TASM_SUPPORT_Da support = new TASM_SUPPORT_Da();
TASM_SUPPORT_HIS_Da his = new TASM_SUPPORT_HIS_Da();
var hisModel = his.SelectBySidType(info.SID, 0);
support.Db.BeginTran();
hisModel.PRE_USER = info.CREATOR;
hisModel.NEXT_USER = info.CONDUCTOR;
if (his.Db.Updateable(hisModel).ExecuteCommand() < 1)
{
support.Db.RollbackTran();
return(FailMessage());
}
if (support.Db.Updateable(info).ExecuteCommand() < 1)
{
support.Db.RollbackTran();
return(FailMessage());
}
support.Db.CommitTran();
return(SuccessMessage());
}
private bool UpdateSupport(TASM_SUPPORT supportModel, TASM_SUPPORT_Da support_manager, int nextUser, int supportStatus, int pmcId)
{
supportModel.MEMBERID = pmcId;
supportModel.STATUS = supportStatus; //修改工单状态
supportModel.CONDUCTOR = nextUser; //工单流转到下一处理人员， 修改处理人员，此处 PMC处理人员 和 下一处理人员共用一个字段
supportModel.STATE = 1; //工单处理中
return(support_manager.CurrentDb.Update(supportModel)); //修改工单表
}
private bool UpdateSupport(TASM_SUPPORT supportModel, TASM_SUPPORT_Da support_manager, int nextUser, int supportStatus, int pid)
{
supportModel.MEMBERID = pid;
supportModel.STATUS = supportStatus; //修改工单状态
supportModel.CONDUCTOR = nextUser; //工单流转到下一处理人员， 修改处理人员，此处 PMC处理人员 和 下一处理人员共用一个字段
if (supportModel.STATUS == 6 || supportModel.STATUS == 7)
{
supportModel.STATE = 2; //工单已完成, 工单状态 只有创建时，是待办， 技术处理之后 就变成 处理中了，
supportModel.CONDUCTOR = supportModel.CREATOR; //工单，完成之后，没有下一处理人， 处理人变成创建人，但不产生新的personal数据
}
return(support_manager.CurrentDb.Update(supportModel)); //修改工单表
}
/// <summary>
/// 个人处理信息表
/// </summary>
/// <param name="model"></param>
/// <param name="sid"></param>
/// <returns></returns>
private bool InsertPersonal(TASM_SUPPORT model, int sid)
{
TASM_SUPPORT_PERSONAL_Da da = new TASM_SUPPORT_PERSONAL_Da();
TASM_SUPPORT_PERSONAL psersonlModel = new TASM_SUPPORT_PERSONAL()
{
CID = model.CREATOR,
CREATETIME = DateTime.Now,
DID = model.CONDUCTOR,
SID = sid,
STATUS = 0,
TID = model.STATUS
};
return(da.CurrentDb.Insert(psersonlModel));
}
/// <summary>
/// 插入操作历史
/// </summary>
/// <param name="model"></param>
/// <param name="supportModel"></param>
/// <param name="nextUser"></param>
/// <param name="supportStatus"></param>
/// <param name="disposerId"></param>
/// <returns></returns>
private bool InsertHistory(TASM_SUPPORT_DISPOSER model, TASM_SUPPORT supportModel, int nextUser, int supportStatus, int disposerId)
{
DataAccess.TASM_SUPPORT_HIS_Da his_manager = new TASM_SUPPORT_HIS_Da();
TASM_SUPPORT_HIS hisModel = new TASM_SUPPORT_HIS();
hisModel.CREATETIME = DateTime.Now;
hisModel.PRE_USER = supportModel.CONDUCTOR;
hisModel.NEXT_USER = nextUser;
hisModel.SID = model.SID;
hisModel.REMARKS = model.STATUS == 1 ? "技术已处理，等待PMC处理" : "技术已处理，等待现场处理";
hisModel.PRE_STATUS = supportModel.STATUS;
hisModel.NEXT_STATUS = supportStatus;
hisModel.TYPE = (int)SupportHisType.技术处理;
hisModel.TID = disposerId;
return(his_manager.CurrentDb.Insert(hisModel));
}
private bool InsertHistory(TASM_SUPPORT_SITE model, TASM_SUPPORT supportModel, int siteId, int supportStatus, int nextUser)
{
DataAccess.TASM_SUPPORT_HIS_Da his_manager = new TASM_SUPPORT_HIS_Da();
TASM_SUPPORT_HIS hisModel = new TASM_SUPPORT_HIS();
hisModel.CREATETIME = DateTime.Now;
hisModel.PRE_USER = supportModel.CONDUCTOR;
hisModel.NEXT_USER = nextUser;
hisModel.SID = model.SID;
hisModel.REMARKS = "现场已处理，等待审核";
hisModel.PRE_STATUS = supportModel.STATUS;
hisModel.NEXT_STATUS = supportStatus;
hisModel.TYPE = (int)Entites.SupportHisType.现场处理;
hisModel.TID = siteId;
return(his_manager.CurrentDb.Insert(hisModel));
}
private bool InsertHistory(TASM_SUPPORT_PRINCIPAL model, TASM_SUPPORT supportModel, int supportStatus, int nextUser, int pid)
{
string remarks = supportStatus == 5 ? "未完成" : "已完成";
//3,当前处理人员发生修改，新增一条 修改记录 history
TASM_SUPPORT_HIS hisModel = new TASM_SUPPORT_HIS();
hisModel.CREATETIME = DateTime.Now;
hisModel.PRE_USER = supportModel.CONDUCTOR;
hisModel.NEXT_USER = nextUser;
hisModel.SID = model.SID;
hisModel.REMARKS = "负责人已审核:" + remarks;
hisModel.PRE_STATUS = supportModel.STATUS;
hisModel.NEXT_STATUS = supportStatus;
hisModel.TYPE = (int)Entites.SupportHisType.负责人审核;
hisModel.TID = pid;
DataAccess.TASM_SUPPORT_HIS_Da his_manager = new TASM_SUPPORT_HIS_Da();
return(his_manager.CurrentDb.Insert(hisModel));
}
/// <summary>
/// 创建工单主表
/// </summary>
/// <param name="model"></param>
/// <param name="da"></param>
/// <param name="sid"></param>
/// <param name="supportModel"></param>
/// <returns></returns>
private bool InsertSupport(SupportCreateModel model, TASM_SUPPORT_Da da, ref int sid, ref TASM_SUPPORT supportModel)
{
TASM_PROJECTManager projectda = new TASM_PROJECTManager();
TASM_PROJECT projectmodel = projectda.CurrentDb.GetById(model.ProjectId);
string code = projectmodel.CODE + "-" + da.SelectSupprotCodeIndex();
supportModel = new TASM_SUPPORT()
{
CREATOR = model.CreatorId,
CONDUCTOR = model.ConductorId,
CONTENT = model.Content,
CREATETIME = DateTime.Now,
FINDATE = model.FindDate,
MEMBERID = 0,
PROJECT = model.ProjectId,
SEVERITY = model.Severity,
STATUS = 0,
TITLE = model.Title,
TYPE = model.Type,
STATE = 0,
MID = model.Mid,
CODE = code
};
sid = da.CurrentDb.InsertReturnIdentity(supportModel);
if (sid <= 0)
{
Msg = "添加操作历史失败！";
return(false);
}
return(true);
}
/// <summary>
/// 增加操作历史
/// </summary>
/// <param name="supportModel"></param>
/// <param name="sid"></param>
/// <returns></returns>
private bool InsertHistory(TASM_SUPPORT supportModel, int sid)
{
DataAccess.TASM_SUPPORT_HIS_Da his_manager = new TASM_SUPPORT_HIS_Da();
TASM_SUPPORT_HIS hisModel = new TASM_SUPPORT_HIS();
hisModel.CREATETIME = DateTime.Now;
hisModel.PRE_USER = supportModel.CREATOR;
hisModel.NEXT_USER = supportModel.CONDUCTOR;
hisModel.SID = sid;
hisModel.REMARKS = "工单创建，等待技术处理";
hisModel.PRE_STATUS = supportModel.STATUS;
hisModel.NEXT_STATUS = supportModel.STATUS; //初始状态
hisModel.TYPE = (int)SupportHisType.创建工单; //tasm_disposer表
hisModel.TID = sid;
if (!his_manager.CurrentDb.Insert(hisModel))
{
Msg = "添加操作历史失败！";
return(false);
}
return(true);
}
private void btn_star_ClickAsync(object sender, EventArgs e)
{
//若有缺失用户直接指定 曾丽蓉
string filepath = this.tb_filePath.Text;
IExcelImporter Importer = new ExcelImporter();
var result = Importer.Import <ExcelModel>(filepath);
if (result.Result.Data == null)
{
MessageBox.Show("读取excel失败！");
return;
}
List <ExcelModel> list = result.Result.Data.ToList();
//TODO： 将excel 拆成5张表
TASM_SUPPORT_Da daSupport = new TASM_SUPPORT_Da();
daSupport.Db.BeginTran(); //事务开
try
{
int i = 0;
foreach (var item in list)
{
i++;
logger.Info("===============导入开始==============" + i);
Log("===============导入开始==============" + i);
int sid = 0; //工单id
TASM_SUPPORT supportModel = new TASM_SUPPORT();
Log("No：" + i + "创建工单-开始");
if (!CreateSupport(daSupport, item, ref sid, ref supportModel))
{
daSupport.Db.RollbackTran();
logger.Info("===============导入失败====创建工单失败==========" + item.Content);
Log("No：" + i + "创建工单-失败");
continue;
}
Log("No：" + i + "创建工单-结束");
//判断是否有现场处理节点，
if (item.IsDisposerPoint.Trim() == "否" || string.IsNullOrWhiteSpace(item.IsDisposerPoint))
{
//没有的话，继续下一条
Log("===============导入结束=========没有Disposer节点=====" + i);
continue;
}
Log("No：" + i + "现场处理-开始");
if (!CreateDisposer(supportModel, item, sid))
{
daSupport.Db.RollbackTran();
logger.Info("===============导入失败====创建现场处理失败==========" + item.Content);
Log("No：" + i + "现场处理-失败");
continue;
}
Log("No：" + i + "现场处理-结束");
if (item.IsPmcPoint.Trim() == "否" || string.IsNullOrWhiteSpace(item.IsPmcPoint))
{
//没有的话，继续下一条
Log("===============导入结束=========没有Pmc节点=====" + i);
continue;
}
Log("No：" + i + "PMC处理-开始");
if (!CreatePmcOrder(supportModel, item, sid))
{
daSupport.Db.RollbackTran();
logger.Info("===============导入失败====PMC处理失败==========" + item.Content);
Log("No：" + i + "PMC处理失败-失败");
continue;
}
Log("No：" + i + "PMC处理-结束");
if (item.IsSitePoint == "否" || string.IsNullOrWhiteSpace(item.IsSitePoint))
{
//没有的话，继续下一条
Log("===============导入结束=========没有site节点=====" + i);
continue;
}
Log("No：" + i + "现场处理-开始");
if (!CreateSiteCheck(supportModel, item, sid))
{
daSupport.Db.RollbackTran();
logger.Info("===============导入失败====现场处理失败==========" + item.Content);
Log("No：" + i + "现场处理失败-失败");
continue;
}
Log("No：" + i + "现场处理-结束");
if (item.IsPrincipalPoint == "否" || string.IsNullOrWhiteSpace(item.IsPrincipalPoint))
{
Log("===============导入结束=========没有principal节点=====" + i);
continue;
}
if (!CreatePrincipal(supportModel, item, sid))
{
daSupport.Db.RollbackTran();
logger.Info("===============导入失败====审核失败==========" + item.Content);
Log("No：" + i + "审核处理失败-失败");
continue;
}
Log("===============导入结束==============" + i);
logger.Info("===============导入结束==============" + i);
}
}
catch (Exception ex)
{
daSupport.Db.RollbackTran();
logger.Info("程序异常，外层捕捉：" + ex);
}
}
/// <summary>
/// 创建负责人审核
/// </summary>
/// <param name="supportModel"></param>
/// <param name="item"></param>
/// <param name="sid"></param>
/// <returns></returns>
private bool CreatePrincipal(TASM_SUPPORT supportModel, ExcelModel item, int sid)
{
try
{
logger.Info("===创建审核开始===！");
DataAccess.TASM_SUPPORT_PRINCIPAL_Da supportPrincipal = new TASM_SUPPORT_PRINCIPAL_Da();
TASM_SUPPORT_PRINCIPAL princalModel = new TASM_SUPPORT_PRINCIPAL();
princalModel.CHECKUSER = item.CheckName;
princalModel.CREATETIME = DateTime.Now;
princalModel.ENDDATE = ConventDateTime(item.FinishDate);
princalModel.RESULT = item.CheckResult;
princalModel.SID = sid;
princalModel.STATUS = 0;
princalModel.REMARKS = "导入数据";
int prId = supportPrincipal.Db.Insertable(princalModel).ExecuteReturnIdentity();
TASM_SUPPORT_HIS_Da supportHis = new TASM_SUPPORT_HIS_Da();
TASM_SUPPORT_HIS supportHisModel = new TASM_SUPPORT_HIS();
supportHisModel.SID = sid;
supportHisModel.PRE_USER = supportModel.CONDUCTOR; //上一处理人
supportHisModel.NEXT_USER = supportModel.CONDUCTOR; //下一处理人
supportHisModel.PRE_STATUS = item.IsPmcPoint == "是" ? 2 : 1; //上一状态，订单初始创建，为0
supportHisModel.NEXT_STATUS = 4; //下一状态，订单初始创建 下一状态为 现场处理，状态0，此处创建订单不做为状态，默认创建 和 创建后未处理状态都是0
supportHisModel.TYPE = 4; //类型，也代表着是哪个表的数据 初始为0
supportHisModel.TID = prId; //数据id 根据type 那张表，看是哪一条数据。
supportHisModel.REMARKS = "现场已处理，等待审核导入数据";
supportHisModel.CREATETIME = DateTime.Now;
supportHis.Db.Insertable(supportHisModel);
logger.Info("插入历史表，审核处理完成");
TASM_SUPPORT_PERSONAL_Da supportPersonal = new TASM_SUPPORT_PERSONAL_Da();
TASM_SUPPORT_PERSONAL personalModel = new TASM_SUPPORT_PERSONAL();
personalModel.CID = supportModel.CONDUCTOR;
personalModel.DID = supportModel.CONDUCTOR;
personalModel.CREATETIME = DateTime.Now;
personalModel.SID = sid;
personalModel.STATUS = 2;
personalModel.TID = 4;
personalModel.CREATETIME = DateTime.Now;
personalModel.REMARKS = "数据导入";
supportPersonal.Db.Insertable(personalModel);
logger.Info("插入个人处理表，审核处理完成");
logger.Info("===创建审核结束===！");
return(true);
}
catch (Exception ex)
{
logger.Error("创建审核失败" + ex);
return(false);
}
}
/// <summary>
/// 现场处理
/// </summary>
/// <returns></returns>
private bool CreateSiteCheck(TASM_SUPPORT supportModel, ExcelModel item, int sid)
{
try
{
logger.Info("===创建现场处理开始===！");
TASM_SUPPORT_SITE_Da supportSite = new TASM_SUPPORT_SITE_Da();
TASM_SUPPORT_SITE siteMode = new TASM_SUPPORT_SITE();
siteMode.CREATETIME = DateTime.Now;
siteMode.DESCRIPTION = item.Description;
siteMode.ENDDATE = ConventDateTime(item.EndDate);
siteMode.REAMRKS = "导入数据";
int siteId = supportSite.Db.Insertable(siteMode).ExecuteReturnIdentity();
TASM_SUPPORT_HIS_Da supportHis = new TASM_SUPPORT_HIS_Da();
TASM_SUPPORT_HIS supportHisModel = new TASM_SUPPORT_HIS();
supportHisModel.SID = sid;
supportHisModel.PRE_USER = supportModel.CONDUCTOR; //上一处理人
supportHisModel.NEXT_USER = supportModel.CONDUCTOR; //下一处理人
supportHisModel.PRE_STATUS = item.IsPmcPoint == "是" ? 2 : 1; //上一状态，订单初始创建，为0
supportHisModel.NEXT_STATUS = 3; //下一状态，订单初始创建 下一状态为 现场处理，状态0，此处创建订单不做为状态，默认创建 和 创建后未处理状态都是0
supportHisModel.TYPE = 3; //类型，也代表着是哪个表的数据 初始为0
supportHisModel.TID = siteId; //数据id 根据type 那张表，看是哪一条数据。
supportHisModel.REMARKS = "现场已处理，等待审核导入数据";
supportHisModel.CREATETIME = DateTime.Now;
supportHis.Db.Insertable(supportHisModel);
logger.Info("插入历史表，现场处理完成");
TASM_SUPPORT_PERSONAL_Da supportPersonal = new TASM_SUPPORT_PERSONAL_Da();
TASM_SUPPORT_PERSONAL personalModel = new TASM_SUPPORT_PERSONAL();
personalModel.CID = supportModel.CONDUCTOR;
personalModel.DID = supportModel.CONDUCTOR;
personalModel.CREATETIME = DateTime.Now;
personalModel.SID = sid;
personalModel.STATUS = 2;
personalModel.TID = 3;
personalModel.CREATETIME = DateTime.Now;
personalModel.REMARKS = "数据导入";
supportPersonal.Db.Insertable(personalModel);
logger.Info("插入个人处理表，现场处理完成");
logger.Info("===创建现场处理结束===！");
return(true);
}
catch (Exception ex)
{
logger.Error("创建现场处理失败" + ex);
return(false);
}
}
/// <summary>
/// PMC处理
/// </summary>
/// <param name="supportModel"></param>
/// <param name="item"></param>
/// <param name="sid"></param>
/// <returns></returns>
private bool CreatePmcOrder(TASM_SUPPORT supportModel, ExcelModel item, int sid)
{
try
{
logger.Info("===创建PMC处理开始===！");
DataAccess.TASM_SUPPORT_PMC_Da supportPmcOrder = new TASM_SUPPORT_PMC_Da();
TASM_SUPPORT_PMC pmcModel = new TASM_SUPPORT_PMC();
pmcModel.BOOKNO = item.BookNo;
pmcModel.DELIVERY = ConventDateTime(item.Delivery);
pmcModel.SENDDATE = ConventDateTime(item.SendDate);
pmcModel.SENDNO = item.SendNo;
pmcModel.CONSIGNEE = item.Consignee;
pmcModel.STATUS = 0;
pmcModel.CREATETIME = DateTime.Now;
pmcModel.REMARKS = "导入数据";
int pmcid = supportPmcOrder.Db.Insertable(pmcModel).ExecuteReturnIdentity();
logger.Info("插入PMC处理表，处理完成");
TASM_SUPPORT_HIS_Da supportHis = new TASM_SUPPORT_HIS_Da();
TASM_SUPPORT_HIS supportHisModel = new TASM_SUPPORT_HIS();
supportHisModel.SID = sid;
supportHisModel.PRE_USER = supportModel.CONDUCTOR; //上一处理人
supportHisModel.NEXT_USER = supportModel.CONDUCTOR; //下一处理人
supportHisModel.PRE_STATUS = 1; //上一状态，订单初始创建，为0
supportHisModel.NEXT_STATUS = 2; //下一状态，订单初始创建 下一状态为 现场处理，状态0，此处创建订单不做为状态，默认创建 和 创建后未处理状态都是0
supportHisModel.TYPE = 2; //类型，也代表着是哪个表的数据 初始为0
supportHisModel.TID = pmcid; //数据id 根据type 那张表，看是哪一条数据。
supportHisModel.REMARKS = "PMC已处理,等待现场处理,导入数据";
supportHisModel.CREATETIME = DateTime.Now;
supportHis.Db.Insertable(supportHisModel);
logger.Info("插入历史表，PMC处理完成");
TASM_SUPPORT_PERSONAL_Da supportPersonal = new TASM_SUPPORT_PERSONAL_Da();
TASM_SUPPORT_PERSONAL personalModel = new TASM_SUPPORT_PERSONAL();
personalModel.CID = supportModel.CONDUCTOR;
personalModel.DID = supportModel.CONDUCTOR;
personalModel.CREATETIME = DateTime.Now;
personalModel.SID = sid;
personalModel.STATUS = 2;
personalModel.TID = 2;
personalModel.CREATETIME = DateTime.Now;
personalModel.REMARKS = "数据导入";
supportPersonal.Db.Insertable(personalModel);
logger.Info("插入个人处理表，PMC处理完成");
logger.Info("===创建PMC处理结束===！");
return(true);
}
catch (Exception ex)
{
logger.Error("创建Pmc失败" + ex);
return(false);
}
}
/// <summary>
/// 技术处理
/// </summary>
/// <param name="supportModel"></param>
/// <param name="item"></param>
/// <param name="sid"></param>
/// <param name="disid"></param>
/// <returns></returns>
private bool CreateDisposer(TASM_SUPPORT supportModel, ExcelModel item, int sid)
{
try
{
logger.Info("===创建现场处理开始===！");
//step3 现场处理表
TASM_SUPPORT_DISPOSER_Da supportDisposer = new TASM_SUPPORT_DISPOSER_Da();
TASM_SUPPORT_DISPOSER disposerModel = new TASM_SUPPORT_DISPOSER();
disposerModel.SID = sid;
disposerModel.ANALYZEUSER = GetUserIdByName(item.AnalyzeUserName);
disposerModel.ANALYZE = item.Analyze;
disposerModel.SOLUTION = item.Solution;
disposerModel.STATUS = 0;
disposerModel.REMARKS = "导入数据";
disposerModel.RESPONSIBLE = item.Responsible;
disposerModel.DUTY = item.Duty;
disposerModel.BOM = item.Bom;
disposerModel.ORDERMAN = item.OrderMan;
disposerModel.ORDERTIME = ConventDateTime(item.OrderTime);
disposerModel.ISORDER = item.IsOrder == "是" ? 1 : 0;
int disid = supportDisposer.Db.Insertable(disposerModel).ExecuteReturnIdentity();
logger.Info("插入技术处理表完成");
//step4 现场处理
TASM_SUPPORT_HIS_Da supportHis = new TASM_SUPPORT_HIS_Da();
TASM_SUPPORT_HIS supportHisModel = new TASM_SUPPORT_HIS();
supportHisModel.SID = sid;
supportHisModel.PRE_USER = supportModel.CONDUCTOR; //上一处理人
supportHisModel.NEXT_USER = supportModel.CONDUCTOR; //下一处理人
supportHisModel.PRE_STATUS = 0; //上一状态，订单初始创建，为0
supportHisModel.NEXT_STATUS = item.IsPmcPoint == "是" ? 2 : 1; //下一状态，订单初始创建 下一状态为 现场处理，状态0，此处创建订单不做为状态，默认创建 和 创建后未处理状态都是0
supportHisModel.TYPE = 1; //类型，也代表着是哪个表的数据 初始为0
supportHisModel.TID = disid; //数据id 根据type 那张表，看是哪一条数据。
supportHisModel.REMARKS = "技术已处理，等待现场处理,导入数据";
supportHisModel.CREATETIME = DateTime.Now;
supportHis.Db.Insertable(supportHisModel);
logger.Info("插入历史表，技术处理完成");
TASM_SUPPORT_PERSONAL_Da supportPersonal = new TASM_SUPPORT_PERSONAL_Da();
TASM_SUPPORT_PERSONAL personalModel = new TASM_SUPPORT_PERSONAL();
personalModel.CID = supportModel.CONDUCTOR;
personalModel.DID = supportModel.CONDUCTOR;
personalModel.CREATETIME = DateTime.Now;
personalModel.SID = sid;
personalModel.STATUS = 2;
personalModel.TID = 0; //2代表现场完成，PMC 介入， 1则是 现场处理完成，无需PMC，直接跳到现场处理。
personalModel.CREATETIME = DateTime.Now;
personalModel.REMARKS = "数据导入";
supportPersonal.Db.Insertable(personalModel);
logger.Info("插入个人处理表，技术处理完成");
logger.Info("===创建现场处理结束===！");
return(true);
}
catch (Exception ex)
{
logger.Error("创建Disposer失败" + ex);
return(false);
}
}
/// <summary>
/// 创建工单
/// </summary>
/// <param name="daSupport"></param>
/// <param name="item"></param>
/// <returns></returns>
private bool CreateSupport(TASM_SUPPORT_Da daSupport, ExcelModel item, ref int sid, ref TASM_SUPPORT supportModel)
{
try
{
logger.Info("===创建工单开始===！");
//step1 添加工单主表，
supportModel = new Entites.CodeGenerator.TASM_SUPPORT();
supportModel.CREATOR = GetUserIdByName(item.CreateName); //工单初始创建人
supportModel.CONTENT = item.Content; //问题描述
supportModel.TYPE = item.SupportType;
supportModel.SEVERITY = item.Severity;
supportModel.FINDATE = ConventDateTime(item.Createtime);
supportModel.CONDUCTOR = GetUserIdByName(item.ConductorName);
supportModel.STATUS = item.EndPiont;
supportModel.STATE = item.ConductorStatus;
supportModel.MID = GetsMachineByName(item.MachineCode);
supportModel.CODE = GetSupportCode(Project.CODE);
supportModel.TITLE = "导入数据";
supportModel.CREATETIME = DateTime.Now;
sid = daSupport.Db.Insertable(supportModel).ExecuteReturnIdentity();
logger.Info("插入工单表");
//step2 添加历史表
TASM_SUPPORT_HIS_Da supportHis = new TASM_SUPPORT_HIS_Da();
TASM_SUPPORT_HIS supportHisModel = new TASM_SUPPORT_HIS();
supportHisModel.SID = sid;
supportHisModel.PRE_USER = supportModel.CREATOR; //上一处理人
supportHisModel.NEXT_USER = supportModel.CONDUCTOR; //下一处理人
supportHisModel.PRE_STATUS = 0; //上一状态，订单初始创建，为0
supportHisModel.NEXT_STATUS = 0; //下一状态，订单初始创建 下一状态为 现场处理，状态0，此处创建订单不做为状态，默认创建 和 创建后未处理状态都是0
supportHisModel.TYPE = 0; //类型，也代表着是哪个表的数据 初始为0
supportHisModel.TID = sid; //数据id 根据type 那张表，看是哪一条数据。
supportHisModel.REMARKS = "工单创建，等待技术处理,导入数据";
supportHisModel.CREATETIME = DateTime.Now;
supportHis.Db.Insertable(supportHisModel);
logger.Info("插入历史表：创建工单");
logger.Info("===创建工单结束===！");
return(true);
}
catch (Exception ex)
{
logger.Error("创建工单失败" + ex);
return(false);
}
}
private bool InsertHistory(TASM_SUPPORT_PMC model, TASM_SUPPORT_PMC_Da manager, TASM_SUPPORT supportModel, int pmcId, int supportStatus, int nextUser)
{
TASM_SUPPORT_HIS_Da his_manager = new TASM_SUPPORT_HIS_Da();
TASM_SUPPORT_HIS hisModel = new TASM_SUPPORT_HIS();
hisModel.CREATETIME = DateTime.Now;
hisModel.PRE_USER = supportModel.CONDUCTOR;
hisModel.NEXT_USER = nextUser;
hisModel.SID = model.SID;
hisModel.REMARKS = "PMC已处理,等待现场处理";
hisModel.PRE_STATUS = supportModel.STATUS;
hisModel.NEXT_STATUS = supportStatus;
hisModel.TYPE = (int)SupportHisType.PMC跟进;; //tasm_disposer表
hisModel.TID = pmcId;
return(his_manager.CurrentDb.Insert(hisModel));
}
/// <summary>
/// 创建工单
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public bool Create(SupportCreateModel model)
{
DataAccess.TASM_SUPPORT_Da da = new TASM_SUPPORT_Da();
try
{
da.Db.BeginTran();
Logger.LogInformation("=====开始创建工单========");
int sid = 0;
TASM_SUPPORT supportModel = new TASM_SUPPORT();
//插入工单表
if (!InsertSupport(model, da, ref sid, ref supportModel))
{
Logger.LogInformation("插入工单表失败");
da.Db.RollbackTran();
return(false);
}
//插入操作历史表
if (!InsertHistory(supportModel, sid))
{
Logger.LogInformation("插入历史表失败");
da.Db.RollbackTran();
return(false);
}
//添加处理人表
if (!InsertPersonal(supportModel, sid))
{
Logger.LogInformation("插入处理人表失败");
da.Db.RollbackTran();
return(false);
}
//修改附件信息
if (!UpdateAttachment(model, sid))
{
Logger.LogInformation("修改附件信息失败");
da.Db.RollbackTran();
return(false);
}
//添加推送消息
if (!InsertPush(model, sid))
{
Logger.LogInformation("添加推送消息失败");
da.Db.RollbackTran();
return(false);
}
//发送通知-----非推送消息，推送消息 需要windows服务去跑
if (!PushMessage(sid, da))
{
Logger.LogInformation("推送消息失败");
da.Db.RollbackTran();
return(false);
}
Logger.LogInformation("=====结束创建工单========");
da.Db.CommitTran();
this.Msg = "创建成功！";
return(true);
}
catch (Exception e)
{
da.Db.RollbackTran();
Logger.LogInformation("" + e);
this.Msg = "创建工单失败！";
return(false);
}
}
private void btn_star_Click(object sender, EventArgs e)
{
logger.Debug("Debug");
logger.Info("Info");
logger.Error("Error");
logger.Warn("Warn");
string filepath = this.tb_filePath.Text;
IExcelImporter Importer = new ExcelImporter();
var result = Importer.Import <ExcelModel>(filepath);
if (result.Result.Data == null)
{
MessageBox.Show("读取excel失败！" + result.Result.Exception);
return;
}
List <ExcelModel> list = result.Result.Data.ToList();
int i = 0;
foreach (var item in list)
{
TASM_SUPPORT_Da daSupport = new TASM_SUPPORT_Da();
daSupport.Db.BeginTran(); //事务开
i++;
logger.Info("===============导入开始==============" + i);
Log("===============导入开始==============" + i);
int sid = 0; //工单id
TASM_SUPPORT supportModel = new TASM_SUPPORT();
Log("No：" + i + "创建工单-开始");
if (!CreateSupport(daSupport, item, ref sid, ref supportModel))
{
logger.Info("===============导入失败====创建工单失败==========" + item.Content);
Log("No：" + i + "创建工单-失败");
Log("===============导入失败====创建工单失败==========" + item.Content);
daSupport.Db.RollbackTran();
continue;
}
Log("No：" + i + "创建工单-结束 sid:" + sid);
//判断是否有技术处理节点，
if (item.IsDisposerPoint.Trim() == "否" || string.IsNullOrWhiteSpace(item.IsDisposerPoint))
{
//没有的话，继续下一条
Log("===============导入结束=========没有Disposer节点=====" + i);
logger.Info("===============导入结束=========没有Disposer节点=====" + i);
daSupport.Db.CommitTran();
continue;
}
Log("No：" + i + "技术处理-开始");
if (!CreateDisposer(supportModel, item, sid))
{
logger.Info("===============导入失败====创建技术处理失败==========" + item.Content);
Log("No：" + i + "技术处理-失败");
Log("===============导入失败====创建技术处理失败==========" + item.Content);
daSupport.Db.RollbackTran();
continue;
}
Log("No：" + i + "技术处理-结束" + sid);
//既没有PMC节点 也没有 site节点，则表示 没有PMC处理，也没有 现场处理，则该订单直接判断，审核环节也不要了， 直接下一条
if ((item.IsPmcPoint.Trim() == "否" || string.IsNullOrWhiteSpace(item.IsPmcPoint)) && (item.IsSitePoint == "否" || string.IsNullOrWhiteSpace(item.IsSitePoint)))
{
//没有的话，继续下一条
Log("===============导入结束=========没有Pmc节点=====" + i);
logger.Info("===============导入结束=========没有Pmc节点=====" + i);
daSupport.Db.CommitTran();
continue;
}
// 如果是有PMC 节点， 则插入PMC节点， 该情况可能发生，没有PMC节点，但是有site节点。所以 这里判断有PMC则插入，没有则还是要下去判断site节点。
if (item.IsPmcPoint.Trim() == "是")
{
Log("No：" + i + "PMC处理-开始");
if (!CreatePmcOrder(supportModel, item, sid))
{
logger.Info("===============导入失败====PMC处理失败==========" + item.Content);
Log("No：" + i + "PMC处理失败-失败");
Log("===============导入失败====PMC处理失败==========" + item.Content);
daSupport.Db.RollbackTran();
continue;
}
Log("No：" + i + "PMC处理-结束");
}
if (item.IsSitePoint == "否" || string.IsNullOrWhiteSpace(item.IsSitePoint))
{
//没有的话，继续下一条
logger.Info("===============导入结束=========没有site节点=====" + i);
Log("===============导入结束=========没有site节点=====" + i);
daSupport.Db.CommitTran();
continue;
}
Log("No：" + i + "现场处理-开始");
if (!CreateSiteCheck(supportModel, item, sid))
{
logger.Info("===============导入失败====现场处理失败==========" + item.Content);
Log("No：" + i + "现场处理失败-失败");
Log("===============导入失败====现场处理失败==========" + item.Content);
daSupport.Db.RollbackTran();
continue;
}
Log("No：" + i + "现场处理-结束");
if (item.IsPrincipalPoint == "否" || string.IsNullOrWhiteSpace(item.IsPrincipalPoint))
{
logger.Info("===============导入结束=========没有principal节点=====" + i);
Log("===============导入结束=========没有principal节点=====" + i);
daSupport.Db.CommitTran();
continue;
}
if (!CreatePrincipal(supportModel, item, sid))
{
logger.Info("===============导入失败====审核失败==========" + item.Content);
Log("No：" + i + "审核处理失败-失败");
Log("===============导入失败====审核失败==========" + item.Content);
daSupport.Db.RollbackTran();
continue;
}
daSupport.Db.CommitTran();
Log("===============导入结束==============" + i);
logger.Info("===============导入结束==============" + i);
}
}
