/// <summary>
/// 修改工序状态
/// </summary>
/// <param name="entity">实体对象</param>
/// <returns></returns>
public void UpdateStepState(Sale_CustomerEntity entity)
{
IRepository db = this.BaseRepository().BeginTrans();
try
{
db.Update <Sale_CustomerEntity>(entity);
//同步到接单表-工序状态
DZ_OrderEntity dZ_OrderEntity = new DZ_OrderEntity
{
StepState = entity.StepState,
StepDate = DateTime.Now,
Id = entity.OrderId
};
db.Update <DZ_OrderEntity>(dZ_OrderEntity);
db.Commit();
//记录扫码操作记录
TrailRecordEntity recordEntity = new TrailRecordEntity()
{
TrailId = Guid.NewGuid().ToString(),
ObjectSort = 4,
ObjectId = entity.OrderId,
TrackContent = entity.StepName,
CreateUserName = entity.ModifyUserName,
CreateDate = DateTime.Now
};
recordService.SaveH5Form(recordEntity);//全是新增
}
catch (Exception)
{
db.Rollback();
throw;
}
}
/// <summary>
/// 排产（主单）
/// </summary>
/// <param name="keyValue">主键值</param>
/// <param name="entity">实体对象</param>
/// <returns></returns>
public void SavePlanForm(string keyValue, Sale_CustomerEntity entity)
{
try
{
if (!string.IsNullOrEmpty(keyValue))
{
if (entity.StatePlanDate != null || entity.EndPlanDate != null)
{
IRepository db = this.BaseRepository().BeginTrans();
entity.PlanMark = 1;
entity.Modify(keyValue);
db.Update <Sale_CustomerEntity>(entity);
//修改销售单排产状态
DZ_OrderEntity dZ_OrderEntity = new DZ_OrderEntity
{
PlanMark = 1,
};
dZ_OrderEntity.Modify(entity.OrderId);//原生产单实体才对
db.Update <DZ_OrderEntity>(dZ_OrderEntity);
db.Commit();
RecordHelp.AddRecord(4, entity.OrderId, "生产排产：" + entity.StatePlanDate.ToString().Replace(" 0:00:00", "") + "至" + entity.EndPlanDate.ToString().Replace(" 0:00:00", ""));
}
}
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// 报价编辑
/// </summary>
/// <param name="keyValue">主键值</param>
/// <param name="entity">实体对象</param>
/// <returns></returns>
public void SaveMoneyForm(string keyValue, DZ_OrderEntity entity, List <DZ_Money_ItemEntity> entryList)
{
try
{
service.SaveMoneyForm(keyValue, entity, entryList);
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// 保存表单（新增、修改）
/// </summary>
/// <param name="keyValue">主键值</param>
/// <param name="entity">实体对象</param>
/// <returns></returns>
public void SaveForm(string keyValue, DZ_OrderEntity entity)
{
try
{
service.SaveForm(keyValue, entity);
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// 保存表单（新增、修改）
/// </summary>
/// <param name="keyValue">主键值</param>
/// <param name="entity">实体对象</param>
/// <returns></returns>
public void SaveForm(string keyValue, TrailRecordEntity entity)
{
IRepository db = new RepositoryFactory().BaseRepository().BeginTrans();
try
{
switch (entity.ObjectSort)
{
case 1: //商机
ChanceEntity chanceEntity = new ChanceEntity();
chanceEntity.Modify(entity.ObjectId);
db.Update <ChanceEntity>(chanceEntity);
break;
case 2: //客户
CustomerEntity customerEntity = new CustomerEntity();
customerEntity.Modify(entity.ObjectId);
db.Update <CustomerEntity>(customerEntity);
break;
case 3: //经销商
Client_CompanyEntity companyEntity = new Client_CompanyEntity();
companyEntity.Modify(entity.ObjectId);
db.Update <Client_CompanyEntity>(companyEntity);
break;
case 4: //订单
DZ_OrderEntity orderEntity = new DZ_OrderEntity();
orderEntity.Modify(entity.ObjectId);
db.Update <DZ_OrderEntity>(orderEntity);
break;
default:
break;
}
entity.Create();
db.Insert(entity);
db.Commit();
}
catch (Exception)
{
db.Rollback();
throw;
}
}
/// <summary>
/// 推单
/// </summary>
/// <param name="keyValue">主键值</param>
/// <param name="state">状态1推单-1撤单</param>
/// <param name="orderId">销售单id</param>
/// <returns></returns>
public void UpdatePushState(string keyValue, int?state, string orderId)
{
IRepository db = this.BaseRepository().BeginTrans();
try
{
if (!string.IsNullOrEmpty(keyValue))
{
Sale_CustomerEntity entity = new Sale_CustomerEntity()
{
PushMark = state,
PushDate = DateTime.Now,
EndDate = DateTime.Now.AddDays(30).Date,//最迟交付日期
PushUserId = OperatorProvider.Provider.Current().UserId,
PushUserName = OperatorProvider.Provider.Current().UserName
};
entity.Modify(keyValue);
db.Update <Sale_CustomerEntity>(entity);
if (!string.IsNullOrEmpty(orderId))
{
//修改销售单推单状态
DZ_OrderEntity dZ_OrderEntity = new DZ_OrderEntity
{
PushMark = state,
PushDate = DateTime.Now
};
dZ_OrderEntity.Modify(orderId);//原生产单实体才对
db.Update <DZ_OrderEntity>(dZ_OrderEntity);
}
db.Commit();
RecordHelp.AddRecord(4, orderId, "生产推单");
}
}
catch (Exception)
{
db.Rollback();
throw;
}
}
/// <summary>
/// 撤单
/// </summary>
/// <param name="keyValue">主键值</param>
/// <param name="entity">实体对象</param>
/// <returns></returns>
public void SavePushBackForm(string keyValue, Sale_CustomerEntity entity)
{
IRepository db = this.BaseRepository().BeginTrans();
try
{
if (!string.IsNullOrEmpty(keyValue))
{
if (!string.IsNullOrEmpty(entity.PushBackPath))
{
//修改生产单撤单状态
entity.PushMark = -1;
entity.PushDate = DateTime.Now;
entity.PushUserId = OperatorProvider.Provider.Current().UserId;
entity.PushUserName = OperatorProvider.Provider.Current().UserName;
//修改销售单撤单状态
DZ_OrderEntity dZ_OrderEntity = new DZ_OrderEntity
{
PushMark = -1,
PushDate = DateTime.Now,
PushBackReason = entity.PushBackReason,
PushBackPath = entity.PushBackPath
};
dZ_OrderEntity.Modify(entity.OrderId);//原生产单实体才对
db.Update <DZ_OrderEntity>(dZ_OrderEntity);
}
entity.Modify(keyValue);
db.Update <Sale_CustomerEntity>(entity);
db.Commit();
RecordHelp.AddRecord(4, entity.OrderId, "生产撤单");
}
}
catch (Exception)
{
db.Rollback();
throw;
}
}
/// <summary>
/// 发货物流，同步到销售表
/// </summary>
/// <param name="keyValue">主键值</param>
/// <param name="entity">实体对象</param>
/// <returns></returns>
public void SaveLogisticsForm(string keyValue, Buys_OrderEntity entity)
{
IRepository db = this.BaseRepository().BeginTrans();
try
{
if (!string.IsNullOrEmpty(keyValue))
{
entity.Modify(keyValue);
entity.SendLogisticsMark = 1;
entity.SendLogisticsDate = DateTime.Now;
entity.SendLogisticsUserId = OperatorProvider.Provider.Current().UserId;
entity.SendLogisticsUserName = OperatorProvider.Provider.Current().UserName;
db.Update <Buys_OrderEntity>(entity);
//同步到销售单-发货通知状态
DZ_OrderEntity dZ_OrderEntity = new DZ_OrderEntity
{
SendLogisticsMark = 1,
SendLogisticsDate = DateTime.Now,
SendLogisticsUserId = OperatorProvider.Provider.Current().UserId,
SendLogisticsUserName = OperatorProvider.Provider.Current().UserName
};
dZ_OrderEntity.Modify(entity.OrderId);
db.Update <DZ_OrderEntity>(dZ_OrderEntity);
db.Commit();
RecordHelp.AddRecord(4, entity.OrderId, "运输信息：" + entity.LogisticsName + " " + entity.LogisticsNO + " " + entity.LogisticsTel + " " + entity.LogisticsCost);
}
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// 安装
/// </summary>
/// <param name="keyValue">主键值</param>
/// <param name="entity">实体对象</param>
/// <returns></returns>
public void SaveInstallForm(string keyValue, Buys_OrderEntity entity)
{
IRepository db = this.BaseRepository().BeginTrans();
try
{
if (!string.IsNullOrEmpty(keyValue))
{
entity.Modify(keyValue);
entity.SendInstallMark = 1;
entity.SendInstallDate = DateTime.Now;
entity.SendInstallUserId = OperatorProvider.Provider.Current().UserId;
entity.SendInstallUserName = OperatorProvider.Provider.Current().UserName;
db.Update <Buys_OrderEntity>(entity);
//同步到销售单-发货通知状态
DZ_OrderEntity dZ_OrderEntity = new DZ_OrderEntity
{
SendInstallMark = 1,
SendInstallDate = DateTime.Now,
SendInstallUserId = OperatorProvider.Provider.Current().UserId,
SendInstallUserName = OperatorProvider.Provider.Current().UserName
};
dZ_OrderEntity.Modify(entity.OrderId);
db.Update <DZ_OrderEntity>(dZ_OrderEntity);
db.Commit();
RecordHelp.AddRecord(4, entity.OrderId, "安装信息：" + entity.InstallUserName);
}
}
catch (Exception)
{
db.Rollback();
throw;
}
}
/// <summary>
/// 保存表单（新增、修改）
/// </summary>
/// <param name="keyValue">主键值</param>
/// <param name="entity">实体对象</param>
/// <param name="entryList">明细对象</param>
/// <returns></returns>
public void SaveForm(string keyValue, Buys_OrderEntity entity, List <Buys_OrderItemEntity> entryList)
{
IRepository db = this.BaseRepository().BeginTrans();
try
{
if (!string.IsNullOrEmpty(keyValue))
{
//主表
entity.Modify(keyValue);
db.Update(entity);
//明细
db.Delete <Buys_OrderItemEntity>(t => t.OrderId.Equals(keyValue));
foreach (Buys_OrderItemEntity item in entryList)
{
item.Create();
item.OrderId = entity.Id;
db.Insert(item);
}
}
else
{
//新增入库单(自动添加之后，取消使用**************)
//主表
entity.Create();
db.Insert(entity);
coderuleService.UseRuleSeed(entity.CreateUserId, "", ((int)CodeRuleEnum.Buy_Order).ToString(), db);//占用单据号
//明细
foreach (Buys_OrderItemEntity item in entryList)
{
item.Create();
item.OrderId = entity.Id;
db.Insert(item);
}
//同步到接单表-入库状态
DZ_OrderEntity dZ_OrderEntity = new DZ_OrderEntity
{
EnterMark = 1,
EnterDate = DateTime.Now
};
dZ_OrderEntity.Modify(entity.OrderId);
db.Update <DZ_OrderEntity>(dZ_OrderEntity);
//同步到生产表-入库状态
Sale_CustomerEntity produceEntity = new Sale_CustomerEntity
{
EnterMark = 1,
EnterDate = DateTime.Now
};
produceEntity.Modify(entity.ProduceId);
db.Update <Sale_CustomerEntity>(produceEntity);
}
db.Commit();
}
catch (Exception)
{
db.Rollback();
throw;
}
}
/// <summary>
/// 下单
/// </summary>
/// <param name="keyValue">主键值</param>
/// <param name="entity">实体对象</param>
/// <returns></returns>
public void SaveDownForm(string keyValue, Sale_CustomerEntity entity)
{
IRepository db = this.BaseRepository().BeginTrans();
try
{
if (!string.IsNullOrEmpty(keyValue))
{
Sale_CustomerEntity oldEntity = GetEntity(keyValue);
DZ_OrderEntity dZ_OrderEntity = new DZ_OrderEntity();
//原生产单没有下单文件，第一次上传下单文件，则修改下单状态
if (entity.DownMark == 1 && oldEntity.DownMark != 1)// && string.IsNullOrEmpty(oldEntity.DownPath)//不管之前有没有上传都修改下单状态
{
//发微信模板消息---下单之后，给程东彩发消息提醒oA-EC1W1BQZ46Wc8HPCZZUUFbE9M
//订单生成通知（8下单提醒）
TemplateWxApp.SendTemplateNew("oA-EC1W1BQZ46Wc8HPCZZUUFbE9M", "您好，有新的订单需要推单!", entity.OrderTitle, entity.OrderCode, "请进行审核推单。");
RecordHelp.AddRecord(4, entity.OrderId, "生产下单");
if (entity.OrderType == 3)
{
dZ_OrderEntity.PushMark = 1;
dZ_OrderEntity.PushDate = DateTime.Now;
entity.PushMark = 1;
entity.PushDate = DateTime.Now;
RecordHelp.AddRecord(4, entity.OrderId, "客诉单跳过推单");
}
}
if (entity.DownMark == -1 && oldEntity.DownMark != -1)// && string.IsNullOrEmpty(oldEntity.DownPath)//不管之前有没有上传都修改下单状态
{
//给刘一珠改刘庆莉发驳回提醒
string backMsg = TemplateWxApp.SendTemplateReject("oA-EC1bg4U16c63kR6yj51lA5AiM", "您好，下单人驳回订单!", oldEntity.OrderCode, oldEntity.OrderTitle);
RecordHelp.AddRecord(4, entity.OrderId, "生产下单驳回");
entity.DownPath = null;//下单驳回，下单附件路径清空
}
//修改销售单下单状态
dZ_OrderEntity.DownMark = entity.DownMark;
dZ_OrderEntity.DownDate = DateTime.Now;
dZ_OrderEntity.DownUserId = OperatorProvider.Provider.Current().UserId;
dZ_OrderEntity.DownUserName = OperatorProvider.Provider.Current().UserName;
dZ_OrderEntity.DownPath = entity.DownPath;
dZ_OrderEntity.Modify(entity.OrderId);//原生产单实体才对
db.Update <DZ_OrderEntity>(dZ_OrderEntity);
//修改生产单下单状态
entity.DownDate = DateTime.Now;
entity.DownUserId = OperatorProvider.Provider.Current().UserId;
entity.DownUserName = OperatorProvider.Provider.Current().UserName;
entity.Modify(keyValue);
db.Update <Sale_CustomerEntity>(entity);
db.Commit();
}
}
catch (Exception)
{
db.Rollback();
throw;
}
}
/// <summary>
/// 实际发货
/// </summary>
/// <param name="keyValue">主键值</param>
/// <param name="SendOutImg">主键值</param>
/// <returns></returns>
public void UpdateSendState(string keyValue, string SendOutImg)
{
IRepository db = this.BaseRepository().BeginTrans();
try
{
if (!string.IsNullOrEmpty(keyValue))
{
Buys_OrderEntity entity = GetEntity(keyValue);
entity.Modify(keyValue);
entity.SendOutMark = 1;
entity.SendOutImg = SendOutImg;
entity.SendOutDate = DateTime.Now;
entity.SendOutUserId = OperatorProvider.Provider.Current().UserId;
entity.SendOutUserName = OperatorProvider.Provider.Current().UserName;
//this.BaseRepository().Update(entity);
db.Update <Buys_OrderEntity>(entity);
//同步到销售单-发货状态
DZ_OrderEntity dZ_OrderEntity = new DZ_OrderEntity
{
SendOutMark = 1,
SendOutImg = SendOutImg,
SendOutDate = DateTime.Now,
SendOutUserId = entity.SendOutUserId,
SendOutUserName = entity.SendOutUserName
};
dZ_OrderEntity.Modify(entity.OrderId);
db.Update <DZ_OrderEntity>(dZ_OrderEntity);
//同步到生产表-实际发货状态
Sale_CustomerEntity produceEntity = new Sale_CustomerEntity
{
SendOutMark = 1,
SendOutDate = DateTime.Now,
SendOutUserId = entity.SendOutUserId,
SendOutUserName = entity.SendOutUserName
};
produceEntity.Modify(entity.ProduceId);
db.Update <Sale_CustomerEntity>(produceEntity);
//发微信模板消息--给销售人提醒(10实际发货提醒)
if (!string.IsNullOrEmpty(entity.SalesmanUserName))
{
var hsf_CardList = db.IQueryable <Hsf_CardEntity>(t => t.Name.Equals(entity.SalesmanUserName));
if (hsf_CardList.Count() != 0)
{
var hsf_CardEntity = hsf_CardList.First();
//订单生成通知，只有关注公众号的业务员才能收到消息(11实际发货提醒)
string backMsg = TemplateWxApp.SendTemplateSendOut(hsf_CardEntity.OpenId, "您好，您的订单已经发货!", entity.Code, entity.OrderTitle + "：共" + entity.TotalQty + "包。");
if (backMsg != "ok")
{
//业务员没有关注公众号，报错：微信Post请求发生错误！错误代码：43004，说明：require subscribe hint: [ziWtva03011295]
LogHelper.AddLog(entity.SalesmanUserName + "没有关注公众号");//记录日志
}
}
}
db.Commit();//此db需要用到查询销售人
RecordHelp.AddRecord(4, entity.OrderId, "发货");
}
}
catch (Exception)
{
db.Rollback();
throw;
}
}
/// <summary>
/// 发货通知
/// </summary>
/// <param name="keyValue">主键值</param>
/// <param name="entity">实体对象</param>
/// <returns></returns>
public void SaveSend(string keyValue, Buys_OrderEntity entity)
{
IRepository db = this.BaseRepository().BeginTrans();
try
{
if (!string.IsNullOrEmpty(keyValue))
{
Buys_OrderEntity oldEntity = GetEntity(keyValue);
//发货通知时间不为null，老发货通知时间为null
if (entity.SendPlanDate != null && entity.SendPlanDate != oldEntity.SendPlanDate)
{
//发微信模板消息---发货通知之后，给公维才发消息提醒?????
//订单生成通知（10发货通知提醒）
//公维才
TemplateWxApp.SendTemplateSend("oA-EC1Z5tDaD1-ejnQe_l_gJK1Us", "您好，有新的发货通知!", entity.Code, entity.OrderTitle + "，计划发货时间：" + entity.SendPlanDate);
//金志花
TemplateWxApp.SendTemplateSend("oA-EC1UWi8i4sSkHsWV6BK7CuopA", "您好，有新的发货通知!", entity.Code, entity.OrderTitle + "，计划发货时间：" + entity.SendPlanDate);
//牛霞
TemplateWxApp.SendTemplateSend("oA-EC1TDoDKimuejhFlBV1U6M5bI", "您好，有新的发货通知!", entity.Code, entity.OrderTitle + "，计划发货时间：" + entity.SendPlanDate);
//胡鲁鲁
TemplateWxApp.SendTemplateSend("oA-EC1aaKOSNdW2wL8lHSsr3R4Dg", "您好，有新的发货通知!", entity.Code, entity.OrderTitle + "，计划发货时间：" + entity.SendPlanDate);
}
entity.Modify(keyValue);
entity.SendMark = 1;
entity.SendDate = DateTime.Now;
entity.SendUserId = OperatorProvider.Provider.Current().UserId;
entity.SendUserName = OperatorProvider.Provider.Current().UserName;
//this.BaseRepository().Update(entity);
db.Update <Buys_OrderEntity>(entity);
//同步到销售单-发货通知状态
DZ_OrderEntity dZ_OrderEntity = new DZ_OrderEntity
{
SendMark = 1,
SendDate = DateTime.Now,
SendPlanDate = entity.SendPlanDate,
SendUserId = entity.SendUserId,
SendUserName = entity.SendUserName
};
dZ_OrderEntity.Modify(entity.OrderId);
db.Update <DZ_OrderEntity>(dZ_OrderEntity);
//同步到生产表-发货通知状态
Sale_CustomerEntity produceEntity = new Sale_CustomerEntity
{
SendMark = 1,
SendDate = DateTime.Now,
SendPlanDate = entity.SendPlanDate,
SendUserId = entity.SendUserId,
SendUserName = entity.SendUserName
};
produceEntity.Modify(entity.ProduceId);
db.Update <Sale_CustomerEntity>(produceEntity);
db.Commit();
RecordHelp.AddRecord(4, entity.OrderId, "发货通知：" + entity.SendPlanDate.ToString().Replace(" 0:00:00", ""));
}
}
catch (Exception)
{
db.Rollback();
throw;
}
}
public ActionResult SaveSigned(string keyValue, DZ_OrderEntity entity)
{
dz_orderbll.SaveSigned(keyValue, entity);
return(Success("操作成功。"));
}
/// <summary>
/// 保存生产单主单
/// </summary>
/// <param name="orderEntity">实体对象</param>
/// <returns></returns>
public static void SaveSaleMain(IRepository db, DZ_OrderEntity orderEntity)
{
try
{
//判断是否创建过这个生产单Id（跟生产编号一致,方便实体查询）
Sale_CustomerEntity oldSale = db.FindEntity <Sale_CustomerEntity>(orderEntity.Code);
//没创建过的才新增，避免下单不及时创建两个生产单初始单
if (oldSale == null)
{
//自动创建【生产单】主单部分
Sale_CustomerEntity sale_CustomerEntity = new Sale_CustomerEntity
{
ProduceCode = orderEntity.Code, //生产单号默认和销售单号一样
OrderId = orderEntity.Id,
OrderCode = orderEntity.Code, //销售单号
OrderTitle = orderEntity.OrderTitle,
OrderType = orderEntity.OrderType,
CompanyId = orderEntity.CompanyId,
CompanyName = orderEntity.CompanyName,
CustomerId = orderEntity.CustomerId,
CustomerName = orderEntity.CustomerName,
SalesmanUserId = orderEntity.SalesmanUserId,
SalesmanUserName = orderEntity.SalesmanUserName,
CustomerTelphone = orderEntity.CustomerTelphone,
SendPlanDate = orderEntity.SendPlanDate,
Address = orderEntity.Address,
ShippingType = orderEntity.ShippingType,
Carrier = orderEntity.Carrier,
//MoneyOkMark = orderEntity.MoneyOkMark == null ? 0 : orderEntity.MoneyOkMark,//报价审核
MoneyOkMark = orderEntity.MoneyOkMark,
MoneyOkDate = orderEntity.MoneyOkDate
};
sale_CustomerEntity.Create();//付款时间
//主表
db.Insert(sale_CustomerEntity);
//生成生产单id二维码
string url = "http://www.sikelai.cn/WeChatManage/Produce/StepSweepcode?id=" + sale_CustomerEntity.ProduceId;
CommonHelper.QRCode(url, sale_CustomerEntity.ProduceCode);
if (sale_CustomerEntity.MoneyOkMark == 1)
{
//发微信模板消息---财务已经报价审核并收款确认之后，给张宝莲发消息提醒oA-EC1bJnd0KFBuOy0joJvUOGwwk
//订单生成通知（7下单提醒）
TemplateWxApp.SendTemplateNew("oA-EC1bJnd0KFBuOy0joJvUOGwwk",
"您好，有新的订单需要下单!", sale_CustomerEntity.OrderTitle, sale_CustomerEntity.OrderCode, "请进行生产下单。");
}
RecordHelp.AddRecord(4, orderEntity.Id, "初始化生产单");
}
else
{
//客诉单需要修改报价审核状态
oldSale.MoneyOkMark = orderEntity.MoneyOkMark;
oldSale.MoneyOkDate = orderEntity.MoneyOkDate;
oldSale.Modify(orderEntity.Code);
db.Update(oldSale);
}
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// 保存生产单主单
/// </summary>
/// <param name="orderEntity">实体对象</param>
/// <returns></returns>
public static void SaveDZOrder(IRepository db, DZSH_OrderEntity orderEntity)
{
try
{
//自动创建【生产单】主单部分
DZ_OrderEntity dzEntity = new DZ_OrderEntity
{
Code = orderEntity.Code,//默认和客诉单号一样
OrderTitle = orderEntity.OrderTitle,
OrderType = orderEntity.OrderType,
CompanyId = orderEntity.CompanyId,
CompanyName = orderEntity.CompanyName,
CustomerId = orderEntity.CustomerId,
CustomerName = orderEntity.CustomerName,
CustomerTelphone = orderEntity.CustomerTelphone,
DesignerUserName = orderEntity.DesignerUserName,
DesignerTelphone = orderEntity.DesignerTelphone,
Address = orderEntity.Address,
SalesmanUserId = orderEntity.SalesmanUserId,
SalesmanUserName = orderEntity.SalesmanUserName,
ShippingType = orderEntity.ShippingType,
Carrier = orderEntity.Carrier,
CreatePath = orderEntity.CreatePath,
Description = orderEntity.Description,
Accounts = 0,
FrontMark = 0,
AfterMark = 0,
MonthMark = 0,
Id = orderEntity.Id,
CreateDate = DateTime.Now,
CreateUserId = OperatorProvider.Provider.Current().UserId,
CreateUserName = OperatorProvider.Provider.Current().UserName,
CheckTuMark = 0, //审图
ChaiMark = 0, //拆单
CheckMark = 0, //审核
MoneyMark = 0, //报价
MoneyOkMark = 0, //报价审核
PaymentState = 1, //未收款
MoneyAccounts = 0, //报价金额
ReceivedAmount = 0, //收款金额
DownMark = 0, //下单
PushMark = 0, //推单
EnterMark = 0, //入库
SendMark = 0, //发货通知
SendOutMark = 0, //实际发货
SignedMark = 0, //签收
OverMark = 0, //结束完成
DeleteMark = 0,
EnabledMark = 1
};
//主表
db.Insert(dzEntity);
//发微信模板消息---接单之后，给审图人提醒--刘明存oA-EC1WVqHl_gsBM3We2rgOHIMEQ
//订单生成通知（审图提醒）
//TemplateWxApp.SendTemplateNew("oA-EC1WVqHl_gsBM3We2rgOHIMEQ", "您好，有新的订单需要审图!", dzEntity.OrderTitle, dzEntity.Code, "请进行审图。");
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// 保存表单（新增、修改）
/// </summary>
/// <param name="keyValue">主键值</param>
/// <param name="entity">实体对象</param>
/// <returns></returns>
public void SaveForm(string keyValue, DZSH_OrderEntity entity)
{
IRepository db = new RepositoryFactory().BaseRepository().BeginTrans();
try
{
if (!string.IsNullOrEmpty(keyValue))
{
//先拿到老的客诉单
DZSH_OrderEntity oldEntity = GetEntity(keyValue);
if (entity.NeedSale == 1 && oldEntity.NeedSale == 0)
{
//改为生产之后，创建销售单
CreateDZOrder.SaveDZOrder(db, entity);
//发微信模板消息---客诉单接单之后，给审图人提醒--刘琛oA-EC1X6RWfW1_DNJ_VNiA3uhOYg
//生成销售单------再通知（审图提醒）
TemplateWxApp.SendTemplateNew("oA-EC1X6RWfW1_DNJ_VNiA3uhOYg", "您好，有新的订单需要审图!", entity.OrderTitle, entity.Code, "请进行审图。");
}
else
{
//先拿到老的销售单
DZ_OrderEntity oldDZEntity = dzService.GetEntity(keyValue);
if (oldDZEntity != null)
{
//如果上传的文件路径变化，判断销售单中的审图状态是否已经审图，已经审图，不能修改文件，需要研发驳回！
if (entity.CreatePath != oldEntity.CreatePath && oldDZEntity.CheckTuMark == 1)
{
throw new Exception("请联系研发审图驳回，再重新上传文件！");
}
DZ_OrderEntity dzEntity = new DZ_OrderEntity
{
OrderTitle = entity.OrderTitle,
OrderType = entity.OrderType,
CompanyId = entity.CompanyId,
CompanyName = entity.CompanyName,
CustomerId = entity.CustomerId,
CustomerName = entity.CustomerName,
CustomerTelphone = entity.CustomerTelphone,
DesignerUserName = entity.DesignerUserName,
DesignerTelphone = entity.DesignerTelphone,
Address = entity.Address,
SalesmanUserId = entity.SalesmanUserId,
SalesmanUserName = entity.SalesmanUserName,
ShippingType = entity.ShippingType,
Carrier = entity.Carrier,
CreatePath = entity.CreatePath,
Description = entity.Description,
};
oldDZEntity.Modify(keyValue);
//同步销售单
db.Update <DZ_OrderEntity>(dzEntity);//重点关注的是路径是否同步
}
}
entity.Modify(keyValue);
//更新
db.Update <DZSH_OrderEntity>(entity);
db.Commit();
RecordHelp.AddRecord(4, entity.Id, "客诉单编辑");
}
else
{
entity.Create();
db.Insert <DZSH_OrderEntity>(entity);
coderuleService.UseRuleSeed(entity.CreateUserId, "", ((int)CodeRuleEnum.DZSH_Order).ToString(), db);//占用单据号
if (entity.NeedSale == 1)
{
//创建新的销售单
CreateDZOrder.SaveDZOrder(db, entity);
//发微信模板消息---客诉单接单之后，给审图人提醒--刘琛oA-EC1X6RWfW1_DNJ_VNiA3uhOYg
//生成销售单------再通知（审图提醒）
TemplateWxApp.SendTemplateNew("oA-EC1X6RWfW1_DNJ_VNiA3uhOYg", "您好，有新的订单需要审图!", entity.OrderTitle, entity.Code, "请进行审图。");
}
db.Commit();
RecordHelp.AddRecord(4, entity.Id, "客诉接单");
//胡鲁鲁
TemplateWxApp.SendTemplateNew("oA-EC1aaKOSNdW2wL8lHSsr3R4Dg", "您好，有新的客诉单!", entity.OrderTitle, entity.Code, "请进行处理。");
//邵明钊
TemplateWxApp.SendTemplateNew("oA-EC1eudNmGSxra3-c5HJrGGTtk", "您好，有新的客诉单!", entity.OrderTitle, entity.Code, "请进行处理。");
}
}
catch (Exception)
{
db.Rollback();
throw;
}
}
/// <summary>
/// 柜体扫码包装之后，g根据生产单信息，创建入库单主单
/// </summary>
/// <param name="entity">实体对象</param>
/// <returns></returns>
public void SaveBuyMain(Sale_CustomerEntity entity)
{
try
{
IRepository db = new RepositoryFactory().BaseRepository().BeginTrans();
Buys_OrderEntity buysEntity = db.FindEntity <Buys_OrderEntity>(t => t.Id == entity.OrderCode);//入库单号同销售订单编号
//入库单不存在，才初始化
if (buysEntity == null)
{
//获取销售单收款状态
DZ_OrderEntity orderEntity = db.FindEntity <DZ_OrderEntity>(t => t.Id == entity.OrderId);
if (orderEntity != null)
{
Buys_OrderEntity buys_OrderEntity = new Buys_OrderEntity()
{
Code = entity.OrderCode,
OrderId = entity.OrderId,
OrderCode = entity.OrderCode,
OrderType = entity.OrderType,
OrderTitle = entity.OrderTitle,
ProduceId = entity.ProduceId,
ProduceCode = entity.ProduceCode,
CompanyId = entity.CompanyId,
CompanyName = entity.CompanyName,
CustomerId = entity.CustomerId,
CustomerName = entity.CustomerName,
SalesmanUserId = entity.SalesmanUserId,
SalesmanUserName = entity.SalesmanUserName,
CustomerTelphone = entity.CustomerTelphone,
Address = entity.Address,
ShippingType = entity.ShippingType,
Carrier = entity.Carrier,
SendPlanDate = entity.SendPlanDate,
PaymentState = orderEntity.PaymentState, //确认是否全部收款
PaymentDate = orderEntity.PaymentDate,
AfterMark = orderEntity.AfterMark, //确认是否收取尾款
};
//材料是否选择，判断需要入库
if (entity.GuiTiMark == 1)
{
buys_OrderEntity.GuiEnterMark = 0;//柜体包装进行中
}
if (entity.MenBanMark == 1)
{
buys_OrderEntity.MenEnterMark = 0;//门板
}
if (entity.WuJinMark == 1)
{
buys_OrderEntity.WuEnterMark = 0;//五金
}
if (entity.WaiXieMark == 1)
{
buys_OrderEntity.WaiEnterMark = 0;//外协
}
buys_OrderEntity.Create();
//新增入库单主表
this.BaseRepository().Insert(buys_OrderEntity);
}
}
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// 分柜体，门板，五金，添加入库之后，判断是否完全入库
/// </summary>
/// <param name="itemEntity">实体对象</param>
/// <returns></returns>
public void SaveInForm(Buys_OrderItemEntity itemEntity)
{
IRepository db = new RepositoryFactory().BaseRepository().BeginTrans();
try
{
Buys_OrderItemEntity oldItemEntity = GetDetail(itemEntity.OrderId, itemEntity.SortCode);
Buys_OrderEntity buyEntity = GetEntity(itemEntity.OrderId);
//先删除再创建
if (oldItemEntity != null)
{
db.Delete <Buys_OrderItemEntity>(oldItemEntity.OrderEntryId);
buyEntity.TotalQty -= oldItemEntity.Qty;//减去老库存
if (itemEntity.Qty == 0)
{
//等于0的情况，直接删掉当前入库记录,当前材料的，入库状态改成null
switch (itemEntity.SortCode)
{
case 1: buyEntity.GuiEnterMark = -1; break;
case 2: buyEntity.MenEnterMark = -1; break;
case 3: buyEntity.WuEnterMark = -1; break;
case 4: buyEntity.WaiEnterMark = -1; break;
default:
break;
}
}
}
if (itemEntity.Qty > 0)
{
//新增入库单从表，新增要新增，初始化id，用户跳过
itemEntity.Create();
db.Insert <Buys_OrderItemEntity>(itemEntity);
buyEntity.TotalQty += itemEntity.Qty; //加上新库存
//修改入库状态，分柜体，门板，五金，外协
switch (itemEntity.SortCode)
{
case 1: buyEntity.GuiEnterMark = 1; break;
case 2: buyEntity.MenEnterMark = 1; break;
case 3: buyEntity.WuEnterMark = 1; break;
case 4: buyEntity.WaiEnterMark = 1; break;
default:
break;
}
//判断是否完全入库
if (buyEntity.GuiEnterMark == 0 || buyEntity.MenEnterMark == 0 || buyEntity.WuEnterMark == 0 || buyEntity.WaiEnterMark == 0)
{
//还没有完全入库
buyEntity.AllEnterMark = 0;
}
else
{
//完全入库修改状态
buyEntity.AllEnterMark = 1;
buyEntity.AllEnterDate = DateTime.Now;
//同步到接单表-入库状态
DZ_OrderEntity dZ_OrderEntity = new DZ_OrderEntity
{
EnterMark = 1,
EnterDate = DateTime.Now
};
dZ_OrderEntity.Modify(buyEntity.OrderId);
db.Update <DZ_OrderEntity>(dZ_OrderEntity);
//同步到生产表-入库状态
Sale_CustomerEntity produceEntity = new Sale_CustomerEntity
{
EnterMark = 1,
EnterDate = DateTime.Now
};
produceEntity.Modify(buyEntity.ProduceId);
db.Update <Sale_CustomerEntity>(produceEntity);
string wk = "";
//发微信模板消息--给销售人提醒(完全入库提醒)
if (buyEntity.PaymentState == 3 || buyEntity.AfterMark == 0)
{
//发微信模板消息---完全入库+（收齐尾款或者不需要收取尾款）之后，给胡鲁鲁发消息提醒????给程东彩发全部入库提醒
//订单生成通知（9完全入库提醒）
TemplateWxApp.SendTemplateAllIn("oA-EC1W1BQZ46Wc8HPCZZUUFbE9M", "您好，有新的订单已经入库!", buyEntity.OrderTitle, "共" + buyEntity.TotalQty + "包，请进行发货通知");
if (buyEntity.CompanyId == "0e4ad85a-7bd3-4cba-a390-26ba6d3bf6a2")
{
//整装部订单全部入库，给戴宝华提醒
TemplateWxApp.SendTemplateAllIn("oA-EC1ZrUuePIU9bIapbYnAVe6EU", "您好，有新的订单已经入库!", buyEntity.OrderTitle, "共" + buyEntity.TotalQty + "包，请进行发货通知");
}
}
else
{
wk = "请确认尾款。";
}
//发微信模板消息--给销售人提醒(完全入库提醒)
if (!string.IsNullOrEmpty(buyEntity.SalesmanUserName))
{
var hsf_CardList = db.IQueryable <Hsf_CardEntity>(t => t.Name.Equals(buyEntity.SalesmanUserName));
if (hsf_CardList.Count() != 0)
{
var hsf_CardEntity = hsf_CardList.First();
//订单生成通知，只有关注公众号的业务员才能收到消息(8完全入库提醒)
string backMsg = TemplateWxApp.SendTemplateAllIn(hsf_CardEntity.OpenId, "您好，您的订单已经全部入库!", buyEntity.Code, buyEntity.OrderTitle + "：共" + buyEntity.TotalQty + "包。" + wk);
if (backMsg != "ok")
{
//业务员没有关注公众号，报错：微信Post请求发生错误！错误代码：43004，说明：require subscribe hint: [ziWtva03011295]
LogHelper.AddLog(buyEntity.SalesmanUserName + "没有关注公众号");//记录日志
}
}
}
}
}
buyEntity.Modify(buyEntity.Id);
db.Update <Buys_OrderEntity>(buyEntity);
db.Commit();
RecordHelp.AddRecord(4, buyEntity.OrderId, itemEntity.ProductName + "入库" + itemEntity.Qty + "包");
}
catch (Exception)
{
db.Rollback();
throw;
}
}
/// <summary>
/// 保存表单（新增、修改）
/// </summary>
/// <param name="keyValue">主键值</param>
/// <param name="entity">实体对象</param>
/// <returns></returns>
public void UpdateStateForm(string keyValue, ReceivableEntity entity)
{
ICashBalanceService icashbalanceservice = new CashBalanceService();
DZ_OrderEntity orderEntity = orderIService.GetEntity(entity.OrderId);
IRepository db = new RepositoryFactory().BaseRepository().BeginTrans();
try
{
if (!string.IsNullOrEmpty(keyValue))
{
ReceivableEntity oldEntity = GetEntity(keyValue);
//第一次确认付款才真正修改金额
if (entity.EnabledMark == 1 && oldEntity.EnabledMark != 1)
{
//更改订单状态
orderEntity.ReceivedAmount = orderEntity.ReceivedAmount + entity.PaymentPrice; //收款金额
orderEntity.PaymentDate = oldEntity.PaymentTime; //收款日期=业务员填的日期
//已收款金额=订单金额
if (orderEntity.ReceivedAmount == orderEntity.Accounts)
{
orderEntity.PaymentState = 3;//全部收款
//发微信模板消息
if (!string.IsNullOrEmpty(oldEntity.CreateUserName))
{
var hsf_CardList = db.IQueryable <Hsf_CardEntity>(t => t.Name.Equals(oldEntity.CreateUserName));//发送给创建订单的人，店长代替店员创建，所以店长能看见拆单报价
if (hsf_CardList.Count() != 0)
{
var hsf_CardEntity = hsf_CardList.First();
//发微信模板消息---营销收款之后，给销售员提醒--（收款确认提醒：已全部收款）
string backMsg = TemplateWxApp.SendTemplateReceivableOk(hsf_CardEntity.OpenId, "您好，有的收款已经确认!", "通过", "已全部收款");
RecordHelp.AddRecord(4, entity.OrderId, "收款确认（全部收款）");
if (backMsg != "ok")
{
//业务员没有关注公众号，报错：微信Post请求发生错误！错误代码：43004，说明：require subscribe hint: [ziWtva03011295]
LogHelper.AddLog(entity.SalesmanUserName + "没有关注公众号");//记录日志
}
}
}
//全部收款之后更新【入库单】中的【尾款】状态
Buys_OrderEntity buyEntity = buyIService.GetEntityByOrderId(orderEntity.Id);
if (buyEntity != null)
{
buyEntity.PaymentDate = DateTime.Now; //付款确认时间
buyEntity.PaymentState = 3; //全部收款
db.Update(buyEntity);
}
}
else
{
orderEntity.PaymentState = 2;//部分收款
//发微信模板消息
if (!string.IsNullOrEmpty(oldEntity.CreateUserName))
{
var hsf_CardList = db.IQueryable <Hsf_CardEntity>(t => t.Name.Equals(oldEntity.CreateUserName));//发送给创建订单的人，店长代替店员创建，所以店长能看见拆单报价
if (hsf_CardList.Count() != 0)
{
var hsf_CardEntity = hsf_CardList.First();
//发微信模板消息---营销收款之后，给销售员提醒--（收款确认提醒：部分收款）
string backMsg = TemplateWxApp.SendTemplateReceivableOk(hsf_CardEntity.OpenId, "您好，您的收款已经确认!", "通过", oldEntity.Code + "部分收款");
RecordHelp.AddRecord(4, entity.OrderId, "收款确认（部分收款）");
if (backMsg != "ok")
{
//业务员没有关注公众号，报错：微信Post请求发生错误！错误代码：43004，说明：require subscribe hint: [ziWtva03011295]
LogHelper.AddLog(entity.SalesmanUserName + "没有关注公众号");//记录日志
}
}
}
}
db.Update(orderEntity);
//修改【下单状态】，第一次收款的时候才创建
if (orderEntity.DownMark != 1)
{
//付了预付款，自动创建【生产单】主单部分*****************
Sale_Customer_Main.SaveSaleMain(db, orderEntity);//如果下单不及时，可能重复创建
}
}
if (entity.EnabledMark == -1 && oldEntity.EnabledMark != -1)
{
RecordHelp.AddRecord(4, entity.OrderId, "收款确认驳回");
var hsf_CardList = db.IQueryable <Hsf_CardEntity>(t => t.Name.Equals(oldEntity.CreateUserName));//发送给创建订单的人，店长代替店员创建，所以店长能看见拆单报价
if (hsf_CardList.Count() != 0)
{
var hsf_CardEntity = hsf_CardList.First();
//发微信模板消息---营销收款之后，给销售员提醒--（收款确认提醒：部分收款）
string backMsg = TemplateWxApp.SendTemplateReject(hsf_CardEntity.OpenId, "您好，收款确认人驳回订单!", oldEntity.Code, oldEntity.OrderTitle);
if (backMsg != "ok")
{
//业务员没有关注公众号，报错：微信Post请求发生错误！错误代码：43004，说明：require subscribe hint: [ziWtva03011295]
LogHelper.AddLog(entity.SalesmanUserName + "没有关注公众号");//记录日志
}
}
}
entity.Modify(keyValue);
this.BaseRepository().Update(entity);
}
db.Commit();
}
catch (Exception)
{
db.Rollback();
throw;
}
}
public ActionResult SaveBackForm(string keyValue, DZ_OrderEntity entity)
{
dz_orderbll.BackForm(keyValue, entity);
return(Success("撤销成功。"));
}
