private void btnConfirm_Click(object sender, EventArgs e)
{
if (ShowQuestionMessage("是否确认修改学生账户可透支额？" + Environment.NewLine + "修改过程需时几分钟，期间不能进行其他操作！"))
{
decimal fOverdraft = Convert.ToDecimal(nbxOverdraft.Text);
if (!ShowQuestionMessage("准备修改的学生账户可透支额为：" + fOverdraft.ToString() + "，是否确认继续？"))
{
return;
}
this.Cursor = Cursors.WaitCursor;
try
{
RechargeRecord_rcr_Info rechrage = new RechargeRecord_rcr_Info();
rechrage.rcr_fRechargeMoney = fOverdraft;
rechrage.rcr_cAdd = this.UserInformation.usm_cUserLoginID;
rechrage.rcr_cLast = this.UserInformation.usm_cUserLoginID;
ICardUserAccountBL accountBL = MasterBLLFactory.GetBLL<ICardUserAccountBL>(MasterBLLFactory.CardUserAccount);
ReturnValueInfo rvInfo = accountBL.ResetAccountOverdraft(rechrage);
this.Cursor = Cursors.Default;
if (rvInfo.boolValue && !rvInfo.isError)
{
ShowInformationMessage("修改成功，学生账户当前可透支额为：" + nbxOverdraft.Text);
}
else
{
ShowInformationMessage("修改失败。" + rvInfo.messageText);
}
}
catch (Exception ex)
{
ShowErrorMessage(ex);
this.Cursor = Cursors.Default;
}
}
}
public frmAmountOfChange()
{
InitializeComponent();
this._info = null;
this._rechargeRecordBL = MasterBLLFactory.GetBLL<IRechargeRecordBL>(MasterBLLFactory.RechargeRecord);
}
public ReturnValueInfo CashRefund(RechargeRecord_rcr_Info refundRecord, decimal fPreCostRecharge)
{
ReturnValueInfo rvInfo = new ReturnValueInfo();
try
{
fPreCostRecharge = Math.Abs(fPreCostRecharge);
rvInfo = this._IRechargeRecordDA.CashRefund(refundRecord, fPreCostRecharge);
}
catch (Exception ex)
{
rvInfo.isError = true;
rvInfo.messageText = ex.Message;
}
return rvInfo;
}
/// <summary>
/// 是否为需要记录到系统账户的数据
/// </summary>
/// <param name="record"></param>
/// <returns></returns>
bool IsSysAccountRecord(RechargeRecord_rcr_Info record)
{
if (record != null)
{
if (record.rcr_cRechargeType == DefineConstantValue.ConsumeMoneyFlowType.Recharge_AdvanceMoney.ToString())
{
return false;
}
}
return true;
}
/// <summary>
/// 获取账户ID
/// </summary>
/// <param name="UserID"></param>
/// <returns></returns>
Guid? GetAccountID(RechargeRecord_rcr_Info rechargeRecord)
{
if (rechargeRecord == null)
{
return null;
}
Guid UserID = rechargeRecord.rcr_cUserID;
CardUserAccount_cua_Info accountInfo = this._ICardUserAccountDA.SearchRecords(new CardUserAccount_cua_Info() { cua_cCUSID = UserID }).FirstOrDefault();
if (accountInfo == null)
{
accountInfo = new CardUserAccount_cua_Info();
accountInfo.cua_cAdd = rechargeRecord.rcr_cLast;
accountInfo.cua_cCUSID = UserID;
accountInfo.cua_cRecordID = Guid.NewGuid();
accountInfo.cua_dAddDate = DateTime.Now;
accountInfo.cua_dLastSyncTime = DateTime.Now;
accountInfo.cua_fCurrentBalance = 0;
accountInfo.cua_fOriginalBalance = 0;
ReturnValueInfo rvInfo = this._ICardUserAccountDA.InsertRecord(accountInfo);
if (!rvInfo.boolValue || rvInfo.isError)
{
return null;
}
}
return accountInfo.cua_cRecordID;
}
/// <summary>
/// 添加消费记录对应用户卡发卡情况
/// </summary>
/// <returns></returns>
bool AddUserCardPairInfo(RechargeRecord_rcr_Info rechargeInfo)
{
bool res = false;
try
{
if (rechargeInfo != null)
{
rechargeInfo.AccountDetail = this._ICardUserAccountDetailDA.DisplayRecord(new CardUserAccountDetail_cuad_Info() { cuad_cConsumeID = rechargeInfo.rcr_cRecordID });
res = true;
}
}
catch (Exception ex)
{
throw ex;
}
return res;
}
/// <summary>
/// 添加消费记录对应账户资金流动记录
/// </summary>
/// <returns></returns>
bool AddAccountDetailInfo(RechargeRecord_rcr_Info rechargeInfo)
{
bool res = false;
try
{
if (rechargeInfo != null)
{
rechargeInfo.PairInfo = this._IUserCardPairDA.DisplayRecord(new UserCardPair_ucp_Info() { ucp_cCardID = rechargeInfo.rcr_cCardID });
res = true;
}
}
catch (Exception ex)
{
throw ex;
}
return res;
}
public ReturnValueInfo Save(IModelObject itemEntity, DefineConstantValue.EditStateEnum EditMode)
{
ReturnValueInfo rvInfo = new ReturnValueInfo();
try
{
RechargeRecord_rcr_Info sourceInfo = itemEntity as RechargeRecord_rcr_Info;
if (sourceInfo == null)
{
rvInfo.messageText = DefineConstantValue.SystemMessageText.strMessageText_E_ObjectNull;
rvInfo.isError = true;
return rvInfo;
}
//检查充值用户的账户ID，如还未创建账户，则自动创建，如创建失败，则不给予充值
Guid? accountID = GetAccountID(sourceInfo);
if (accountID == null)
{
rvInfo.messageText = "用户账户信息缺失，自动添加账户失败。";
rvInfo.isError = true;
return rvInfo;
}
//判断是否为需要录入用户账户中的记录
bool isUserDetail = IsUserAccountRecord(sourceInfo);
// 判断是否为需要录入到系统账户中的记录
bool isSysDetail = IsSysAccountRecord(sourceInfo);
switch (EditMode)
{
case DefineConstantValue.EditStateEnum.OE_Insert:
{
/*插入充值记录时，判断是否需要同步一条卡用户账户资金流记录及系统账户资金流记录，
* 如需要，则在新增充值记录后同步插入一条资金流记录及系统账户资金流记录，
* 如插入失败，则需要在运行资金同步服务时重新新增*/
#region Insert Record
sourceInfo.rcr_dRechargeTime = DateTime.Now;
sourceInfo.rcr_dLastDate = sourceInfo.rcr_dRechargeTime;
rvInfo = this._IRechargeRecordDA.InsertRecord(sourceInfo);
if (rvInfo.boolValue && !rvInfo.isError)
{
if (isUserDetail)
{
//同步插入一条用户资金流动记录
#region 同步用户资金流动记录
CardUserAccountDetail_cuad_Info accountDetail = new CardUserAccountDetail_cuad_Info();
accountDetail.cuad_cConsumeID = sourceInfo.rcr_cRecordID;
accountDetail.cuad_cCUAID = accountID.Value;
accountDetail.cuad_fFlowMoney = sourceInfo.rcr_fRechargeMoney;
accountDetail.cuad_cFlowType = sourceInfo.rcr_cRechargeType;
accountDetail.cuad_cOpt = sourceInfo.rcr_cAdd;
accountDetail.cuad_cRecordID = Guid.NewGuid();
accountDetail.cuad_dOptTime = sourceInfo.rcr_dRechargeTime;
ReturnValueInfo res = this._ICardUserAccountDetailDA.InsertRecord(accountDetail);
rvInfo.messageText += res.messageText;
#endregion
}
if (isSysDetail)
{
//同步插入一条系统资金现金流
#region 同步系统资金流动记录
SystemAccountDetail_sad_Info sysAccountInfo = new SystemAccountDetail_sad_Info();
sysAccountInfo.sad_cConsumeID = sourceInfo.rcr_cRecordID;
sysAccountInfo.sad_cDesc = string.Empty;
sysAccountInfo.sad_cFLowMoney = sourceInfo.rcr_fRechargeMoney;
sysAccountInfo.sad_cFlowType = sourceInfo.rcr_cRechargeType;
sysAccountInfo.sad_cOpt = sourceInfo.rcr_cAdd;
sysAccountInfo.sad_cRecordID = Guid.NewGuid();
sysAccountInfo.sad_dOptTime = sourceInfo.rcr_dRechargeTime;
ReturnValueInfo res = this._ISystemAccountDetailDA.InsertRecord(sysAccountInfo);
rvInfo.messageText += res.messageText;
#endregion
}
}
break;
#endregion
}
case DefineConstantValue.EditStateEnum.OE_Update:
{
/*更新充值记录时，需检查是否有相应的资金流记录，
* 如有，则需同步更新
*/
#region Update Record
sourceInfo.rcr_dLastDate = DateTime.Now;
rvInfo = this._IRechargeRecordDA.UpdateRecord(sourceInfo);
if (rvInfo.boolValue && !rvInfo.isError)
{
if (isUserDetail)
{
//同步更新对应用户资金流记录
#region 同步用户资金流记录
CardUserAccountDetail_cuad_Info accountDetail = this._ICardUserAccountDetailDA.SearchRecords(new CardUserAccountDetail_cuad_Info() { cuad_cConsumeID = sourceInfo.rcr_cRecordID }).FirstOrDefault();
if (accountDetail == null)
{
//如无对应资金流记录，则添加
accountDetail = new CardUserAccountDetail_cuad_Info();
accountDetail.cuad_cConsumeID = sourceInfo.rcr_cRecordID;
accountDetail.cuad_cCUAID = accountID.Value;
accountDetail.cuad_fFlowMoney = sourceInfo.rcr_fRechargeMoney;
accountDetail.cuad_cFlowType = sourceInfo.rcr_cRechargeType;
accountDetail.cuad_cOpt = sourceInfo.rcr_cAdd;
accountDetail.cuad_cRecordID = Guid.NewGuid();
accountDetail.cuad_dOptTime = sourceInfo.rcr_dRechargeTime;
ReturnValueInfo res = this._ICardUserAccountDetailDA.InsertRecord(accountDetail);
rvInfo.messageText += res.messageText;
}
else
{
//如存在对应资金流记录，则更新金额、流类型、操作人、最后操作时间
accountDetail.cuad_cFlowType = sourceInfo.rcr_cRechargeType;
accountDetail.cuad_cOpt = sourceInfo.rcr_cLast;
accountDetail.cuad_dOptTime = sourceInfo.rcr_dLastDate;
accountDetail.cuad_fFlowMoney = sourceInfo.rcr_fRechargeMoney;
ReturnValueInfo res = this._ICardUserAccountDetailDA.UpdateRecord(accountDetail);
rvInfo.messageText += res.messageText;
}
#endregion
}
if (isSysDetail)
{
//同步更新对应系统资金流记录
#region 同步系统资金流记录
SystemAccountDetail_sad_Info sysAccountInfo = this._ISystemAccountDetailDA.SearchRecords(new SystemAccountDetail_sad_Info() { sad_cConsumeID = sourceInfo.rcr_cRecordID }).FirstOrDefault();
if (sysAccountInfo == null)
{
sysAccountInfo.sad_cConsumeID = sourceInfo.rcr_cRecordID;
sysAccountInfo.sad_cDesc = string.Empty;
sysAccountInfo.sad_cFLowMoney = sourceInfo.rcr_fRechargeMoney;
sysAccountInfo.sad_cFlowType = sourceInfo.rcr_cRechargeType;
sysAccountInfo.sad_cOpt = sourceInfo.rcr_cAdd;
sysAccountInfo.sad_cRecordID = Guid.NewGuid();
sysAccountInfo.sad_dOptTime = sourceInfo.rcr_dRechargeTime;
ReturnValueInfo res = this._ISystemAccountDetailDA.InsertRecord(sysAccountInfo);
rvInfo.messageText += res.messageText;
}
else
{
sysAccountInfo.sad_cDesc = string.Empty;
sysAccountInfo.sad_cFLowMoney = sourceInfo.rcr_fRechargeMoney;
sysAccountInfo.sad_cFlowType = sourceInfo.rcr_cRechargeType;
sysAccountInfo.sad_cOpt = sourceInfo.rcr_cAdd;
sysAccountInfo.sad_cRecordID = Guid.NewGuid();
sysAccountInfo.sad_dOptTime = sourceInfo.rcr_dRechargeTime;
ReturnValueInfo res = this._ISystemAccountDetailDA.UpdateRecord(sysAccountInfo);
rvInfo.messageText += res.messageText;
}
#endregion
}
}
break;
#endregion
}
case DefineConstantValue.EditStateEnum.OE_Delete:
{
/*需要删除充值记录时，不能做真正的删除记录操作，
* 只能添加一条交易金额为原金额*1的充值记录作为充数只用，充值类型也相应为对冲类型
* 同时也需要检查是否有资金流记录，进行同步操作
*/
#region Delete Record
RechargeRecord_rcr_Info OldRechargeInfo = this._IRechargeRecordDA.DisplayRecord(sourceInfo);
if (OldRechargeInfo != null)
{
//插入一条金额对冲记录代替删除原充值记录
RechargeRecord_rcr_Info NewRechargeInfo = new RechargeRecord_rcr_Info();
NewRechargeInfo.rcr_fRechargeMoney = OldRechargeInfo.rcr_fRechargeMoney * -1;
NewRechargeInfo.rcr_dRechargeTime = DateTime.Now;
NewRechargeInfo.rcr_cUserID = OldRechargeInfo.rcr_cUserID;
NewRechargeInfo.rcr_cStatus = DefineConstantValue.ConsumeMoneyFlowStatus.Finished.ToString();
NewRechargeInfo.rcr_cRecordID = Guid.NewGuid();
NewRechargeInfo.rcr_cRechargeType = DefineConstantValue.ConsumeMoneyFlowType.HedgeFund.ToString();
NewRechargeInfo.rcr_cLast = sourceInfo.rcr_cLast;
NewRechargeInfo.rcr_dLastDate = NewRechargeInfo.rcr_dRechargeTime;
rvInfo = this._IRechargeRecordDA.InsertRecord(NewRechargeInfo);
if (rvInfo.boolValue && !rvInfo.isError)
{
if (isUserDetail)
{
//同步插入用户账户资金流
#region 同步用户资金流记录
CardUserAccountDetail_cuad_Info accountDetail = new CardUserAccountDetail_cuad_Info();
accountDetail.cuad_cConsumeID = sourceInfo.rcr_cRecordID;
accountDetail.cuad_cCUAID = accountID.Value;
accountDetail.cuad_fFlowMoney = sourceInfo.rcr_fRechargeMoney;
accountDetail.cuad_cFlowType = sourceInfo.rcr_cRechargeType;
accountDetail.cuad_cOpt = sourceInfo.rcr_cAdd;
accountDetail.cuad_cRecordID = Guid.NewGuid();
accountDetail.cuad_dOptTime = sourceInfo.rcr_dRechargeTime;
ReturnValueInfo res = this._ICardUserAccountDetailDA.InsertRecord(accountDetail);
#endregion
}
if (isSysDetail)
{
//同步插入系统资金现金流
#region 同步系统资金流动记录
SystemAccountDetail_sad_Info sysAccountInfo = new SystemAccountDetail_sad_Info();
sysAccountInfo.sad_cConsumeID = sourceInfo.rcr_cRecordID;
sysAccountInfo.sad_cDesc = string.Empty;
sysAccountInfo.sad_cFLowMoney = sourceInfo.rcr_fRechargeMoney;
sysAccountInfo.sad_cFlowType = sourceInfo.rcr_cRechargeType;
sysAccountInfo.sad_cOpt = sourceInfo.rcr_cAdd;
sysAccountInfo.sad_cRecordID = Guid.NewGuid();
sysAccountInfo.sad_dOptTime = sourceInfo.rcr_dRechargeTime;
ReturnValueInfo res = this._ISystemAccountDetailDA.InsertRecord(sysAccountInfo);
rvInfo.messageText += res.messageText;
#endregion
}
}
}
else
{
rvInfo.messageText = "找不到原充值记录。";
rvInfo.isError = true;
}
break;
#endregion
}
default:
break;
}
}
catch (Exception ex)
{
rvInfo.isError = true;
rvInfo.messageText = ex.Message;
}
return rvInfo;
}
/// <summary>
/// 单卡发卡逻辑
/// </summary>
/// <param name="userID">用户信息记录ID</param>
/// <param name="fNewCardCost">新卡工本费</param>
/// <param name="fAdvanceCost">可透支额</param>
/// <returns></returns>
ReturnValueInfo pairCardLogic(Guid userID, decimal fNewCardCost, decimal fAdvanceCost)
{
ReturnValueInfo rvInfo = new ReturnValueInfo();
try
{
ConsumeCardInfo sourceCardInfo = this._Reader.ReadCardInfo(base._CardInfoSection, base._SectionPwd);
if (sourceCardInfo == null)
{
sourceCardInfo = this._Reader.ReadCardInfo(base._CardInfoSection, base._OrganizeSectionPwd);
if (sourceCardInfo != null)
{
rvInfo = this._Reader.ModifySectionPwd(base._CardInfoSection, base._OrganizeSectionPwd, base._SectionPwd);
}
}
if (sourceCardInfo == null)
{
rvInfo.messageText = "卡片已损坏，请重试。";
rvInfo.isError = true;
return rvInfo;
}
string strCardID = sourceCardInfo.CardSourceID;
if (strCardID == null)
{
rvInfo.messageText = "卡片已损坏或摆放位置不正确，请重试。";
rvInfo.isError = true;
return rvInfo;
}
ConsumeCardMaster_ccm_Info cardSearch = null;
ConsumeCardMaster_ccm_Info cardInfo = new ConsumeCardMaster_ccm_Info();
cardInfo.ccm_cCardID = strCardID;
// *********1、搜索卡主档，检查是否存在此卡资料*********
#region 卡主档信息检查
cardSearch = this._IConsumeCardMasterBL.DisplayRecord(cardInfo) as ConsumeCardMaster_ccm_Info;
if (cardSearch == null)
{
//无相应卡主档记录则先添加此卡
cardInfo.ccm_cCardState = DefineConstantValue.CardUseState.NotUsed.ToString();
cardInfo.ccm_cAdd = base.UserInformation.usm_cUserLoginID;
cardInfo.ccm_dAddDate = DateTime.Now;
cardInfo.ccm_cLast = cardInfo.ccm_cAdd;
cardInfo.ccm_dLastDate = cardInfo.ccm_dAddDate;
rvInfo = this._IConsumeCardMasterBL.Save(cardInfo, DefineConstantValue.EditStateEnum.OE_Insert);
if (!rvInfo.boolValue || rvInfo.isError)
{
rvInfo.messageText = "录入本卡信息失败，请重试。";
rvInfo.isError = true;
return rvInfo;
}
}
#endregion
try
{
//*********2、插入发卡信息************
UserCardPair_ucp_Info pairInfo = new UserCardPair_ucp_Info();
#region 检查是否已发卡
pairInfo = new UserCardPair_ucp_Info();
pairInfo.ucp_cCUSID = userID;
List<UserCardPair_ucp_Info> listSearch = this._IUserCardPairBL.SearchRecords(pairInfo);
listSearch = listSearch.Where(x => x.ucp_cUseStatus != Common.DefineConstantValue.ConsumeCardStatus.Returned.ToString()).ToList();
if (listSearch.Count > 0)
{
//此人已发卡
rvInfo.messageText = "此用户已被发卡。" + Environment.NewLine + "拥有卡号：" + listSearch[0].ucp_iCardNo.ToString();
return rvInfo;
}
pairInfo = new UserCardPair_ucp_Info();
pairInfo.ucp_iCardNo = int.Parse(sourceCardInfo.CardNo);
pairInfo.ucp_cCardID = cardInfo.ccm_cCardID;
listSearch = this._IUserCardPairBL.SearchRecords(pairInfo);
listSearch = listSearch.Where(x => x.ucp_cUseStatus != Common.DefineConstantValue.ConsumeCardStatus.Returned.ToString()).ToList();
if (listSearch.Count > 0)
{
//此卡已发卡
rvInfo.messageText = "此卡已被发卡。" + Environment.NewLine + "卡拥有人：" + listSearch[0].CardOwner.cus_cStudentID + " " + listSearch[0].CardOwner.cus_cChaName;
return rvInfo;
}
#endregion
pairInfo = new UserCardPair_ucp_Info();
pairInfo.ucp_cRecordID = Guid.NewGuid();
pairInfo.ucp_cCardID = cardInfo.ccm_cCardID;
pairInfo.ucp_cCUSID = userID;
pairInfo.ucp_dPairTime = DateTime.Now;
pairInfo.ucp_cUseStatus = Common.DefineConstantValue.ConsumeCardStatus.Normal.ToString();
pairInfo.ucp_cAdd = base.UserInformation.usm_cUserLoginID;
pairInfo.ucp_dAddDate = pairInfo.ucp_dPairTime;
pairInfo.ucp_cLast = pairInfo.ucp_cAdd;
pairInfo.ucp_dLastDate = pairInfo.ucp_dAddDate;
rvInfo = this._IUserCardPairBL.InsertNewCard(pairInfo, fNewCardCost);
if (rvInfo.boolValue && !rvInfo.isError)
{
// *********3、写入卡物理信息*********
#region 发卡
UserCardPair_ucp_Info currentPair = this._IUserCardPairBL.DisplayRecord(new UserCardPair_ucp_Info()
{
ucp_cRecordID = pairInfo.ucp_cRecordID
});
CardUserMaster_cus_Info userInfo = null;
//抽取用户资料【写入卡显示名称】
string strCardName = string.Empty;//卡片显示信息
#region 写入卡显示信息
if (currentPair.CardOwner != null)
{
CardUserMaster_cus_Info userSearch = new CardUserMaster_cus_Info()
{
cus_cRecordID = currentPair.CardOwner.cus_cRecordID
};
userInfo = this._ICardUserMasterBL.DisplayRecord(userSearch);
if (userInfo != null)
{
#region 判断身份
if (userInfo.cus_cIdentityNum == DefineConstantValue.CodeMasterDefine.KEY2_SIOT_CardUserIdentity_Student)//学生
{
if (userInfo.ClassInfo != null)
{
if (userInfo.ClassInfo.GradeInfo == null)
{
strCardName += userInfo.ClassInfo.csm_cClassName.Substring(0, 1) == "高" ? "G" : "C";
strCardName += userInfo.ClassInfo.csm_cClassName.Substring(1, 1);
}
else
{
strCardName += userInfo.ClassInfo.GradeInfo.gdm_cAbbreviation;
}
string strTmpName = userInfo.cus_cChaName;
if (userInfo.cus_cChaName.Length > 3)
{
strTmpName = userInfo.cus_cChaName.Substring(1, 3);
}
strCardName += strTmpName;
}
else
{
rvInfo.messageText = "用户班级信息不全，请重试。";
rvInfo.isError = true;
return rvInfo;
}
}
else if (userInfo.cus_cIdentityNum == DefineConstantValue.CodeMasterDefine.KEY2_SIOT_CardUserIdentity_Staff)//老师
{
string strTmpName = userInfo.cus_cChaName;
if (userInfo.cus_cChaName.Length > 6)
{
strTmpName = strTmpName.Substring(0, 6);
}
strCardName = strTmpName;
}
else
{
rvInfo.messageText = "有未知身份的用户。" + Environment.NewLine + userInfo.cus_cStudentID + " " + userInfo.cus_cChaName;
rvInfo.isError = true;
return rvInfo;
}
#endregion
ConsumeCardInfo writeCardInfo = new ConsumeCardInfo() { CardBalance = 0, CardNo = currentPair.ucp_iCardNo.ToString(), CardPwd = base._PayPwd, ConsumeTimes = 0, Name = strCardName };
//写入卡显示信息
rvInfo = this._Reader.WriteCardInfo(base._CardInfoSection, base._SectionPwd, writeCardInfo);
if (!rvInfo.boolValue || rvInfo.isError)
{
rvInfo = this._IUserCardPairBL.Save(pairInfo, DefineConstantValue.EditStateEnum.OE_Delete);
if (rvInfo.boolValue && rvInfo.isError)
{
rvInfo.messageText = "写入用户卡信息时出现异常，当前发卡记录已重置，请重新进行发卡操作。";
rvInfo.isError = true;
return rvInfo;
}
else
{
rvInfo.messageText = "写入用户卡信息时出现异常，当前发卡记录未能重置，请联系系统管理员重置发卡记录后重新发卡。";
rvInfo.isError = true;
return rvInfo;
}
}
}
else
{
rvInfo.messageText = "用户信息异常，请检查该用户信息后重试。";
rvInfo.isError = true;
return rvInfo;
}
}
#endregion
if (userInfo.cus_cIdentityNum == DefineConstantValue.CodeMasterDefine.KEY2_SIOT_CardUserIdentity_Student)
{
#region 学生发卡，需预充透支金额
//插入发卡信息后，充入透支金额
rvInfo = this._Reader.Recharge((short)base._CardInfoSection, base._SectionPwd, fAdvanceCost);
if (rvInfo.boolValue && !rvInfo.isError)
{
RechargeRecord_rcr_Info record = new RechargeRecord_rcr_Info();
record.rcr_cRecordID = Guid.NewGuid();
record.rcr_cCardID = cardInfo.ccm_cCardID;
record.rcr_cRechargeType = DefineConstantValue.ConsumeMoneyFlowType.Recharge_AdvanceMoney.ToString();
record.rcr_cStatus = DefineConstantValue.ConsumeMoneyFlowStatus.Finished.ToString();
record.rcr_cUserID = userID;
record.rcr_dRechargeTime = DateTime.Now;
record.rcr_cAdd = base.UserInformation.usm_cUserLoginID;
record.rcr_cLast = record.rcr_cAdd;
record.rcr_dLastDate = record.rcr_dRechargeTime;
record.rcr_fRechargeMoney = fAdvanceCost;
//成功充值后，将充值信息计入相应记录表
rvInfo = this._IRechargeRecordBL.Save(record, DefineConstantValue.EditStateEnum.OE_Insert);
if (!rvInfo.boolValue || rvInfo.isError)
{
//卡充值失败，将原金额扣除
rvInfo = this._Reader.Recharge((short)base._CardInfoSection, base._SectionPwd, fAdvanceCost * -1);
rvInfo.messageText = "发卡成功，保存预充透支金额失败。";
rvInfo.isError = true;
return rvInfo;
}
ConsumeCardInfo cardCurrentInfo = this._Reader.ReadCardInfo(base._CardInfoSection, base._SectionPwd);
string strContent = "发卡成功。" + Environment.NewLine + "学生姓名：" + userInfo.cus_cChaName;
if (cardCurrentInfo != null)
{
strContent += Environment.NewLine + "卡可用余额：￥" + cardCurrentInfo.CardBalance.ToString() + "元。";
strContent += Environment.NewLine + "（包含可透支金额：￥" + fAdvanceCost.ToString() + "元）";
strContent += Environment.NewLine + "新卡工本费：￥" + fNewCardCost.ToString() + "元。";
}
rvInfo.messageText = strContent;
}//CardRecharge
else
{
rvInfo.messageText = "发卡成功，消费卡充入预支款失败。";
rvInfo.isError = true;
return rvInfo;
}
#endregion
}
else if (userInfo.cus_cIdentityNum == DefineConstantValue.CodeMasterDefine.KEY2_SIOT_CardUserIdentity_Staff)
{
#region 老师卡发卡
rvInfo.messageText = "发卡成功。" + Environment.NewLine
+ "老师姓名：" + userInfo.cus_cChaName + "。" + Environment.NewLine
+ "新卡工本费：" + fNewCardCost.ToString() + "。";
#endregion
}
#endregion
rvInfo.ValueObject = currentPair;
//*********4、查询是否有预充值款项，有则进行预充值*********
//查找该用户是否有【转账充值】款项
List<PreRechargeRecord_prr_Info> listPreRecharge = this._IPreRechargeRecordBL.SearchRecords(new PreRechargeRecord_prr_Info()
{
prr_cUserID = userID,
prr_cStatus = Common.DefineConstantValue.ConsumeMoneyFlowStatus.WaitForAcceptTransfer.ToString()
});
if (listPreRecharge != null && listPreRecharge.Count > 0)
{
#region 预充值
//查找该用户是否有未付的【预消费】款项
decimal fSumPreCost = decimal.Zero;//未结算消费总额
List<PreConsumeRecord_pcs_Info> listPreCost = this._IPreConsumeRecordBL.SearchRecords(new PreConsumeRecord_pcs_Info()
{
pcs_cUserID = userID,
});
if (listPreCost != null)
{
listPreCost = listPreCost.Where(x =>
x.pcs_lIsSettled == false
&& x.pcs_cConsumeType != Common.DefineConstantValue.ConsumeMoneyFlowType.IndeterminateCost.ToString()
&& x.pcs_cConsumeType != Common.DefineConstantValue.ConsumeMoneyFlowType.AdvanceMealCost.ToString()
&& x.pcs_cConsumeType != Common.DefineConstantValue.ConsumeMoneyFlowType.HedgeFund.ToString()
).ToList();
if (listPreCost.Count > 0)
{
fSumPreCost = listPreCost.Sum(x => x.pcs_fCost);
}
}
ConsumeCardInfo CardInfo = this._Reader.ReadCardInfo(base._CardInfoSection, base._SectionPwd);
if (CardInfo == null)
{
rvInfo.messageText += Environment.NewLine + "确认卡片信息失败，无法继续进行预充值操作。";
rvInfo.boolValue = false;
return rvInfo;
}
decimal fCardBalance = CardInfo.CardBalance;//卡片现可用余额
decimal fPreRecharge = listPreRecharge.Sum(x => x.prr_fRechargeMoney);//预充值累积款
decimal fCardRecharge = fPreRecharge + fSumPreCost;//预充值款 + 未结算预付款 = 卡片应充值金额
if (fPreRecharge > 0 && fCardRecharge >= 0)
{
#region 存在预充值记录，并且足以扣除未结算款项
ReturnValueInfo rvInfoPreRecharge = this._Reader.Recharge(base._CardInfoSection, base._SectionPwd, fCardRecharge);
if (rvInfoPreRecharge.boolValue && !rvInfoPreRecharge.isError)
{
List<RechargeRecord_rcr_Info> listRechargeInsert = new List<RechargeRecord_rcr_Info>();
decimal fPerTimeRecharge = fSumPreCost;
//foreach (PreRechargeRecord_prr_Info preRecItem in listPreRecharge)
//{
// RechargeRecord_rcr_Info rechargeRecord = new RechargeRecord_rcr_Info();
// rechargeRecord.rcr_cAdd = base.UserInformation.usm_cUserLoginID;
// rechargeRecord.rcr_cCardID = pairInfo.ucp_cCardID;
// rechargeRecord.rcr_cLast = base.UserInformation.usm_cUserLoginID;
// rechargeRecord.rcr_cRechargeType = preRecItem.prr_cRechargeType;
// rechargeRecord.rcr_cRecordID = Guid.NewGuid();
// rechargeRecord.rcr_cStatus = DefineConstantValue.ConsumeMoneyFlowStatus.Finished.ToString();
// rechargeRecord.rcr_cUserID = pairInfo.ucp_cCUSID;
// rechargeRecord.rcr_dLastDate = DateTime.Now;
// rechargeRecord.rcr_dRechargeTime = DateTime.Now;
// rechargeRecord.rcr_fRechargeMoney = preRecItem.prr_fRechargeMoney;
// fPerTimeRecharge += preRecItem.prr_fRechargeMoney;
// if (fPerTimeRecharge < 0)
// {
// rechargeRecord.rcr_fBalance = fCardBalance;
// }
// else
// {
// rechargeRecord.rcr_fBalance = fCardBalance + fPerTimeRecharge;
// }
// preRecItem.prr_cRCRID = rechargeRecord.rcr_cRecordID;
// listRechargeInsert.Add(rechargeRecord);
//}
for (int i = 0; i < listPreRecharge.Count; i++)
{
RechargeRecord_rcr_Info rechargeRecord = new RechargeRecord_rcr_Info();
rechargeRecord.rcr_cAdd = base.UserInformation.usm_cUserLoginID;
rechargeRecord.rcr_cCardID = pairInfo.ucp_cCardID;
rechargeRecord.rcr_cLast = base.UserInformation.usm_cUserLoginID;
rechargeRecord.rcr_cRechargeType = listPreRecharge[i].prr_cRechargeType;
rechargeRecord.rcr_cRecordID = Guid.NewGuid();
rechargeRecord.rcr_cStatus = DefineConstantValue.ConsumeMoneyFlowStatus.Finished.ToString();
rechargeRecord.rcr_cUserID = pairInfo.ucp_cCUSID;
rechargeRecord.rcr_dLastDate = DateTime.Now;
rechargeRecord.rcr_dRechargeTime = DateTime.Now;
rechargeRecord.rcr_fRechargeMoney = listPreRecharge[i].prr_fRechargeMoney;
fPerTimeRecharge += listPreRecharge[i].prr_fRechargeMoney;
if (fPerTimeRecharge < 0)
{
//rechargeRecord.rcr_fBalance = fCardBalance;
if (i != listPreRecharge.Count - 1)
{
rechargeRecord.rcr_fBalance = fCardBalance;
}
else
{
rechargeRecord.rcr_fBalance = fCardBalance + fPerTimeRecharge;
}
}
else
{
rechargeRecord.rcr_fBalance = fCardBalance + fPerTimeRecharge;
}
listPreRecharge[i].prr_cRCRID = rechargeRecord.rcr_cRecordID;
listRechargeInsert.Add(rechargeRecord);
}
rvInfoPreRecharge = this._IRechargeRecordBL.UpdateRechargeRecord(listPreRecharge, listRechargeInsert, fSumPreCost);
if (rvInfoPreRecharge.boolValue && !rvInfoPreRecharge.isError)
{
rvInfo.messageText += Environment.NewLine + "存在预转账记录" + listPreRecharge.Count.ToString() + "条，款项合共：￥" + fPreRecharge.ToString() + "元，已成功充入。";
rvInfo.boolValue = true;
return rvInfo;
}
else
{
rvInfoPreRecharge = this._Reader.Recharge(base._CardInfoSection, base._SectionPwd, fPreRecharge);
if (rvInfoPreRecharge.isError || !rvInfoPreRecharge.boolValue)
{
rvInfo.messageText += Environment.NewLine + "保存预充值记录失败，卡片金额已更新，请联系管理员扣减卡金额。";
}
}
}
else
{
rvInfo.messageText += Environment.NewLine + "预充值操作失败，无法将该用户的待转账款项充入卡内，请稍后手动转账充值。" + Environment.NewLine + rvInfoPreRecharge.messageText;
rvInfo.boolValue = false;
}
#endregion
}
else
{
if (fCardRecharge < 0)
{
rvInfo.messageText += Environment.NewLine + "本用户有转账充值记录" + listPreRecharge.Count.ToString() + "条，但不足以抵扣未结算预付款，请充值。";
rvInfo.boolValue = true;
return rvInfo;
}
}
#endregion
}
else
{
rvInfo.boolValue = true;
return rvInfo;
}
}
else
{
rvInfo.messageText = "保存新发卡资料失败。" + rvInfo.messageText;
rvInfo.isError = true;
return rvInfo;
}
}
catch (Exception ex)
{
rvInfo.messageText = ex.Message;
rvInfo.isError = true;
return rvInfo;
}
}
catch (Exception exAll)
{
rvInfo.messageText = exAll.Message;
rvInfo.isError = true;
}
return rvInfo;
}
public ReturnValueInfo ResetAccountOverdraft(RechargeRecord_rcr_Info OverdraftInfo)
{
ReturnValueInfo rvInfo = new ReturnValueInfo();
if (OverdraftInfo == null)
{
rvInfo.isError = true;
rvInfo.messageText = Common.DefineConstantValue.SystemMessageText.strMessageText_E_ObjectNull;
return rvInfo;
}
try
{
//获取已发卡用户列表
ICardUserMasterDA userDA = MasterDAFactory.GetDAL<ICardUserMasterDA>(MasterDAFactory.CardUserMaster);
CardUserMaster_cus_Info userSearch = new CardUserMaster_cus_Info();
userSearch.cus_cIdentityNum = Common.DefineConstantValue.CodeMasterDefine.KEY2_SIOT_CardUserIdentity_Student;
List<CardUserMaster_cus_Info> listUsers = userDA.SearchRecordsWithCardInfo(userSearch);
if (listUsers != null)
{
listUsers = listUsers.Where(x => x.cus_lValid && x.PairCardNo != null).ToList();
}
//获取透支额列表
IRechargeRecordDA rechargeDA = MasterDAFactory.GetDAL<IRechargeRecordDA>(MasterDAFactory.RechargeRecord);
RechargeRecord_rcr_Info rechargeSearch = new RechargeRecord_rcr_Info();
rechargeSearch.rcr_cRechargeType = Common.DefineConstantValue.ConsumeMoneyFlowType.Recharge_AdvanceMoney.ToString();
List<RechargeRecord_rcr_Info> listRecharge = rechargeDA.SearchRecords(rechargeSearch);
List<RechargeRecord_rcr> listRechargeRec = new List<RechargeRecord_rcr>();
List<PreConsumeRecord_pcs> listInsertPreCost = new List<PreConsumeRecord_pcs>();
if (listRecharge != null && listRecharge.Count > 0)
{
IEnumerable<IGrouping<Guid, RechargeRecord_rcr_Info>> groupRecharge = listRecharge.GroupBy(x => x.rcr_cUserID);
foreach (var itemRecharge in groupRecharge)
{
Guid userID = itemRecharge.Key;
CardUserMaster_cus_Info userInfo = listUsers.Find(x => x.cus_cRecordID == userID);
if (userInfo == null)
{
continue;
}
RechargeRecord_rcr_Info userRecharge = itemRecharge.OrderByDescending(x => x.rcr_dRechargeTime).FirstOrDefault();
if (userRecharge != null)
{
Guid sourceID = Guid.NewGuid();
if (OverdraftInfo.rcr_fRechargeMoney > userRecharge.rcr_fRechargeMoney)
{
//新的透支额大于当前透支额
}
else if (OverdraftInfo.rcr_fRechargeMoney < userRecharge.rcr_fRechargeMoney)
{
//新的透支额小于当前透支额 eg: 0, 50
PreConsumeRecord_pcs preCost = new PreConsumeRecord_pcs();
preCost.pcs_cRecordID = Guid.NewGuid();
preCost.pcs_cSourceID = sourceID;
preCost.pcs_cAccountID = userInfo.AccountID.Value;
preCost.pcs_cAdd = OverdraftInfo.rcr_cAdd;
preCost.pcs_cConsumeType = Common.DefineConstantValue.ConsumeMoneyFlowType.Recharge_AdvanceMoney.ToString();
preCost.pcs_cUserID = userID;
preCost.pcs_dAddDate = DateTime.Now;
preCost.pcs_dConsumeDate = DateTime.Now;
preCost.pcs_fCost = Math.Abs(OverdraftInfo.rcr_fRechargeMoney - userRecharge.rcr_fRechargeMoney);
listInsertPreCost.Add(preCost);
}
else
{
continue;
}
RechargeRecord_rcr insertRechrage = Common.General.CopyObjectValue<RechargeRecord_rcr_Info, RechargeRecord_rcr>(userRecharge);
insertRechrage.rcr_cRecordID = sourceID;
insertRechrage.rcr_fRechargeMoney = OverdraftInfo.rcr_fRechargeMoney;
insertRechrage.rcr_fBalance = 0;
insertRechrage.rcr_dRechargeTime = DateTime.Now;
insertRechrage.rcr_cAdd = OverdraftInfo.rcr_cAdd;
insertRechrage.rcr_cLast = OverdraftInfo.rcr_cLast;
insertRechrage.rcr_cDesc = OverdraftInfo.rcr_cDesc;
insertRechrage.rcr_cStatus = Common.DefineConstantValue.ConsumeMoneyFlowStatus.Finished.ToString();
listRechargeRec.Add(insertRechrage);
}
}
}
if (listInsertPreCost.Count == listRechargeRec.Count && listRechargeRec.Count > 0)
{
using (SIOTSDB_HHZXDataContext db = new SIOTSDB_HHZXDataContext())
{
db.Connection.Open();
db.Transaction = db.Connection.BeginTransaction();
try
{
db.RechargeRecord_rcr.InsertAllOnSubmit(listRechargeRec);
db.PreConsumeRecord_pcs.InsertAllOnSubmit(listInsertPreCost);
db.SubmitChanges();
db.Transaction.Commit();
rvInfo.boolValue = true;
}
catch (Exception exx)
{
db.Transaction.Rollback();
db.Connection.Close();
throw exx;
}
}
}
}
catch (Exception ex)
{
throw ex;
}
return rvInfo;
}
public ReturnValueInfo CashRefund(RechargeRecord_rcr_Info refundRecord, decimal fPreCostRecharge)
{
ReturnValueInfo rvInfo = new ReturnValueInfo();
try
{
#region 数据检验
if (refundRecord == null)
{
rvInfo.messageText = Common.DefineConstantValue.SystemMessageText.strMessageText_E_ObjectNull;
rvInfo.isError = true;
return rvInfo;
}
RechargeRecord_rcr refundInfo = Common.General.CopyObjectValue<RechargeRecord_rcr_Info, RechargeRecord_rcr>(refundRecord);
if (refundInfo == null)
{
rvInfo.messageText = Common.DefineConstantValue.SystemMessageText.strMessageText_E_ObjectNull;
rvInfo.isError = true;
return rvInfo;
}
#endregion
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 == refundRecord.rcr_cUserID).FirstOrDefault();
#region 账户信息丢失时，自动创建账户信息
if (account == null)
{
account = new CardUserAccount_cua();
account.cua_cRecordID = Guid.NewGuid();
account.cua_cCUSID = refundRecord.rcr_cUserID;
account.cua_cAdd = refundRecord.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
if (account != null)
{
if (Math.Abs(fPreCostRecharge) > 0)
{
#region 检查未付款记录，并更新状态
List<PreConsumeRecord_pcs> listPreCosts = db.PreConsumeRecord_pcs.Where(x =>
x.pcs_cAccountID == account.cua_cRecordID
&& x.pcs_cUserID == refundInfo.rcr_cUserID
&& x.pcs_lIsSettled == false
).ToList();
//筛选预付款的消费类型
listPreCosts = filterRecord_CanComputePreCost(listPreCosts);
if (listPreCosts != null && listPreCosts.Count > 0)
{
decimal fSumPreCost = listPreCosts.Sum(x => x.pcs_fCost);
fSumPreCost = Math.Abs(fSumPreCost);
if (fSumPreCost != Math.Abs(fPreCostRecharge))
{
rvInfo.messageText = "未结算款项记录异常。";
db.Transaction.Rollback();
rvInfo.isError = true;
return rvInfo;
}
else
{
List<CardUserAccountDetail_cuad> listAccountPreCost = new List<CardUserAccountDetail_cuad>();
List<SystemAccountDetail_sad> listSysAccountPreCost = new List<SystemAccountDetail_sad>();
foreach (PreConsumeRecord_pcs preCostItem in listPreCosts)
{
preCostItem.pcs_lIsSettled = true;
preCostItem.pcs_dSettleTime = DateTime.Now;
#region 插入欠费缴费记录
//插入用户账户记录
CardUserAccountDetail_cuad accountDetailPreCost = new CardUserAccountDetail_cuad();
accountDetailPreCost.cuad_cRecordID = Guid.NewGuid();
accountDetailPreCost.cuad_cConsumeID = refundInfo.rcr_cRecordID;
accountDetailPreCost.cuad_cCUAID = account.cua_cRecordID;
accountDetailPreCost.cuad_cFlowType = preCostItem.pcs_cConsumeType;
accountDetailPreCost.cuad_cOpt = refundInfo.rcr_cLast;
accountDetailPreCost.cuad_dOptTime = DateTime.Now;
accountDetailPreCost.cuad_fFlowMoney = preCostItem.pcs_fCost;
listAccountPreCost.Add(accountDetailPreCost);
//插入系统账户记录
SystemAccountDetail_sad sysAccountDetailPreCost = new SystemAccountDetail_sad();
sysAccountDetailPreCost.sad_cRecordID = Guid.NewGuid();
sysAccountDetailPreCost.sad_cConsumeID = refundInfo.rcr_cRecordID;
sysAccountDetailPreCost.sad_cDesc = DefineConstantValue.GetMoneyFlowDesc(preCostItem.pcs_cConsumeType);
sysAccountDetailPreCost.sad_cFLowMoney = preCostItem.pcs_fCost;
sysAccountDetailPreCost.sad_cFlowType = preCostItem.pcs_cConsumeType;
sysAccountDetailPreCost.sad_cOpt = refundInfo.rcr_cLast;
sysAccountDetailPreCost.sad_dOptTime = DateTime.Now;
listSysAccountPreCost.Add(sysAccountDetailPreCost);
#endregion
}
if (listAccountPreCost.Count > 0)
{
listToInsertAccountDetail.AddRange(listAccountPreCost);
listToInsertSysDetail.AddRange(listSysAccountPreCost);
}
}
}
else
{
if (listPreCosts == null)
{
rvInfo.messageText = "未结算款项记录异常。";
rvInfo.isError = true;
return rvInfo;
}
}
#endregion
}
#region 插入退款记录
//插入用户账户退款记录
CardUserAccountDetail_cuad accountDetail = new CardUserAccountDetail_cuad();
accountDetail.cuad_cRecordID = Guid.NewGuid();
accountDetail.cuad_cConsumeID = refundInfo.rcr_cRecordID;
accountDetail.cuad_cCUAID = account.cua_cRecordID;
accountDetail.cuad_cFlowType = refundInfo.rcr_cRechargeType;
accountDetail.cuad_cOpt = refundInfo.rcr_cLast;
accountDetail.cuad_dOptTime = DateTime.Now;
accountDetail.cuad_fFlowMoney = refundInfo.rcr_fRechargeMoney;
listToInsertAccountDetail.Add(accountDetail);
//插入系统账户退款记录
SystemAccountDetail_sad sysAccountDetail = new SystemAccountDetail_sad();
sysAccountDetail.sad_cRecordID = Guid.NewGuid();
sysAccountDetail.sad_cConsumeID = refundInfo.rcr_cRecordID;
sysAccountDetail.sad_cDesc = refundInfo.rcr_cDesc;
sysAccountDetail.sad_cFLowMoney = refundInfo.rcr_fRechargeMoney;
sysAccountDetail.sad_cFlowType = refundInfo.rcr_cRechargeType;
sysAccountDetail.sad_cOpt = refundInfo.rcr_cLast;
sysAccountDetail.sad_dOptTime = DateTime.Now;
listToInsertSysDetail.Add(sysAccountDetail);
#endregion
decimal fAdvanceCost = decimal.Zero;
#region 获取透支金额
List<RechargeRecord_rcr> listAdvanceCost = db.RechargeRecord_rcr.Where(x =>
x.rcr_cUserID == refundInfo.rcr_cUserID
&& x.rcr_cRechargeType == Common.DefineConstantValue.ConsumeMoneyFlowType.Recharge_AdvanceMoney.ToString()).ToList();
if (listAdvanceCost != null && listAdvanceCost.Count > 0)
{
RechargeRecord_rcr advanceCost = listAdvanceCost.OrderByDescending(x => x.rcr_dRechargeTime).FirstOrDefault();
if (advanceCost != null)
{
fAdvanceCost = advanceCost.rcr_fRechargeMoney;
}
}
#endregion
decimal fAccountCurrentBalance = account.cua_fCurrentBalance - fPreCostRecharge - refundInfo.rcr_fRechargeMoney;//退款后的最新账户余额
decimal fCardCurrentBalance = refundInfo.rcr_fBalance - fAdvanceCost;//退款后的卡余额
if (fAccountCurrentBalance > fCardCurrentBalance)
{
//账户余额比卡余额大，则需要插入补充金额
#region 插入补充消费记录
decimal fInsert = fAccountCurrentBalance - fCardCurrentBalance;
//【系统账户余额】 大于 【卡实际余额】
// 新增一条平数的预扣费记录
PreConsumeRecord_pcs unconfirmRecord = new PreConsumeRecord_pcs();
unconfirmRecord.pcs_cAccountID = account.cua_cRecordID;
unconfirmRecord.pcs_cRecordID = Guid.NewGuid();
unconfirmRecord.pcs_cConsumeType = DefineConstantValue.ConsumeMoneyFlowType.HedgeFund.ToString();
unconfirmRecord.pcs_cUserID = refundInfo.rcr_cUserID;
unconfirmRecord.pcs_cAdd = refundInfo.rcr_cLast;
unconfirmRecord.pcs_dAddDate = DateTime.Now;
unconfirmRecord.pcs_dConsumeDate = DateTime.Now;
unconfirmRecord.pcs_fCost = fInsert;
unconfirmRecord.pcs_lIsSettled = false;
listToInsertPreCost.Add(unconfirmRecord);
//用户账户
CardUserAccountDetail_cuad userAccount = new CardUserAccountDetail_cuad();
userAccount.cuad_cConsumeID = unconfirmRecord.pcs_cRecordID;
userAccount.cuad_cCUAID = account.cua_cRecordID;
userAccount.cuad_cFlowType = unconfirmRecord.pcs_cConsumeType;
userAccount.cuad_cOpt = refundInfo.rcr_cLast;
userAccount.cuad_cRecordID = Guid.NewGuid();
userAccount.cuad_dOptTime = DateTime.Now;
userAccount.cuad_fFlowMoney = fInsert;
listToInsertAccountDetail.Add(userAccount);
//系统账户
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 = fInsert;
sysAccount.sad_cFlowType = unconfirmRecord.pcs_cConsumeType;
sysAccount.sad_cOpt = refundInfo.rcr_cLast;
sysAccount.sad_dOptTime = DateTime.Now;
listToInsertSysDetail.Add(sysAccount);
#endregion
}
try
{
db.Connection.Open();
db.Transaction = db.Connection.BeginTransaction();
refundInfo.rcr_dRechargeTime = DateTime.Now;
refundInfo.rcr_dLastDate = DateTime.Now;
db.RechargeRecord_rcr.InsertOnSubmit(refundInfo);
account.cua_fCurrentBalance = fCardCurrentBalance;
account.cua_dLastSyncTime = DateTime.Now;
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);
if (listToInsertRecharge != null && listToInsertRecharge.Count > 0)
db.RechargeRecord_rcr.InsertAllOnSubmit(listToInsertRecharge);
db.SubmitChanges();
db.Transaction.Commit();
rvInfo.boolValue = true;
}
catch (Exception exx)
{
db.Transaction.Rollback();
db.Connection.Close();
throw exx;
}
}
}
}
catch (Exception ex)
{
rvInfo.isError = true;
rvInfo.messageText = ex.Message;
}
return rvInfo;
}
public ReturnValueInfo UpdateRecord(RechargeRecord_rcr_Info infoObject)
{
ReturnValueInfo rvInfo = new ReturnValueInfo();
try
{
if (infoObject != null)
{
using (SIOTSDB_HHZXDataContext db = new SIOTSDB_HHZXDataContext())
{
RechargeRecord_rcr record = db.RechargeRecord_rcr.Where(x => x.rcr_cRecordID == infoObject.rcr_cRecordID).FirstOrDefault();
if (record != null)
{
record.rcr_cLast = infoObject.rcr_cLast;
record.rcr_cCardID = infoObject.rcr_cCardID;
record.rcr_cRechargeType = infoObject.rcr_cRechargeType;
record.rcr_cStatus = infoObject.rcr_cStatus;
record.rcr_cUserID = infoObject.rcr_cUserID;
record.rcr_dLastDate = infoObject.rcr_dLastDate;
record.rcr_fRechargeMoney = infoObject.rcr_fRechargeMoney;
record.rcr_dRechargeTime = infoObject.rcr_dRechargeTime;
record.rcr_cDesc = infoObject.rcr_cDesc;
db.SubmitChanges();
rvInfo.boolValue = true;
}
else
{
rvInfo.messageText = "GetEntity is null";
}
}
}
else
{
rvInfo.messageText = Common.DefineConstantValue.SystemMessageText.strMessageText_E_ObjectNull;
}
}
catch (Exception ex)
{
rvInfo.isError = true;
rvInfo.messageText = ex.Message;
}
return rvInfo;
}
/// <summary>
/// 初始化读卡信息
/// </summary>
void InitReadCard()
{
labCardNo.Text = string.Empty.PadLeft(8, '0');
labName.Text = string.Empty;
labPreCost.Text = "0.00";
labRecharge.Text = "0.00";
labTotalRecharge.Text = "0.00";
labCardBalance.Text = "0.00";
lvRechargeList.SetDataSource<RechargeInfo>(new List<RechargeInfo>());
ListViewSorter sorter = new ListViewSorter(1, SortOrder.Ascending);
lvRechargeList.ListViewItemSorter = sorter;
lvRechargeList.Sorting = SortOrder.Ascending;
WaitForCardReader wfcrFrm = new WaitForCardReader(this._strPwd);
GlobalVar.OpenFormList.Add(wfcrFrm);
if (wfcrFrm.ShowDialog() == DialogResult.OK)
{
this._CardInfo = wfcrFrm.CardInfo;
if (this._CardInfo != null)
{
string strCardID = this._CardInfo.CardSourceID;
labCardBalance.Text = this._CardInfo.CardBalance.ToString();
UserCardPair_ucp_Info cardPair = this._IUserCardPairBL.SearchRecords(new UserCardPair_ucp_Info()
{
ucp_iCardNo = Convert.ToInt16(this._CardInfo.CardNo),
ucp_cCardID = strCardID,
ucp_cUseStatus = Common.DefineConstantValue.ConsumeCardStatus.Normal.ToString()
}).FirstOrDefault();
if (cardPair != null)
{
if (cardPair.CardOwner != null && cardPair.CardOwner.AccountInfo != null)
{
ucMealBookingDetail.ShowData(cardPair.CardOwner);
labName.Text = cardPair.CardOwner.cus_cChaName;
labCardNo.Text = this._CardInfo.CardNo.PadLeft(8, '0');
this._UserInfo = cardPair.CardOwner;
//预充值表
List<PreRechargeRecord_prr_Info> listPreRechargeRecord = this._IPreRechargeRecordBL.SearchRecords(new PreRechargeRecord_prr_Info()
{
prr_cUserID = cardPair.ucp_cCUSID,
prr_cStatus = Common.DefineConstantValue.ConsumeMoneyFlowStatus.WaitForAcceptTransfer.ToString()
});
if (listPreRechargeRecord == null && (listPreRechargeRecord != null && listPreRechargeRecord.Count > 0))
{
base.MessageDialog("提示", "没有可用的预充值的记录。");
return;
}
//转账列表
List<RechargeRecord_rcr_Info> listRechargeRecord = new List<RechargeRecord_rcr_Info>();
foreach (PreRechargeRecord_prr_Info item in listPreRechargeRecord)
{
RechargeRecord_rcr_Info rechrageInfo = new RechargeRecord_rcr_Info();
rechrageInfo.rcr_cAdd = "tqs";
rechrageInfo.rcr_cCardID = this._CardInfo.CardSourceID;
rechrageInfo.rcr_cLast = "tqs";
rechrageInfo.rcr_cRechargeType = item.prr_cRechargeType;
rechrageInfo.rcr_cRecordID = Guid.NewGuid();
rechrageInfo.rcr_cStatus = Common.DefineConstantValue.ConsumeMoneyFlowStatus.Finished.ToString();
rechrageInfo.rcr_cUserID = item.prr_cUserID;
rechrageInfo.rcr_dLastDate = DateTime.Now;
rechrageInfo.rcr_dRechargeTime = item.prr_dRechargeTime;
rechrageInfo.rcr_fBalance = 0;
rechrageInfo.rcr_fRechargeMoney = item.prr_fRechargeMoney;
item.prr_cRCRID = rechrageInfo.rcr_cRecordID;
listRechargeRecord.Add(rechrageInfo);
}
this._ListPreRechargeRecord = listPreRechargeRecord;
this._ListRechargeRecord = listRechargeRecord;
List<RechargeInfo> listRechargeInfo = getRechargeInfo(listRechargeRecord);
if (listRechargeInfo != null)
{
listRechargeInfo = listRechargeInfo.OrderByDescending(x => x.RechargeTime).ToList();
lvRechargeList.SetDataSource<RechargeInfo>(listRechargeInfo);
decimal dRecharge = listRechargeInfo.Sum(x => x.RechargeMoney);
if (dRecharge != 0)
{
labRecharge.Text = dRecharge.ToString();
}
}
//未结算的预消费列表
List<PreConsumeRecord_pcs_Info> listPreCost = this._IPreConsumeRecordBL.SearchRecords(new PreConsumeRecord_pcs_Info() { pcs_cAccountID = cardPair.CardOwner.AccountInfo.cua_cRecordID });
if (listPreCost != null)
{
listPreCost = listPreCost.Where(x =>
x.pcs_cConsumeType != Common.DefineConstantValue.ConsumeMoneyFlowType.IndeterminateCost.ToString()
&& x.pcs_cConsumeType != Common.DefineConstantValue.ConsumeMoneyFlowType.AdvanceMealCost.ToString()
&& x.pcs_cConsumeType != Common.DefineConstantValue.ConsumeMoneyFlowType.HedgeFund.ToString()
&& x.pcs_lIsSettled == false
&& x.pcs_cUserID == cardPair.CardOwner.cus_cRecordID
).ToList();
labPreCost.Text = Math.Round(listPreCost.Sum(x => x.pcs_fCost), 2).ToString();
}
else
{
labPreCost.Text = "0.00";
}
decimal fTotalRecharge = decimal.Parse(labRecharge.Text) + decimal.Parse(labPreCost.Text);
decimal fActualRecharge = decimal.Parse(labRecharge.Text) + decimal.Parse(labPreCost.Text) + decimal.Parse(labCardBalance.Text);
labTotalRecharge.Text = fTotalRecharge.ToString();
if (fActualRecharge >= decimal.Zero)
btnRecharge.Enabled = true;
else
btnRecharge.Enabled = false;
}
else
{
base.MessageDialog("提示", "本卡持卡人信息异常！");
return;
}
}
else
{
base.MessageDialog("提示", "未找到此卡或此卡不能進行充值！");
return;
}
}
else
{
base.MessageDialog("提示", "读卡失败，请重试。" + Environment.NewLine + "（如多次失败，卡片有可能已损坏，请及时申请更换）");
return;
}
}
}
private void btnConfirmRefund_Click(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(tbxRefundMoney.Text.Trim()))
{
this.ShowWarningMessage("请输入退款金额。");
tbxRefundMoney.Focus();
return;
}
decimal fRefund;//退款额
bool res = decimal.TryParse(tbxRefundMoney.Text.Trim(), out fRefund);
if (!res)
{
this.ShowWarningMessage("请检查退款金额的格式。");
tbxRefundMoney.Focus();
return;
}
if (fRefund <= 0)
{
this.ShowWarningMessage("退款金额需大于0，请重新输入。");
tbxRefundMoney.Focus();
return;
}
else if (fRefund > Common.DefineConstantValue.MaxRechargeVal)
{
this.ShowWarningMessage("退款金额不能大于" + Common.DefineConstantValue.MaxRechargeVal.ToString() + "，请重新输入。");
tbxRefundMoney.Focus();
tbxRefundMoney.SelectAll();
return;
}
decimal fCardBalance = this._CurrentCardInfo.CardBalance;//卡内余额
decimal fPreCost = decimal.Parse(labPreCost.Text);//未结算预付款
decimal fAdvance = decimal.Zero;//透支额
//************计算卡内金额是否足以退款*******************
#region 计算卡内金额是否足以退款
if (base._CurrentCardUserInfo.cus_cIdentityNum == Common.DefineConstantValue.CodeMasterDefine.KEY2_SIOT_CardUserIdentity_Student)
{
List<RechargeRecord_rcr_Info> listAdvance = this._IRechargeRecordBL.SearchRecords(new RechargeRecord_rcr_Info()
{
rcr_cUserID = base._CurrentCardUserInfo.cus_cRecordID,
rcr_cRechargeType = Common.DefineConstantValue.ConsumeMoneyFlowType.Recharge_AdvanceMoney.ToString(),
});
listAdvance = listAdvance.OrderByDescending(x => x.rcr_dRechargeTime).ToList();
if (listAdvance != null && listAdvance.Count > 0)
{
fAdvance = listAdvance[0].rcr_fRechargeMoney;
}
}
if (ckbPreCost.Checked)
{
if (fCardBalance - fAdvance - Math.Abs(fPreCost) < fRefund)
{
ShowWarningMessage("卡余额不足以支付本次退款。");
return;
}
}
else
{
if (fCardBalance - fAdvance < fRefund)
{
ShowWarningMessage("卡余额不足以支付本次退款。");
return;
}
}
#endregion
if (string.IsNullOrEmpty(tbxRefundDesc.Text))
{
ShowWarningMessage("请先输入退款原因。");
tbxRefundDesc.Focus();
tbxRefundDesc.SelectAll();
return;
}
if (base._CurrentCardUserInfo == null)
{
this.ShowWarningMessage("当前卡用户信息异常，请重新读卡。");
btnReadCard.Focus();
return;
}
if (base.UserInformation == null)
{
this.ShowWarningMessage("当前操作用户信息异常，请重新登录。");
return;
}
dlgConfirmInfo dlg = new dlgConfirmInfo();
dlg.IsPrinted = cbxPrint.Checked;
dlg.RefundMoney = fRefund * -1;
if (ckbPreCost.Checked)
{
dlg.PreCostMoney = Math.Abs(fPreCost) * -1;
}
else
{
dlg.PreCostMoney = 0;
}
dlg.UserInfo = this._CurrentCardUserInfo;
dlg.CardInfo = base._CurrentCardInfo;
if (dlg.ShowDialog() == DialogResult.OK)
{
ConsumeCardInfo chkCardInfo = this._Reader.ReadCardInfo(base._CardInfoSection, base._SectionPwd);
if (chkCardInfo == null || (chkCardInfo != null && chkCardInfo.CardSourceID != base._CurrentCardInfo.CardSourceID))
{
this.ShowWarningMessage("卡片信息已变更，请重新读卡后操作。");
resetAllControls();
return;
}
this.Cursor = Cursors.WaitCursor;
try
{
//物理卡充值
ReturnValueInfo rvInfo = this._Reader.Recharge(base._CardInfoSection, base._SectionPwd, (fRefund + Math.Abs(dlg.PreCostMoney)) * -1);
if (rvInfo.boolValue && !rvInfo.isError)
{
RechargeRecord_rcr_Info rechargeInfo = new RechargeRecord_rcr_Info();
rechargeInfo.rcr_cRecordID = Guid.NewGuid();
rechargeInfo.rcr_cAdd = base.UserInformation.usm_cUserLoginID;
rechargeInfo.rcr_cLast = base.UserInformation.usm_cUserLoginID;
rechargeInfo.rcr_cCardID = chkCardInfo.CardSourceID;
rechargeInfo.rcr_cDesc = tbxRefundDesc.Text;
rechargeInfo.rcr_cRechargeType = Common.DefineConstantValue.ConsumeMoneyFlowType.Refund_PersonalCash.ToString();
rechargeInfo.rcr_cStatus = Common.DefineConstantValue.ConsumeMoneyFlowStatus.Finished.ToString();
rechargeInfo.rcr_cUserID = base._CurrentCardUserInfo.cus_cRecordID;
rechargeInfo.rcr_dLastDate = DateTime.Now;
rechargeInfo.rcr_dRechargeTime = DateTime.Now;
rechargeInfo.rcr_fBalance = fCardBalance - (fRefund + Math.Abs(dlg.PreCostMoney));
rechargeInfo.rcr_fRechargeMoney = fRefund;
if (ckbPreCost.Checked)
{
rvInfo = this._IRechargeRecordBL.CashRefund(rechargeInfo, dlg.PreCostMoney);
}
else
{
rvInfo = this._IRechargeRecordBL.CashRefund(rechargeInfo, 0);
}
if (rvInfo.boolValue && !rvInfo.isError)
{
this.Cursor = Cursors.Default;
this.ShowInformationMessage("退款成功。" + Environment.NewLine + "退款用户：" + this._CurrentCardUserInfo.cus_cChaName + "，退款金额：" + fRefund.ToString() + "元");
resetAllControls();
return;
}
else
{
#region 退款回滚
ShowErrorMessage("上传退款记录失败，需要进行回滚扣费，请摆放好卡片后，点击确定。");
ConsumeCardInfo cardInfoRollback = this._Reader.ReadCardInfo(base._CardInfoSection, base._SectionPwd);
if (cardInfoRollback.CardSourceID != chkCardInfo.CardSourceID)
{
ShowWarningMessage("卡片信息不符合，请核对后重新放卡，原卡片卡号为：" + chkCardInfo.CardNo.ToString() + ",卡信息为：" + chkCardInfo.Name);
cardInfoRollback = this._Reader.ReadCardInfo(base._CardInfoSection, base._SectionPwd);
if (cardInfoRollback.CardSourceID == chkCardInfo.CardSourceID)
{
//录入退款记录失败，则需要将原先充入的卡金额扣除，如果卡已被取走，则需等待后台自动同步金额
rvInfo = this._Reader.Recharge(base._CardInfoSection, base._SectionPwd, fRefund + Math.Abs(dlg.PreCostMoney));
if (rvInfo.boolValue && !rvInfo.isError)
{
ShowInformationMessage("回滚扣费成功，可重新进行充值。");
return;
}
else
{
ShowWarningMessage("回滚扣费失败，请联系系统管理员处理问题卡片。");
}
}
else
{
ShowWarningMessage("核对信息失败，请联系系统管理员处理问题卡片。");
}
}
else
{
rvInfo = this._Reader.Recharge(base._CardInfoSection, base._SectionPwd, fRefund + Math.Abs(dlg.PreCostMoney));
if (rvInfo.boolValue && !rvInfo.isError)
{
ShowInformationMessage("回滚扣费成功，可重新进行充值。");
return;
}
else
{
ShowWarningMessage("回滚扣费失败，请联系系统管理员处理问题卡片。");
}
}
#endregion
}
resetAllControls();
this.Cursor = Cursors.Default;
this.ShowWarningMessage("现金退款失败。" + rvInfo.messageText);
return;
}
else
{
resetAllControls();
this.Cursor = Cursors.Default;
this.ShowWarningMessage("现金退款失败。" + rvInfo.messageText);
return;
}
}
catch (Exception ex)
{
this.Cursor = Cursors.Default;
this.ShowErrorMessage("退款失败。" + Environment.NewLine + ex);
return;
}
}
}
/// <summary>
/// 是否为需要记录到用户账户的数据
/// </summary>
/// <param name="record"></param>
/// <returns></returns>
bool IsUserAccountRecord(RechargeRecord_rcr_Info record)
{
if (record != null)
{
if (record.rcr_cRechargeType == DefineConstantValue.ConsumeMoneyFlowType.Recharge_AdvanceMoney.ToString() || record.rcr_cRechargeType == DefineConstantValue.ConsumeMoneyFlowType.Recharge_BatchTransfer.ToString() || record.rcr_cRechargeType == DefineConstantValue.ConsumeMoneyFlowType.Recharge_PersonalTransfer.ToString() || record.rcr_cRechargeType == DefineConstantValue.ConsumeMoneyFlowType.Refund_BatchTransfer.ToString() || record.rcr_cRechargeType == DefineConstantValue.ConsumeMoneyFlowType.Refund_PersonalTransfer.ToString())
{
return false;
}
}
return true;
}
public ReturnValueInfo InsertRecord(RechargeRecord_rcr_Info infoObject)
{
ReturnValueInfo rvInfo = new ReturnValueInfo();
try
{
if (infoObject != null)
{
using (SIOTSDB_HHZXDataContext db = new SIOTSDB_HHZXDataContext())
{
RechargeRecord_rcr record = Common.General.CopyObjectValue<RechargeRecord_rcr_Info, RechargeRecord_rcr>(infoObject);
if (record != null)
{
db.RechargeRecord_rcr.InsertOnSubmit(record);
db.SubmitChanges();
rvInfo.boolValue = true;
rvInfo.ValueObject = infoObject;
}
else
{
rvInfo.messageText = "TransEntity is null";
}
}
}
else
{
rvInfo.messageText = Common.DefineConstantValue.SystemMessageText.strMessageText_E_ObjectNull;
}
}
catch (Exception ex)
{
rvInfo.isError = true;
rvInfo.messageText = ex.Message;
}
return rvInfo;
}
private void btnConfirmRecharge_Click(object sender, EventArgs e)
{
bool resUkey = base.CheckUKey();
if (!resUkey)
{
return;
}
if (base._CurrentCardInfo == null)
{
this.ShowWarningMessage("请重新读卡。");
btnRead.Focus();
return;
}
if (string.IsNullOrEmpty(tbxRechargeMoney.Text.Trim()))
{
this.ShowWarningMessage("请输入充值金额。");
tbxRechargeMoney.Focus();
tbxRechargeMoney.SelectAll();
return;
}
decimal fRecharge;//实际充值金额
#region 检查实际充值金额
bool res = decimal.TryParse(tbxRechargeMoney.Text.Trim(), out fRecharge);
if (!res)
{
this.ShowWarningMessage("请检查充值金额的格式。");
tbxRechargeMoney.Focus();
tbxRechargeMoney.SelectAll();
return;
}
if (fRecharge <= 0)
{
this.ShowWarningMessage("充值金额需大于0，请重新输入。");
tbxRechargeMoney.Focus();
tbxRechargeMoney.SelectAll();
return;
}
else if (fRecharge > Common.DefineConstantValue.MaxRechargeVal)
{
this.ShowWarningMessage("充值金额不能大于" + Common.DefineConstantValue.MaxRechargeVal.ToString() + "，请重新输入。");
tbxRechargeMoney.Focus();
tbxRechargeMoney.SelectAll();
return;
}
#endregion
decimal fPreCost;//当次欠费，显示为负数
#region 检查当次欠费
bool resPreCost = decimal.TryParse(labPreCost.Text, out fPreCost);
if (!resPreCost)
{
this.ShowWarningMessage("充值金额需大于0，请重新输入。");
btnRead.Focus();
return;
}
#endregion
if (base._CurrentCardInfo == null)
{
ShowWarningMessage("原卡信息异常，请重新读卡确认。");
btnRead.Focus();
return;
}
if (this._CurrentPairInfo == null)
{
ShowWarningMessage("卡信息异常，请重新读卡确认。");
btnRead.Focus();
return;
}
if (base._CurrentCardUserInfo == null)
{
ShowWarningMessage("卡用户信息异常，请重新读卡确认");
btnRead.Focus();
return;
}
decimal fAdvanceMoney = decimal.Zero;
RechargeRecord_rcr_Info searchAdvance = new RechargeRecord_rcr_Info();
//searchAdvance.rcr_cCardID = this._CurrentCardInfo.CardSourceID;
searchAdvance.rcr_cUserID = this._CurrentCardUserInfo.cus_cRecordID;
searchAdvance.rcr_cRechargeType = Common.DefineConstantValue.ConsumeMoneyFlowType.Recharge_AdvanceMoney.ToString();
RechargeRecord_rcr_Info advanceRecharge = this._IRechargeRecordBL.SearchRecords(searchAdvance).FirstOrDefault();
if (advanceRecharge != null)
{
fAdvanceMoney = advanceRecharge.rcr_fRechargeMoney;
}
//确认页面
dlgConfirmInfo dlg = new dlgConfirmInfo();
dlg.CardInfo = base._CurrentCardInfo;
dlg.UserInfo = base._CurrentCardUserInfo;
dlg.IsPrinted = cbxPrint.Checked;
dlg.RechargeMoney = fRecharge;
dlg.AdvanceMoney = fAdvanceMoney;
if (ckbIsSyncUnPay.Checked)
{
dlg.PreCostMoney = fPreCost;
}
else
{
dlg.PreCostMoney = decimal.Zero;
}
if (dlg.ShowDialog() == DialogResult.OK)
{
this.Cursor = Cursors.WaitCursor;
decimal fRechargeDeduct = decimal.Zero;
if (ckbIsSyncUnPay.Checked)
{
fRechargeDeduct = fRecharge + fPreCost;//已经扣除的预付款数据
if (fRechargeDeduct < fRecharge)
fPreCost = Math.Abs(fPreCost);
else
fPreCost = 0;
}
else
{
fRechargeDeduct = fRecharge;
fPreCost = 0;
}
//卡信息再次验证
ConsumeCardInfo cardInfo = this._Reader.ReadCardInfo(base._CardInfoSection, base._SectionPwd);
#region 卡片信息再次验证
if (cardInfo == null)
{
ShowWarningMessage("充值失败。" + Environment.NewLine + "无法确认充值卡信息，请重新读卡再试。");
this.Cursor = Cursors.Default;
return;
}
if (cardInfo.CardSourceID != dlg.CardInfo.CardSourceID)
{
ShowWarningMessage("充值失败。" + Environment.NewLine + "充值卡信息已变更，请重新读卡再试。");
this.Cursor = Cursors.Default;
return;
}
#endregion
//修正卡显示资料
#region 修正卡显示资料
try
{
string strOldCardName = cardInfo.Name.Trim();
string strCurrentCardName = (this._CurrentPairInfo.CardOwner.ClassInfo.GradeInfo.gdm_cAbbreviation + this._CurrentPairInfo.CardOwner.cus_cChaName).Trim();
if (strOldCardName != strCurrentCardName)
{
ConsumeCardInfo changeCardInfo = new ConsumeCardInfo();
changeCardInfo.CardBalance = this._CurrentCardInfo.CardBalance;
changeCardInfo.CardNo = this._CurrentCardInfo.CardNo;
changeCardInfo.CardPwd = this._CurrentCardInfo.CardPwd;
changeCardInfo.CardSourceID = this._CurrentCardInfo.CardSourceID;
changeCardInfo.CardBalance = this._CurrentCardInfo.CardBalance;
changeCardInfo.Name = strCurrentCardName;
//年级信息发生变更，修改对应信息
ReturnValueInfo rvChangeCardInfo = this._Reader.WriteCardInfo(base._CardInfoSection, base._SectionPwd, changeCardInfo);
}
}
catch (Exception)
{ }
#endregion
//先进行【卡物理充值】
ReturnValueInfo rvInfo = this._Reader.Recharge(base._CardInfoSection, base._SectionPwd, fRechargeDeduct);
if (rvInfo.boolValue && !rvInfo.isError)
{
//卡物理充值成功，继续进行充值记录上传操作
RechargeRecord_rcr_Info rechargeRecord = new RechargeRecord_rcr_Info();
#region 实体赋值
rechargeRecord.rcr_cRecordID = Guid.NewGuid();
rechargeRecord.rcr_cCardID = cardInfo.CardSourceID;
rechargeRecord.rcr_cRechargeType = DefineConstantValue.ConsumeMoneyFlowType.Recharge_PersonalRealTime.ToString();
rechargeRecord.rcr_cStatus = DefineConstantValue.ConsumeMoneyFlowStatus.Finished.ToString();
rechargeRecord.rcr_cUserID = this._CurrentCardUserInfo.cus_cRecordID;
rechargeRecord.rcr_dRechargeTime = DateTime.Now;//TODO:应该修改为跟服务器时间
rechargeRecord.rcr_fRechargeMoney = fRechargeDeduct;//扣减欠费得到的当次实际充值金额
rechargeRecord.PreCostMoney = fPreCost;//需要缴付的欠款金额
//<--卡实际充值后余额=卡当前余额+实际充值金额
rechargeRecord.rcr_fBalance = base._CurrentCardInfo.CardBalance + fRechargeDeduct;
//--->
rechargeRecord.IsNeedSyncAccount = ckbIsSyncUnPay.Checked;//是否需要同步账户，主要用以分别透支金额这些系统额外金额的记录登记
rechargeRecord.rcr_cAdd = this.UserInformation.usm_cUserLoginID;
rechargeRecord.rcr_cLast = rechargeRecord.rcr_cAdd;
rechargeRecord.rcr_dLastDate = rechargeRecord.rcr_dRechargeTime;
#endregion
//卡充值成功后，将充值信息写入充值记录表
rvInfo = this._IRechargeRecordBL.InsertRechargeRecord(rechargeRecord);
ComputePreCost(this._CurrentPairInfo);
if (rvInfo.boolValue && !rvInfo.isError)
{
//成功录入充值记录后提示成功
this.Cursor = Cursors.Default;
this.ShowInformationMessage("充值成功。");
if (cbxPrint.Checked)
{
RechargeDetail rdInfo = new RechargeDetail();
rdInfo.CardNo = Int32.Parse(this.labCardNo.Text);
rdInfo.OperationTime = System.DateTime.Now;
rdInfo.Operator = this.UserInformation.usm_cUserLoginID;
rdInfo.RechargeValue = fRecharge;
rdInfo.UserName = this.labUserName.Text;
rdInfo.ClassName = this.labClassName.Text;
//打印小票
PrintTicket(rdInfo);
}
resetAllControls();
this.Invoke(new DLG_GetRechargeHistory(BindRechargeList));
DateTime? dtSysNow = DateTime.Now;//使用系统时间作准，避免因客户机时间不同步造成操作异常
if (rvInfo.ValueObject != null)
{
dtSysNow = Convert.ToDateTime(rvInfo.ValueObject);
}
if (dtSysNow == null)
{
dtSysNow = DateTime.Now;
}
ResetMealPlanning(base._CurrentCardUserInfo, dtSysNow);
btnRead.Focus();
return;
}
else
{
ShowErrorMessage("上传充值记录失败，需要进行回滚扣费，请摆放好卡片后，点击确定。");
ConsumeCardInfo cardInfoRollback = this._Reader.ReadCardInfo(base._CardInfoSection, base._SectionPwd);
if (cardInfoRollback.CardSourceID != cardInfo.CardSourceID)
{
ShowWarningMessage("卡片信息不符合，请核对后重新放卡，原卡片卡号为：" + cardInfo.CardNo.ToString() + ",卡信息为：" + cardInfo.Name);
cardInfoRollback = this._Reader.ReadCardInfo(base._CardInfoSection, base._SectionPwd);
if (cardInfoRollback.CardSourceID == cardInfo.CardSourceID)
{
//录入充值记录失败，则需要将原先充入的卡金额扣除，如果卡已被取走，则需等待后台自动同步金额
rvInfo = this._Reader.Recharge(base._CardInfoSection, base._SectionPwd, fRechargeDeduct * -1);
if (rvInfo.boolValue && !rvInfo.isError)
{
ShowInformationMessage("回滚扣费成功，可重新进行充值。");
return;
}
else
{
ShowWarningMessage("回滚扣费失败，请联系系统管理员处理问题卡片。");
}
}
else
{
ShowWarningMessage("核对信息失败，请联系系统管理员处理问题卡片。");
}
}
else
{
rvInfo = this._Reader.Recharge(base._CardInfoSection, base._SectionPwd, fRechargeDeduct * -1);
if (rvInfo.boolValue && !rvInfo.isError)
{
ShowInformationMessage("回滚扣费成功，可重新进行充值。");
return;
}
else
{
ShowWarningMessage("回滚扣费失败，请联系系统管理员处理问题卡片。");
}
}
resetAllControls();
this.Cursor = Cursors.Default;
this.ShowInformationMessage("充值失败。" + rvInfo.messageText);
btnRead.Focus();
return;
}
}
else
{
resetAllControls();
this.Cursor = Cursors.Default;
this.ShowInformationMessage("充值失败。" + rvInfo.messageText);
btnRead.Focus();
return;
}
}
}
private void btnConfirmRefund_Click(object sender, EventArgs e)
{
bool resUkey = base.CheckUKey();
if (!resUkey)
{
return;
}
if (base._CurrentCardInfo == null)
{
this.ShowWarningMessage("请重新读卡。");
btnRead.Focus();
return;
}
if (string.IsNullOrEmpty(tbxRefundMoney.Text.Trim()))
{
this.ShowWarningMessage("请输入退款金额。");
tbxRefundMoney.Focus();
tbxRefundMoney.SelectAll();
return;
}
decimal fRefund;
#region 处理退款金额
bool res = decimal.TryParse(tbxRefundMoney.Text.Trim(), out fRefund);
if (!res)
{
this.ShowWarningMessage("请检查退款金额的格式。");
tbxRefundMoney.Focus();
tbxRefundMoney.SelectAll();
return;
}
if (fRefund <= 0)
{
this.ShowWarningMessage("退款金额需大于0，请重新输入。");
tbxRefundMoney.Focus();
tbxRefundMoney.SelectAll();
return;
}
else if (fRefund > Common.DefineConstantValue.MaxRechargeVal)
{
this.ShowWarningMessage("充值金额不能大于" + Common.DefineConstantValue.MaxRechargeVal.ToString() + "，请重新输入。");
tbxRefundMoney.Focus();
tbxRefundMoney.SelectAll();
return;
}
#endregion
if (string.IsNullOrEmpty(tbxDesc.Text))
{
ShowWarningMessage("请先输入退款原因。");
tbxDesc.Focus();
tbxDesc.SelectAll();
return;
}
decimal fPreCost = decimal.Zero;
if (ckbPreCost.Checked)
{
fPreCost = decimal.Parse(labPreCost.Text);
}
dlgConfirmInfo dlg = new dlgConfirmInfo();
dlg.CardInfo = base._CurrentCardInfo;
dlg.IsPrinted = cbxPrint.Checked;
dlg.RefundMoney = fRefund;
dlg.UserInfo = base._CurrentCardUserInfo;
dlg.PreCostMoney = fPreCost;
dlg.IsPrinted = cbxPrint.Checked;
if (dlg.ShowDialog() == DialogResult.OK)
{
//卡信息再次验证
ConsumeCardInfo chkCardInfo = this._Reader.ReadCardInfo(base._CardInfoSection, base._SectionPwd);
if (chkCardInfo == null || (chkCardInfo != null && chkCardInfo.CardSourceID != base._CurrentCardInfo.CardSourceID))
{
this.ShowWarningMessage("卡片信息已变更，请重新读卡后操作。");
resetAllControls();
return;
}
this.Cursor = Cursors.WaitCursor;
try
{
fRefund = fRefund - Math.Abs(fPreCost);//实际退款金额 = 用户键入的退款额 - 需交付的欠款额
//先进行物理卡充值
ReturnValueInfo rvInfo = this._Reader.Recharge(base._CardInfoSection, base._SectionPwd, fRefund);
if (rvInfo.boolValue && !rvInfo.isError)
{
RechargeRecord_rcr_Info rechargeRecord = new RechargeRecord_rcr_Info();
#region 填充实体
rechargeRecord.rcr_cRecordID = Guid.NewGuid();
rechargeRecord.rcr_cUserID = this._CurrentCardUserInfo.cus_cRecordID;
rechargeRecord.rcr_cCardID = chkCardInfo.CardSourceID;
rechargeRecord.rcr_cRechargeType = DefineConstantValue.ConsumeMoneyFlowType.Refund_CardPersonalRealTime.ToString();
rechargeRecord.rcr_cStatus = DefineConstantValue.ConsumeMoneyFlowStatus.Finished.ToString();
rechargeRecord.rcr_dRechargeTime = DateTime.Now;
rechargeRecord.rcr_fRechargeMoney = fRefund;
rechargeRecord.rcr_fBalance = base._CurrentCardInfo.CardBalance + fRefund;//退款后卡余额 = 当前卡余额 + 退款金额
rechargeRecord.PreCostMoney = fPreCost;//未结算的欠款
rechargeRecord.rcr_cDesc = tbxDesc.Text;
rechargeRecord.rcr_cAdd = this.UserInformation.usm_cUserLoginID;
rechargeRecord.rcr_cLast = rechargeRecord.rcr_cAdd;
rechargeRecord.rcr_dLastDate = rechargeRecord.rcr_dRechargeTime;
rechargeRecord.IsNeedSyncAccount = ckbPreCost.Checked;
#endregion
//卡退款成功后，将退款信息写入充值记录表
rvInfo = this._IRechargeRecordBL.InsertRechargeRecord(rechargeRecord);
if (rvInfo.boolValue && !rvInfo.isError)
{
//成功录入退款记录后提示成功
this.Cursor = Cursors.Default;
this.ShowInformationMessage("退款成功。" + Environment.NewLine + "退款用户：" + this._CurrentCardUserInfo.cus_cChaName + "，退款金额：" + fRefund.ToString() + "元");
if (cbxPrint.Checked)
{
RechargeDetail rdInfo = new RechargeDetail();
//rdInfo.CardNo = Int32.Parse(this.labCardNo.Text);
rdInfo.OperationTime = System.DateTime.Now;
rdInfo.Operator = this.UserInformation.usm_cUserLoginID;
rdInfo.RechargeValue = fRefund;
rdInfo.UserName = this.labUserName.Text;
rdInfo.ClassName = this.labClassName.Text;
//打印小票
PrintTicket(rdInfo);
}
resetAllControls();
btnRead.Focus();
return;
}
else
{
ShowErrorMessage("上传充值记录失败，需要进行回滚扣费，请摆放好卡片后，点击确定。");
ConsumeCardInfo cardInfoRollback = this._Reader.ReadCardInfo(base._CardInfoSection, base._SectionPwd);
if (cardInfoRollback.CardSourceID != chkCardInfo.CardSourceID)
{
ShowWarningMessage("卡片信息不符合，请核对后重新放卡，原卡片卡号为：" + chkCardInfo.CardNo.ToString() + ",卡信息为：" + chkCardInfo.Name);
cardInfoRollback = this._Reader.ReadCardInfo(base._CardInfoSection, base._SectionPwd);
if (cardInfoRollback.CardSourceID == chkCardInfo.CardSourceID)
{
//录入退款记录失败，则需要将原先充入的卡金额扣除，如果卡已被取走，则需等待后台自动同步金额
rvInfo = this._Reader.Recharge(base._CardInfoSection, base._SectionPwd, fRefund * -1);
if (rvInfo.boolValue && !rvInfo.isError)
{
ShowInformationMessage("回滚扣费成功，可重新进行充值。");
return;
}
else
{
ShowWarningMessage("回滚扣费失败，请联系系统管理员处理问题卡片。");
}
}
else
{
ShowWarningMessage("核对信息失败，请联系系统管理员处理问题卡片。");
}
}
else
{
rvInfo = this._Reader.Recharge(base._CardInfoSection, base._SectionPwd, fRefund * -1);
if (rvInfo.boolValue && !rvInfo.isError)
{
ShowInformationMessage("回滚扣费成功，可重新进行充值。");
return;
}
else
{
ShowWarningMessage("回滚扣费失败，请联系系统管理员处理问题卡片。");
}
}
resetAllControls();
this.Cursor = Cursors.Default;
this.ShowInformationMessage("实时卡退款失败。" + rvInfo.messageText);
btnRead.Focus();
return;
}
}
else
{
resetAllControls();
this.Cursor = Cursors.Default;
this.ShowInformationMessage("实时卡退款失败。" + rvInfo.messageText);
btnRead.Focus();
return;
}
}
catch (Exception ex)
{
this.Cursor = Cursors.Default;
this.ShowErrorMessage("退款失败。" + Environment.NewLine + ex);
btnRead.Focus();
return;
}
}
}
public ReturnValueInfo ResetAccountOverdraft(RechargeRecord_rcr_Info OverdraftInfo)
{
try
{
return this._ICardUserAccountDA.ResetAccountOverdraft(OverdraftInfo);
}
catch (Exception ex)
{
throw ex;
}
}
