/// <summary>
/// 获取消费记录的餐类型
/// </summary>
/// <param name="listTimeSpan"></param>
/// <param name="dtConsumeTime"></param>
/// <returns></returns>
string getConsumeMealType(List<CodeMaster_cmt_Info> listTimeSpan, DateTime dtConsumeTime)
{
string strLunch = listTimeSpan.Find(x => x.cmt_cKey2 == Common.DefineConstantValue.MealType.Lunch.ToString()).cmt_cRemark;
string strSupper = listTimeSpan.Find(x => x.cmt_cKey2 == Common.DefineConstantValue.MealType.Supper.ToString()).cmt_cRemark;
TimeSpan tsLunch = TimeSpan.Parse(strLunch);
TimeSpan tsSupper = TimeSpan.Parse(strSupper);
TimeSpan tsConsume = TimeSpan.Parse(dtConsumeTime.ToString("HH:mm:ss"));
if (tsConsume < tsLunch)
{
return Common.DefineConstantValue.MealType.Breakfast.ToString();
}
else if (tsConsume >= tsLunch && tsConsume < tsSupper)
{
return Common.DefineConstantValue.MealType.Lunch.ToString();
}
else
{
return Common.DefineConstantValue.MealType.Supper.ToString();
}
}
public static bool DecodeCommand(Player Plr,ref List<string> Values, List<GmCommandHandler> Handlers,List<GmCommandHandler> BaseHandlers)
{
string Command = GetString(ref Values);
//Log.Success("DecodeCommand", "Command = " + Command);
GmCommandHandler Handler = Handlers.Find(com => com != null && com.Name.StartsWith(Command));
if(Handler == null) // Si la commande n'existe pas , on affiche la liste des commandes
{
List<GmCommandHandler> Base = Handlers == null ? BaseHandlers : Handlers;
PrintCommands(Plr,Base);
return true;
}
else // Le Handler Existe
{
if(Handler.GmLevel > Plr.GmLevel) // GmLevel insuffisant
{
Plr.SendMessage(0, "", "Invalid GM Level : < " + Handler.GmLevel, SystemData.ChatLogFilters.CHATLOGFILTERS_SHOUT);
return false;
}
if(Handler.ValueCount > Values.Count) // Nombre d'arguments insuffisant
{
Plr.SendMessage(0, "", "Invalid Arguments Count : " + Handler.Description, SystemData.ChatLogFilters.CHATLOGFILTERS_SHOUT);
return true;
}
if(Handler.Handlers != null && Handler.Handlers.Count > 0)
{
return DecodeCommand(Plr,ref Values,Handler.Handlers,Handlers);
}
if(Handler.Handler != null)
{
return Handler.Handler.Invoke(Plr,ref Values);
}
}
return false;
}
/// <summary>
/// 消费数据分析
/// </summary>
/// <returns></returns>
bool cosumeRecordAnalysis()
{
this._IsRunning = true;
bool res = true;
try
{
bool canStart = false;
TimeSpan tsNow = new TimeSpan(DateTime.Now.Hour, DateTime.Now.Minute, DateTime.Now.Second);
foreach (TimeSpan item in this._ListCollectSpan)
{
TimeSpan tsEnd = new TimeSpan();
if (item.Hours == 23)
{
tsEnd = new TimeSpan(23, 59, 59);
}
else
{
tsEnd = new TimeSpan(item.Hours + 1, item.Minutes, 0);
}
if (tsNow > item && tsNow < tsEnd)
{
canStart = true;
break;
}
}
if (!canStart)
{
this._IsRunning = false;
return false;
}
//消费机最后同步时间
DateTime dtMacSync = DateTime.MinValue;
//找出消费机主档信息，检查是否全部收数完毕，是则进行平数处理，否则不操作
#region 找出消费机主档信息，检查是否全部收数完毕，是则进行平数处理，否则不操作
List<ConsumeMachineMaster_cmm_Info> listMachineInfos = this._IConsumeMachineBL.SearchRecords(new ConsumeMachineMaster_cmm_Info()
{
cmm_cStatus = Common.DefineConstantValue.ConsumeMachineStatus.Using.ToString(),
});
if (listMachineInfos == null)
{
this._IsRunning = false;
return false;
}
else
{
if (listMachineInfos != null && listMachineInfos.Count > 0)
{
if (listMachineInfos != null && listMachineInfos.Count > 0)
{
dtMacSync = listMachineInfos[0].cmm_dLastAccessTime;
}
}
List<ConsumeMachineMaster_cmm_Info> listUnSyncMachineInfos = listMachineInfos.Where(x =>
x.cmm_dLastAccessTime.Hour != dtMacSync.Hour).ToList();
if (listUnSyncMachineInfos != null && listUnSyncMachineInfos.Count > 0)
{
this._IsRunning = false;
return false;
}
List<ConsumeMachineMaster_cmm_Info> listUnConnMachineInfos = listMachineInfos.Where(x =>
x.cmm_lIsActive == true
&& x.cmm_lLastAccessRes == false
).ToList();
if (listUnConnMachineInfos == null || (listUnConnMachineInfos != null && listUnConnMachineInfos.Count > 0))
{
this._IsRunning = false;
return false;
}
}
#endregion
//就餐时段
#region 学生真实就餐时段列表
List<CodeMaster_cmt_Info> listMealTimeSpan = this._ICodeMasterBL.SearchRecords(new CodeMaster_cmt_Info()
{
cmt_cKey1 = Common.DefineConstantValue.CodeMasterDefine.KEY1_MealTimeSpan
});
if (listMealTimeSpan == null || (listMealTimeSpan != null && listMealTimeSpan.Count < 1))
{
this._IsRunning = false;
return false;
}
#endregion
//定餐时段
#region 学生定餐设置生成时间列表
List<CodeMaster_cmt_Info> listBookingMealTimeSpan = this._ICodeMasterBL.SearchRecords(new CodeMaster_cmt_Info()
{
cmt_cKey1 = Common.DefineConstantValue.CodeMasterDefine.KEY1_BWListUploadInterval
});
if (listBookingMealTimeSpan == null || (listBookingMealTimeSpan != null && listBookingMealTimeSpan.Count < 1))
{
this._IsRunning = false;
return false;
}
#endregion
//未结算的未可确认扣费的消费记录
#region 获取当前所有未结算的未可确认扣费的消费记录
List<PreConsumeRecord_pcs_Info> listUnSettlePreCost = this._IPreConsumeRecordBL.SearchRecords(new PreConsumeRecord_pcs_Info()
{
pcs_cConsumeType = Common.DefineConstantValue.ConsumeMoneyFlowType.IndeterminateCost.ToString()
});
List<PreConsumeRecord_pcs_Info> listWaitSettlePreCost = this._IPreConsumeRecordBL.SearchRecords(new PreConsumeRecord_pcs_Info()
{
pcs_cConsumeType = Common.DefineConstantValue.ConsumeMoneyFlowType.AdvanceMealCost.ToString()
});
listUnSettlePreCost.AddRange(listWaitSettlePreCost);
if (listUnSettlePreCost != null)
{
//条件分开两次进行筛选，方便数据观察
listUnSettlePreCost = listUnSettlePreCost.Where(x =>
x.pcs_lIsSettled == false//需要状态为未结算
).ToList();
listUnSettlePreCost = listUnSettlePreCost.Where(x =>
x.pcs_dConsumeDate <= dtMacSync//使用消费机最后同步时间之前的未结算数据进行同步
).ToList();
}
#endregion
//对冲平数记录
#region 获取当前所有对冲数据记录
List<PreConsumeRecord_pcs_Info> listHedge = this._IPreConsumeRecordBL.SearchRecords(new PreConsumeRecord_pcs_Info()
{
pcs_cConsumeType = Common.DefineConstantValue.ConsumeMoneyFlowType.HedgeFund.ToString()
});
listHedge = listHedge.Where(x =>
x.pcs_lIsSettled == false//需要为未结算状态
&& x.pcs_dConsumeDate <= dtMacSync//需要为消费机最后同步前的数据
).ToList();
#endregion
//未结算的消费记录
#region 获取当前所有状态为未结算的打卡消费数据
List<ConsumeRecord_csr_Info> listUnSettleCardCost = this._IConsumeRecordBL.SearchRecords(new ConsumeRecord_csr_Info()
{
IsSettled = false
});
if (listUnSettleCardCost != null && listUnSettleCardCost.Count > 0)
{
listUnSettleCardCost = listUnSettleCardCost.Where(x =>
x.csr_dConsumeDate <= dtMacSync//需要为消费机最后同步前的数据
).ToList();
}
#endregion
/*<Start-------------------------------------------用于最后数据处理的容器-------------------------------------------------->*/
//待更新的打卡消费记录
List<ConsumeRecord_csr_Info> listUpdate_Consume = new List<ConsumeRecord_csr_Info>();
//待更新的预扣费记录
List<PreConsumeRecord_pcs_Info> listUpdate_PreCost = new List<PreConsumeRecord_pcs_Info>();
//无需要处理预扣费的消费记录
List<ConsumeRecord_csr_Info> listUpdate_UnMealConsume = new List<ConsumeRecord_csr_Info>();
//待删除的多余预扣费记录
List<PreConsumeRecord_pcs_Info> listDelete_PreCost = new List<PreConsumeRecord_pcs_Info>();
/*<End-------------------------------------------用于最后数据处理的容器--------------------------------------------------->*/
if (listUnSettleCardCost != null && listUnSettleCardCost.Count > 0)//存在未结算处理的消费记录时
{
#region 处理打卡数据（定餐打卡，饮料打卡，加菜打卡，热水打卡）
//逐条消费数据进行比对，用作处理未确认扣款记录和对冲记录
foreach (ConsumeRecord_csr_Info consumeItem in listUnSettleCardCost)
{
if (consumeItem.csr_cConsumeType == DefineConstantValue.ConsumeMachineType.StuSetmeal.ToString())
{
#region 处理定餐消费记录
//判断为定餐消费记录，用于消除未确定消费记录
List<PreConsumeRecord_pcs_Info> listResPreCost = listUnSettlePreCost.Where(x =>
x.pcs_cUserID == consumeItem.csr_cCardUserID//需为消费用户对应ID
&& x.MealType == consumeItem.csr_cMealType//餐类型需要相同
//&& x.pcs_dConsumeDate.Date == consumeItem.csr_dConsumeDate.Date
&& x.pcs_dAddDate.Date == consumeItem.csr_dConsumeDate.Date//以添加时间为准，找出
&& Math.Abs(x.pcs_fCost) == Math.Abs(consumeItem.csr_fConsumeMoney)//消费金额需一致
).ToList();
if (listResPreCost != null && listResPreCost.Count > 0)//！要注意这里会不会搜索出两条记录出来
{
if (listResPreCost.Count > 1)
{
bool lSign = true;//标识特殊case：同一条打卡消费记录对应两条定餐未结算记录
}
//消费数据符合该条未确认数据记录的条件，更新该条消费记录的状态为已结，并更新对应的未确定扣费定餐记录置为已结状态
consumeItem.csr_lIsSettled = true;
consumeItem.csr_dSettleTime = DateTime.Now;
listUpdate_Consume.Add(consumeItem);
//按升序排序多条待付款预扣费记录
List<PreConsumeRecord_pcs_Info> listPreTmp = listResPreCost.OrderBy(x => x.pcs_dAddDate).ToList();
for (int i = 0; i < listPreTmp.Count; i++)
{
PreConsumeRecord_pcs_Info preCost = listPreTmp[i];
preCost.pcs_cSourceID = consumeItem.csr_cRecordID;//转换预付款记录的源记录ID，原为定餐记录，现为消费记录
preCost.pcs_lIsSettled = true;
preCost.pcs_dSettleTime = DateTime.Now;
preCost.pcs_cConsumeType = Common.DefineConstantValue.ConsumeMoneyFlowType.SetMealCost.ToString();
preCost.pcs_dConsumeDate = consumeItem.csr_dConsumeDate;
PreConsumeRecord_pcs_Info resCompUp = listUpdate_PreCost.Find(x => x.pcs_cRecordID == preCost.pcs_cRecordID);
PreConsumeRecord_pcs_Info resCompDel = listDelete_PreCost.Find(x => x.pcs_cRecordID == preCost.pcs_cRecordID);
if (resCompUp == null && resCompDel == null)
{
if (i == 0)
{
listUpdate_PreCost.Add(preCost);
}
else
{
listDelete_PreCost.Add(preCost);
}
}
else
{
bool lSign = true;//异常数据标识
}
}
}
else
{
//无符合该消费记录的待付款记录
listUpdate_UnMealConsume.Add(consumeItem);
}
#endregion
}
else
{
//判断为非定餐消费记录，用于消减冲数记录
consumeItem.csr_lIsSettled = true;
consumeItem.csr_dSettleTime = DateTime.Now;
listUpdate_Consume.Add(consumeItem);
}
}
#endregion
}
//找出有定餐但无打卡数据的未确定预消费记录
#region 筛选出定餐但无打卡的数据
int iCount = 0;
int iCOunt2 = 0;
foreach (PreConsumeRecord_pcs_Info unMealPreCost in listUnSettlePreCost)
{
PreConsumeRecord_pcs_Info resUnMeal = listUpdate_PreCost.Find(x => x.pcs_cRecordID == unMealPreCost.pcs_cRecordID);
PreConsumeRecord_pcs_Info resDelMeal = listDelete_PreCost.Find(x => x.pcs_cRecordID == unMealPreCost.pcs_cRecordID);
if (resUnMeal == null && resDelMeal == null)
{
unMealPreCost.pcs_cConsumeType = Common.DefineConstantValue.ConsumeMoneyFlowType.SetMealCost.ToString();
unMealPreCost.pcs_dAddDate = DateTime.Now;
unMealPreCost.pcs_cAdd = this._ServiceName;
listUpdate_PreCost.Add(unMealPreCost);
iCount++;
}
else
{
iCOunt2++;
}
}
#endregion
//消减平账冲数记录
#region 消减平账记录
var groupUserHedge = listHedge.GroupBy(x => x.pcs_cUserID);
foreach (var userItem in groupUserHedge)
{
//以人为单位组成数据组别
Guid userID = userItem.Key;
//找出本次收数得到的指定用户的打卡记录
List<ConsumeRecord_csr_Info> listUserConsume = listUpdate_Consume.Where(x => x.csr_cCardUserID == userID).ToList();
//找出未被处理到类型的打卡记录，并添加到打卡对比记录列表
List<ConsumeRecord_csr_Info> listUnMealConsume = listUpdate_UnMealConsume.Where(x => x.csr_cCardUserID == userID).ToList();
if (listUnMealConsume != null && listUnMealConsume.Count > 0)
{
listUserConsume.AddRange(listUnMealConsume);
}
if (listUserConsume == null || (listUserConsume != null && listUserConsume.Count < 1))
{
continue;
}
//以对冲记录产生的时间升序排列，时间早的靠前
List<PreConsumeRecord_pcs_Info> listUserHedge = userItem.OrderBy(x => x.pcs_dConsumeDate).ToList();
if (listUserHedge != null && listUserHedge.Count > 0)
{
for (int i = 0; i < listUserHedge.Count; i++)
{
List<ConsumeRecord_csr_Info> listConsumeComp = new List<ConsumeRecord_csr_Info>();
if (i > 0 && i == listUserHedge.Count - 1)
{
//对冲记录数大于0，且为最后一条记录时，找出是否存在打卡记录在最后一条对冲记录和倒数第二条对冲记录之间
listConsumeComp = listUserConsume.Where(x => x.csr_dConsumeDate <= listUserHedge[i].pcs_dConsumeDate && x.csr_dConsumeDate > listUserHedge[i - 1].pcs_dConsumeDate).ToList();
}
else if (i < listUserHedge.Count - 1)
{
listConsumeComp = listUserConsume.Where(x => x.csr_dConsumeDate < listUserHedge[i + 1].pcs_dConsumeDate && x.csr_dConsumeDate >= listUserHedge[i].pcs_dConsumeDate).ToList();
}
else if (i == 0 && listUserHedge.Count == 1)
{
listConsumeComp = listUserConsume.Where(x => x.csr_dConsumeDate <= listUserHedge[i].pcs_dConsumeDate).ToList();
}
if (listConsumeComp == null)
continue;
if (listConsumeComp.Count > 1)
{
decimal fComp = Math.Abs(listUserHedge[i].pcs_fCost) - Math.Abs(listConsumeComp.Sum(x => x.csr_fConsumeMoney));
if (fComp <= 0)
{
listUserHedge[i].pcs_lIsSettled = true;
listUserHedge[i].pcs_dSettleTime = DateTime.Now;
listUpdate_PreCost.Add(listUserHedge[i]);
}
else
{
listUserHedge[i].pcs_dConsumeDate = DateTime.Now;
listUserHedge[i].pcs_fCost = fComp;
listUpdate_PreCost.Add(listUserHedge[i]);
}
foreach (ConsumeRecord_csr_Info item in listConsumeComp)
{
ConsumeRecord_csr_Info consumeHedge = listUpdate_Consume.Find(x => x.csr_cRecordID == item.csr_cRecordID);
if (consumeHedge == null)
{
consumeHedge = listUpdate_UnMealConsume.Find(x => x.csr_cRecordID == item.csr_cRecordID);
consumeHedge.csr_lIsSettled = true;
consumeHedge.csr_dSettleTime = DateTime.Now;
listUpdate_Consume.Add(consumeHedge);
}
else
{
consumeHedge.csr_lIsSettled = true;
consumeHedge.csr_dSettleTime = DateTime.Now;
}
}
}
else
{
if (listUserHedge[i].pcs_dConsumeDate < dtMacSync)
{
//若无对应的消费记录，且时间早于收数时间，则删除此对冲记录
listDelete_PreCost.Add(listUserHedge[i]);
}
}
}
}
}
#endregion
//如没有被1、定餐冲数；2、平数记录冲数，则进行结算处理
if (listUpdate_UnMealConsume != null && listUpdate_UnMealConsume.Count > 0)
{
foreach (ConsumeRecord_csr_Info item in listUpdate_UnMealConsume)
{
if (!item.csr_lIsSettled)
{
item.csr_lIsSettled = true;
item.csr_dSettleTime = DateTime.Now;
listUpdate_Consume.Add(item);
}
}
}
if (listUpdate_PreCost.Count > 0 || listUpdate_Consume.Count > 0)
{
ReturnValueInfo rvInfo = this._ICardUserAccountBL.BatchSyncAccountDetail(listUpdate_PreCost, listDelete_PreCost, listUpdate_Consume);
if (rvInfo.boolValue && !rvInfo.isError)
{
this._LocalLogger.WriteLog("同步账户数据成功！" + DateTime.Now.ToString(), string.Empty, SystemLog.SystemLog.LogType.Trace);
res = true;
}
else
{
if (rvInfo.isError)
{
this._LocalLogger.WriteLog("同步账户数据失败！" + DateTime.Now.ToString() + rvInfo.messageText, string.Empty, SystemLog.SystemLog.LogType.Error);
}
else
{
this._LocalLogger.WriteLog("同步账户数据失败！" + DateTime.Now.ToString() + rvInfo.messageText, string.Empty, SystemLog.SystemLog.LogType.Warning);
}
res = false;
}
}
else
{
this._IsRunning = false;
return true;
}
}
catch (Exception ex)
{
this._LocalLogger.WriteLog(ex.Message, string.Empty, SystemLog.SystemLog.LogType.Error);
res = false;
}
this._IsRunning = false;
return res;
}
public ReturnValueInfo UpdateRechargeRecord(List<PreRechargeRecord_prr_Info> listRecord, List<RechargeRecord_rcr_Info> listRecharges, decimal fPreCostRecharge)
{
ReturnValueInfo rvInfo = new ReturnValueInfo();
#region 检查条件合法性
if (listRecord == null)
{
rvInfo.isError = true;
rvInfo.messageText = Common.DefineConstantValue.SystemMessageText.strMessageText_E_ObjectNull + Environment.NewLine + "预充值记录。";
return rvInfo;
}
if (listRecharges == null)
{
rvInfo.isError = true;
rvInfo.messageText = Common.DefineConstantValue.SystemMessageText.strMessageText_E_ObjectNull + Environment.NewLine + "实际充值记录。";
return rvInfo;
}
if (listRecharges != null && listRecharges.Count < 1)
{
rvInfo.isError = true;
rvInfo.messageText = "需要录入的充值记录不能为空。";
return rvInfo;
}
if (listRecord != null && listRecord.Count < 1)
{
rvInfo.isError = true;
rvInfo.messageText = "需要更新的充值记录不能为空。";
return rvInfo;
}
#endregion
try
{
using (SIOTSDB_HHZXDataContext db = new SIOTSDB_HHZXDataContext())
{
//用于批量统一插数
List<PreConsumeRecord_pcs> listToInsertPreCost = new List<PreConsumeRecord_pcs>();
List<CardUserAccountDetail_cuad> listToInsertAccountDetail = new List<CardUserAccountDetail_cuad>();
List<SystemAccountDetail_sad> listToInsertSysDetail = new List<SystemAccountDetail_sad>();
List<RechargeRecord_rcr> listToInsertRecharge = new List<RechargeRecord_rcr>();
//获取账户信息
CardUserAccount_cua account = db.CardUserAccount_cua.Where(x => x.cua_cCUSID == listRecharges[0].rcr_cUserID).FirstOrDefault();
#region 账户信息丢失时，自动创建账户信息
if (account == null)
{
account = new CardUserAccount_cua();
account.cua_cRecordID = Guid.NewGuid();
account.cua_cCUSID = listRecharges[0].rcr_cUserID;
account.cua_cAdd = listRecharges[0].rcr_cLast;
account.cua_dAddDate = DateTime.Now;
account.cua_dLastSyncTime = DateTime.Now;
account.cua_lIsActive = true;
account.cua_fCurrentBalance = decimal.Zero;
account.cua_fOriginalBalance = decimal.Zero;
db.CardUserAccount_cua.InsertOnSubmit(account);
db.SubmitChanges();
}
#endregion
//充值总额
decimal fSumRecharge = decimal.Zero;
//待添加的实际充值记录
List<RechargeRecord_rcr> listRechargeInserts = new List<RechargeRecord_rcr>();
//待添加的的用户账户数据
List<CardUserAccountDetail_cuad> listUserAccountInfos = new List<CardUserAccountDetail_cuad>();
//待添加的系统账户数据
List<SystemAccountDetail_sad> listSysAccountInfos = new List<SystemAccountDetail_sad>();
//更新已经使用的转账充值记录
#region 更新已被使用的预充值记录状态为已完成，并插入实际充值记录并记录账户收入记录
foreach (PreRechargeRecord_prr_Info preRechargeItem in listRecord)
{
if (preRechargeItem == null)
{
continue;
}
PreRechargeRecord_prr preRecord = db.PreRechargeRecord_prr.Where(x => x.prr_cRecordID == preRechargeItem.prr_cRecordID).FirstOrDefault();
if (preRecord != null)
{
//添加实际消费记录
RechargeRecord_rcr_Info rechargeInfo = listRecharges.Find(x => x.rcr_cRecordID == preRechargeItem.prr_cRCRID);
if (rechargeInfo != null)
{
RechargeRecord_rcr recharge = Common.General.CopyObjectValue<RechargeRecord_rcr_Info, RechargeRecord_rcr>(rechargeInfo);
if (recharge != null)
{
rechargeInfo.rcr_dRechargeTime = DateTime.Now;
rechargeInfo.rcr_dLastDate = DateTime.Now;
listRechargeInserts.Add(recharge);
}
}
preRecord.prr_cRCRID = rechargeInfo.rcr_cRecordID;
preRecord.prr_cStatus = Common.DefineConstantValue.ConsumeMoneyFlowStatus.Finished.ToString();
preRecord.prr_cLast = preRechargeItem.prr_cLast;
preRecord.prr_dLastDate = preRechargeItem.prr_dLastDate;
//累积充值记录
fSumRecharge += preRechargeItem.prr_fRechargeMoney;
//用户账户
CardUserAccountDetail_cuad userAccountDetail = new CardUserAccountDetail_cuad();
userAccountDetail.cuad_cRecordID = Guid.NewGuid();
userAccountDetail.cuad_cConsumeID = rechargeInfo.rcr_cRecordID;
userAccountDetail.cuad_cCUAID = account.cua_cRecordID;
userAccountDetail.cuad_cFlowType = rechargeInfo.rcr_cRechargeType;
userAccountDetail.cuad_cOpt = rechargeInfo.rcr_cLast;
userAccountDetail.cuad_dOptTime = DateTime.Now;
userAccountDetail.cuad_fFlowMoney = preRechargeItem.prr_fRechargeMoney;//金额与预充值额全额一致
listUserAccountInfos.Add(userAccountDetail);
//系统账户
SystemAccountDetail_sad sysAccount = new SystemAccountDetail_sad();
sysAccount.sad_cRecordID = Guid.NewGuid();
sysAccount.sad_cConsumeID = rechargeInfo.rcr_cRecordID;
sysAccount.sad_cDesc = Common.DefineConstantValue.GetMoneyFlowDesc(rechargeInfo.rcr_cRechargeType);
sysAccount.sad_cFLowMoney = preRechargeItem.prr_fRechargeMoney;//金额与预充值额全额一致
sysAccount.sad_cFlowType = rechargeInfo.rcr_cRechargeType;
sysAccount.sad_cOpt = rechargeInfo.rcr_cLast;
sysAccount.sad_dOptTime = DateTime.Now;
listSysAccountInfos.Add(sysAccount);
}
}
#endregion
if (listUserAccountInfos.Count > 0)
{
//插入由充值记录产生的账户记录
listToInsertRecharge.AddRange(listRechargeInserts);
listToInsertAccountDetail.AddRange(listUserAccountInfos);
listToInsertSysDetail.AddRange(listSysAccountInfos);
}
//查找用户是否含有透支预存款记录
decimal fAdvance = decimal.Zero;
#region 获取用户的透支金额
List<RechargeRecord_rcr> listAdvance = db.RechargeRecord_rcr.Where(x =>
x.rcr_cUserID == listRechargeInserts[0].rcr_cUserID
&& x.rcr_cRechargeType == Common.DefineConstantValue.ConsumeMoneyFlowType.Recharge_AdvanceMoney.ToString()
).ToList();
if (listAdvance != null && listAdvance.Count > 0)
{
fAdvance = listAdvance.OrderByDescending(x => x.rcr_dRechargeTime).FirstOrDefault().rcr_fRechargeMoney;
}
#endregion
decimal fCurrentBalance = decimal.Zero;
fPreCostRecharge = Math.Abs(fPreCostRecharge);
decimal fSumPreCost = decimal.Zero;//记录欠款总额
//获取本次充值的最后余额
//decimal fCardBalance = listRechargeInserts.Max(x => x.rcr_fBalance);
decimal fCardBalance = listRechargeInserts.OrderByDescending(x => x.rcr_dRechargeTime).FirstOrDefault().rcr_fBalance;
if (fPreCostRecharge >= 0 && listRechargeInserts.Count > 0)//若存在需要支付预付款的金额，则进行平数处理
{
//若预付款还款值大于0，则更新被支付的未结算预付款记录
#region 结算预付款项
List<PreConsumeRecord_pcs> listPreCost = db.PreConsumeRecord_pcs.Where(x =>
x.pcs_lIsSettled == false //需为未支付金额
&& x.pcs_cAccountID == account.cua_cRecordID//需要账户对口
&& x.pcs_cUserID == listRechargeInserts[0].rcr_cUserID //需要对口人员ID
).ToList();
//筛选预付款的消费类型
listPreCost = filterRecord_CanComputePreCost(listPreCost);
fSumPreCost = listPreCost.Sum(x => x.pcs_fCost);
if (Math.Abs(fPreCostRecharge) < Math.Abs(fSumPreCost))
{
rvInfo.messageText = "支付额不足以支付待结算的预付款。";
return rvInfo;
}
List<CardUserAccountDetail_cuad> listPreUserCost = new List<CardUserAccountDetail_cuad>();
List<SystemAccountDetail_sad> listPreSysIncome = new List<SystemAccountDetail_sad>();
foreach (PreConsumeRecord_pcs preItem in listPreCost)
{
preItem.pcs_lIsSettled = true;
preItem.pcs_dSettleTime = DateTime.Now;
//结算的同时插入一条用户账户支出记录
CardUserAccountDetail_cuad userAccountDetail = new CardUserAccountDetail_cuad();
userAccountDetail.cuad_cConsumeID = preItem.pcs_cRecordID;
userAccountDetail.cuad_cCUAID = account.cua_cRecordID;
userAccountDetail.cuad_cFlowType = preItem.pcs_cConsumeType;
userAccountDetail.cuad_cOpt = listRechargeInserts[0].rcr_cLast;
userAccountDetail.cuad_cRecordID = Guid.NewGuid();
userAccountDetail.cuad_dOptTime = DateTime.Now;
userAccountDetail.cuad_fFlowMoney = preItem.pcs_fCost;
listPreUserCost.Add(userAccountDetail);
//结算的同时插入一条系统账户收入记录
SystemAccountDetail_sad sysAccount = new SystemAccountDetail_sad();
sysAccount.sad_cConsumeID = preItem.pcs_cRecordID;
sysAccount.sad_cDesc = Common.DefineConstantValue.GetMoneyFlowDesc(preItem.pcs_cConsumeType);
sysAccount.sad_cFLowMoney = preItem.pcs_fCost;
sysAccount.sad_cFlowType = preItem.pcs_cConsumeType;
sysAccount.sad_cOpt = listRechargeInserts[0].rcr_cLast;
sysAccount.sad_cRecordID = Guid.NewGuid();
sysAccount.sad_dOptTime = DateTime.Now;
listPreSysIncome.Add(sysAccount);
}
if (listPreUserCost.Count > 0)
{
listToInsertAccountDetail.AddRange(listPreUserCost);
listToInsertSysDetail.AddRange(listPreSysIncome);
}
#endregion
//扣减预支款
fCardBalance -= fAdvance;
//账户余额
decimal fAccountUpdate = account.cua_fCurrentBalance + fSumRecharge - fSumPreCost;
if (fAccountUpdate > fCardBalance)
{
#region 平数处理
//【系统账户余额】 大于 【卡实际余额】
// 新增一条平数的预扣费记录
decimal fUnconfirmCost = fAccountUpdate - fCardBalance;
PreConsumeRecord_pcs unconfirmRecord = new PreConsumeRecord_pcs();
unconfirmRecord.pcs_cRecordID = Guid.NewGuid();
unconfirmRecord.pcs_cAccountID = account.cua_cRecordID;
unconfirmRecord.pcs_cAdd = listRechargeInserts[0].rcr_cLast;
unconfirmRecord.pcs_cConsumeType = DefineConstantValue.ConsumeMoneyFlowType.HedgeFund.ToString();
unconfirmRecord.pcs_cUserID = listRechargeInserts[0].rcr_cUserID;
unconfirmRecord.pcs_dAddDate = DateTime.Now;
unconfirmRecord.pcs_dConsumeDate = DateTime.Now;
unconfirmRecord.pcs_fCost = fUnconfirmCost;
unconfirmRecord.pcs_lIsSettled = false;
listToInsertPreCost.Add(unconfirmRecord);
//用户账户
CardUserAccountDetail_cuad userAccountDetail = new CardUserAccountDetail_cuad();
userAccountDetail.cuad_cRecordID = Guid.NewGuid();
userAccountDetail.cuad_cConsumeID = unconfirmRecord.pcs_cRecordID;
userAccountDetail.cuad_cCUAID = account.cua_cRecordID;
userAccountDetail.cuad_cFlowType = unconfirmRecord.pcs_cConsumeType;
userAccountDetail.cuad_cOpt = listRechargeInserts[0].rcr_cLast;
userAccountDetail.cuad_dOptTime = DateTime.Now;
userAccountDetail.cuad_fFlowMoney = fUnconfirmCost;
listToInsertAccountDetail.Add(userAccountDetail);
//系统账户
SystemAccountDetail_sad sysAccount = new SystemAccountDetail_sad();
sysAccount.sad_cRecordID = Guid.NewGuid();
sysAccount.sad_cConsumeID = unconfirmRecord.pcs_cRecordID;
sysAccount.sad_cDesc = DefineConstantValue.GetMoneyFlowDesc(unconfirmRecord.pcs_cConsumeType);
sysAccount.sad_cFLowMoney = fUnconfirmCost;
sysAccount.sad_cFlowType = unconfirmRecord.pcs_cConsumeType;
sysAccount.sad_cOpt = listRechargeInserts[0].rcr_cLast;
sysAccount.sad_dOptTime = DateTime.Now;
listToInsertSysDetail.Add(sysAccount);
#endregion
}
fCurrentBalance = fCardBalance;
}
else
{
fCurrentBalance = fCardBalance - fAdvance;
}
try
{
db.Connection.Open();
db.Transaction = db.Connection.BeginTransaction();
if (listToInsertRecharge != null && listToInsertRecharge.Count > 0)
db.RechargeRecord_rcr.InsertAllOnSubmit(listToInsertRecharge);
if (listToInsertPreCost != null && listToInsertPreCost.Count > 0)
db.PreConsumeRecord_pcs.InsertAllOnSubmit(listToInsertPreCost);
if (listToInsertAccountDetail != null && listToInsertAccountDetail.Count > 0)
db.CardUserAccountDetail_cuad.InsertAllOnSubmit(listToInsertAccountDetail);
if (listToInsertSysDetail != null && listToInsertSysDetail.Count > 0)
db.SystemAccountDetail_sad.InsertAllOnSubmit(listToInsertSysDetail);
account.cua_dLastSyncTime = DateTime.Now;
account.cua_fCurrentBalance = fCurrentBalance;
db.SubmitChanges();
db.Transaction.Commit();
rvInfo.boolValue = true;
rvInfo.ValueObject = DateTime.Now;
return rvInfo;
}
catch (Exception exx)
{
db.Transaction.Rollback();
db.Connection.Close();
throw exx;
}
}
}
catch (Exception ex)
{
rvInfo.isError = true;
rvInfo.messageText = ex.Message;
}
return rvInfo;
}
public static bool DecodeCommand(Player Plr,ref List<string> Values, List<GmCommandHandler> Handlers,List<GmCommandHandler> BaseHandlers)
{
string Command = GetString(ref Values);
Log.Success("DecodeCommand", "Command = " + Command);
GmCommandHandler Handler = Handlers.Find(com => com != null && com.Name.StartsWith(Command));
if(Handler == null) // Si la commande n'existe pas , on affiche la liste des commandes
{
List<GmCommandHandler> Base = Handlers == null ? BaseHandlers : Handlers;
PrintCommands(Plr,Base);
return true;
}
else // Le Handler Existe
{
if(Handler.GmLevel > Plr.GmLevel) // GmLevel insuffisant
{
return false;
}
if(Handler.ValuCount > Values.Count) // Nombre d'arguments insuffisant
{
return true;
}
if(Handler.Handlers != null && Handler.Handlers.Count > 0)
{
return DecodeCommand(Plr,ref Values,Handler.Handlers,Handlers);
}
if(Handler.Handler != null)
{
return Handler.Handler.Invoke(Plr,ref Values);
}
}
return false;
}
/// <summary>
/// 重设被欠费停餐的人员开餐情况
/// </summary>
/// <param name="userInfo"></param>
private void ResetMealPlanning(CardUserMaster_cus_Info userInfo, DateTime dtSysNow, List<MealBookingHistory_mbh_Info> listMeaslHistory)
{
try
{
ICodeMasterBL bll = BLL.Factory.SysMaster.MasterBLLFactory.GetBLL<ICodeMasterBL>(BLL.Factory.SysMaster.MasterBLLFactory.CodeMaster_cmt);
List<CodeMaster_cmt_Info> listMealTimeSpans = bll.SearchRecords(new CodeMaster_cmt_Info() { cmt_cKey1 = Common.DefineConstantValue.CodeMasterDefine.KEY1_MealTimeSpan });
List<CodeMaster_cmt_Info> listBlacklistTImeSpans = bll.SearchRecords(new CodeMaster_cmt_Info() { cmt_cKey1 = Common.DefineConstantValue.CodeMasterDefine.KEY1_BWListUploadInterval });
TimeSpan tsBLLunch = TimeSpan.Parse(listBlacklistTImeSpans.Find(x => x.cmt_cValue == Common.DefineConstantValue.MealType.Lunch.ToString()).cmt_cRemark);
TimeSpan tsMealLunch = TimeSpan.Parse(listMealTimeSpans.Find(x => x.cmt_cKey2 == Common.DefineConstantValue.MealType.Lunch.ToString()).cmt_cRemark2);
TimeSpan tsBLSupper = TimeSpan.Parse(listBlacklistTImeSpans.Find(x => x.cmt_cValue == Common.DefineConstantValue.MealType.Supper.ToString()).cmt_cRemark);
TimeSpan tsMealSupper = TimeSpan.Parse(listMealTimeSpans.Find(x => x.cmt_cKey2 == Common.DefineConstantValue.MealType.Supper.ToString()).cmt_cRemark2);
TimeSpan tsNow = TimeSpan.Parse(dtSysNow.ToString("HH:mm"));
string strMealType = string.Empty;
if (tsNow >= tsBLLunch && tsNow <= tsMealLunch)
{
strMealType = Common.DefineConstantValue.MealType.Lunch.ToString();
MealBookingHistory_mbh_Info mealInfo = listMeaslHistory.Find(x => x.mbh_cMealType == strMealType);
if (mealInfo != null)
{
localLog.WriteLog("找到午餐计划。" + dtSysNow.ToString(), string.Empty, SystemLog.SystemLog.LogType.Trace);
UpdateMealPlanning(strMealType, userInfo, mealInfo);
}
else
{
localLog.WriteLog("找不到午餐计划。" + dtSysNow.ToString(), string.Empty, SystemLog.SystemLog.LogType.Trace);
}
}
else if (tsNow >= tsBLSupper && tsNow <= tsMealSupper)
{
strMealType = Common.DefineConstantValue.MealType.Supper.ToString();
MealBookingHistory_mbh_Info mealInfo = listMeaslHistory.Find(x => x.mbh_cMealType == strMealType);
if (mealInfo != null)
{
localLog.WriteLog("找到晚餐计划。" + dtSysNow.ToString(), string.Empty, SystemLog.SystemLog.LogType.Trace);
UpdateMealPlanning(strMealType, userInfo, mealInfo);
}
else
{
localLog.WriteLog("找不到晚餐计划。" + dtSysNow.ToString(), string.Empty, SystemLog.SystemLog.LogType.Trace);
}
}
else
{
localLog.WriteLog(userInfo.cus_cChaName + "，不在就餐时间内。" + dtSysNow.ToString(), string.Empty, SystemLog.SystemLog.LogType.Trace);
}
ReturnValueInfo rvInfo = AddOldCardList(int.Parse(_CardInfo.CardNo), DefineConstantValue.EnumCardUploadListOpt.AddWhiteList);
if (rvInfo.boolValue && !rvInfo.isError)
{
localLog.WriteLog(userInfo.cus_cChaName + "清除名单成功。" + dtSysNow.ToString(), string.Empty, SystemLog.SystemLog.LogType.Trace);
}
else
{
localLog.WriteLog(userInfo.cus_cChaName + "清除名单失败。" + rvInfo.messageText + " " + dtSysNow.ToString(), string.Empty, SystemLog.SystemLog.LogType.Error);
}
}
catch (Exception ex)
{
localLog.WriteLog(ex.Message, string.Empty, SystemLog.SystemLog.LogType.Error);
}
}
/// <summary>
/// 綁定菜單欄
/// </summary>
void BindMenuItems()
{
Sys_FormMaster_fom_Info info = new Sys_FormMaster_fom_Info();
info.fom_cSysCode = Common.DefineConstantValue.SysFormCodeEnum.HBManager.ToString();
ISysFormMasterBL _ISysFormMasterBL = MasterBLLFactory.GetBLL<ISysFormMasterBL>(MasterBLLFactory.SysFormMaster);
Sys_UserMaster_usm_Info user = this.UserInformation;
List<Sys_FormMaster_fom_Info> listObjForms = _ISysFormMasterBL.GetUserMenu(info, user);
List<Sys_FormMaster_fom_Info> listForms = new List<Sys_FormMaster_fom_Info>();
foreach (Sys_FormMaster_fom_Info item in listObjForms)
{
if (item != null)
{
listForms.Add(item);
}
}
Sys_FormMaster_fom_Info ParentFormInfo = listForms.Find(x => x.fom_iParentID == -1);
if (ParentFormInfo == null)
{
return;
}
ClearMenuItem();
GetMenuItems(TopMenu.MenuItems, listForms, ParentFormInfo.fom_iRecordID);
}
/// <summary>
/// 绑定菜单栏
/// </summary>
void BindMenuItems()
{
Sys_FormMaster_fom_Info info = new Sys_FormMaster_fom_Info();
ISysFormMasterBL _ISysFormMasterBL = MasterBLLFactory.GetBLL<ISysFormMasterBL>(MasterBLLFactory.SysFormMaster);
Sys_UserMaster_usm_Info user = this.UserInformation;
List<Sys_FormMaster_fom_Info> listObjForms = _ISysFormMasterBL.GetUserMenu(info, user);
List<Sys_FormMaster_fom_Info> listForms = new List<Sys_FormMaster_fom_Info>();
foreach (Sys_FormMaster_fom_Info item in listObjForms)
{
if (item != null)
{
listForms.Add(item);
}
}
Sys_FormMaster_fom_Info ParentFormInfo = listForms.Find(x => x.fom_iParentID == -1);
if (ParentFormInfo == null)
{
return;
}
ClearMenuItem();
bool isException = false;
if (this.UserInformation != null)
{
if (this.UserInformation.usm_cUserLoginID == "sa")
{
isException = true;
}
}
GetMenuItems(TopMenu.MenuItems, listForms, ParentFormInfo.fom_iRecordID, isException);
SetSystemMenu();
}
private static string GetConnectionStringFromCommandLineArguments()
{
List<string> args = new List<string>(Environment.GetCommandLineArgs());
if (args.Find(s => s.StartsWith("/cs:")) != null)
{
return args.Find(s => s.StartsWith("/cs:")).Substring(4);
}
if (connectionString == null && args.Find(s => s.StartsWith("/s:")) != null && args.Find(s => s.StartsWith("/d:")) != null)
{
return BuildConnectionString(args.Find(s => s.StartsWith("/s:")).Substring(3), args.Find(s => s.StartsWith("/d:")).Substring(3));
}
return null;
}
private void UpdateMemberships(List<FuzzyVariable> sourceVariables, VariableMFParam parameterToUpdate, BoundType boundType)
{
switch (parameterToUpdate)
{
case VariableMFParam.Mean:
case VariableMFParam.Deviation:
foreach (var variable in inputVariables)
{
foreach (var type2term in variable.Terms)
{
var sourceTerm = sourceVariables.Find(v => v.Name == variable.Name).Terms.Find(t => t.Name == type2term.Name);
var mf = sourceTerm.MembershipFunction as NormalMembershipFunction;
if (boundType == BoundType.Lower)
{
type2term.LowerMembershipFunction = new NormalMembershipFunction(mf.B, mf.Sigma);
}
else
{
type2term.UpperMembershipFunction = new NormalMembershipFunction(mf.B, mf.Sigma);
}
}
}
break;
case VariableMFParam.RuleWeight:
// todo
break;
}
}
