/// <summary>
/// 冻结交易取消
/// </summary>
/// <param name="sourceTradeType">原始订单交易类型</param>
/// <param name="targetTradeType">目标订单交易类型</param>
/// <param name="orderId"></param>
internal void TradeFrozeCancel(OrderTradeType sourceTradeType, OrderTradeType targetTradeType, long orderId, string remark)
{
lock (LocalThreadLock.GetLockKeyName(LockKeyNames.LOCK_WALLET, this._studentId.ToString()))
{
TblCashWalletForzenDetail detail = this.ProcessFrozeBalanceComplete(sourceTradeType, orderId, BalanceFrozeStatus.Cancel);
decimal transAmount = detail.Amount * (-1);
//2、增加交易记录
TblCashWallet tblCashWallet = this.TblCashWallet;
decimal transBefBalance = tblCashWallet.Balance + transAmount; //交易前余额,同下
decimal transAftBalance = tblCashWallet.Balance; //交易后余额,冻结交易,余额早已扣除，所以该余额即交易后余额
//余额交易明细
TblCashWalletTrade walletTrade = new TblCashWalletTrade()
{
WalletTradeId = IdGenerator.NextId(),
OrderId = orderId,
StudentId = this._studentId,
SchoolId = this._schoolId,
TradeType = (int)targetTradeType,
TransBefBalance = transBefBalance,
TransAftBalance = transAftBalance,
TransAmount = transAmount,
TransDate = DateTime.Now,
Remark = remark
};
//写入数据
_walletTradeRepository.Value.Add(walletTrade);
}
}
/// <summary>
/// 取消学生的某个课次
/// <para>作 者：郭伟佳</para>
/// <para>创建时间：2018-11-28</para>
/// </summary>
/// <param name="lessonIdList">课程Id列表</param>
/// <exception cref="AMS.Core.BussinessException">
/// 异常ID：
/// 13. 系统不存在该写生课信息
/// 14. 该学期已结束，不可取消
/// 34. 写生课已取消
/// </exception>
public void Cancel(List <long> lessonIdList)
{
lock (LocalThreadLock.GetLockKeyName(LockKeyNames.LOCK_LIFE_CLASS, _lifeClassId.ToString()))
{
//1、校验
var lifeClassInfo = _repository.Value.GetLifeClassInfo(_lifeClassId);
CheckDataBeforeCancel(lifeClassInfo, lessonIdList);
using (UnitOfWork unitOfWork = new UnitOfWork())
{
try
{
unitOfWork.BeginTransaction(IsolationLevel.Snapshot);
//2、取消学生的写生排课
CancelLifeClass(unitOfWork, lifeClassInfo, lessonIdList);
unitOfWork.CommitTransaction();
}
catch (Exception ex)
{
unitOfWork.RollbackTransaction();
throw ex;
}
}
}
}
/// <summary>
/// 补课调整
/// <para>作 者：zhiwei.Tang</para>
/// <para>创建时间：2019-03-14</para>
/// </summary>
/// <param name="iRequest">补课调整参数</param>
public override void Adjust(IAdjustLessonRequest iRequest)
{
//1、涉及到学生课次开启线程锁
//2、构建需要补课的课次信息
//3、调用课次调整服务进行学生补课
AdjustReplenishRequest request = iRequest as AdjustReplenishRequest;
lock (LocalThreadLock.GetLockKeyName(LockKeyNames.LOCK_AMSSCHOOLSTUDENT, _schoolId, request.StudentId.ToString()))
{
using (UnitOfWork unitOfWork = new UnitOfWork())
{
try
{
unitOfWork.BeginTransaction();
//构建需要补课的课次信息
AdjustLessonReplenishCreator adjustLessonReplenishCreator =
new AdjustLessonReplenishCreator(_schoolId, request, unitOfWork);
//调用课次调整服务进行学生补课
ReplenishLessonService service = new ReplenishLessonService(unitOfWork);
service.Create(adjustLessonReplenishCreator);
unitOfWork.CommitTransaction();
}
catch (Exception e)
{
unitOfWork.RollbackTransaction();
throw e;
}
}
}
}
/// <summary>
/// 学生写生排课
/// <para>作 者：郭伟佳</para>
/// <para>创建时间：2019-01-05</para>
/// </summary>
/// <param name="request">学期班级学生请求参数</param>
/// <param name="lifeClassInfo">写生课信息</param>
/// <param name="lessonClassList">报班明细信息</param>
/// <returns>写生排课结果</returns>
private LifeClassResultResponse MakeLessonForStudent(List <TimeLessonClassRequest> request, TblTimLifeClass lifeClassInfo, List <ViewTimeLessonClass> lessonClassList)
{
LifeClassResultResponse resultResponse = new LifeClassResultResponse();
foreach (var studentId in lessonClassList.Select(a => a.StudentId).Distinct())
{
lock (LocalThreadLock.GetLockKeyName(LockKeyNames.LOCK_AMSSCHOOLSTUDENT, _schoolId, studentId.ToString()))
{
//1.获取学生对应的课次信息
var studentLessonList = lessonClassList.Where(a => a.StudentId == studentId);
//2.获取报名订单课程明细信息
var studentEnrollItemList = EnrollOrderService.GetEnrollOrderItemByItemId(studentLessonList.Select(a => a.EnrollOrderItemId).Distinct());
//3.获取需要生成的写生课明细、一个学生多个班级列表和课次不够的学生列表
var result = GetLifeClassLesson(request, lifeClassInfo, studentLessonList, studentEnrollItemList);
resultResponse.LackTimeList.AddRange(result.Item1); //获取课次不够的学生列表
List <LifeClassLessonMakeRequest> lifeClassLessonList = result.Item2; //获取写生课明细
resultResponse.StudentClassList.AddRange(result.Item3); //获取一个学生多个班级列表
//4.进行写生排课
MakeLifeClass(lifeClassInfo, lifeClassLessonList);
}
}
return(resultResponse);
}
/// <summary>
/// 作废定金
/// <para>作 者::Huang GaoLiang </para>
/// <para>创建时间:2018-10-30 </para>
/// </summary>
/// <param name="orderId">订金编号</param>
/// <param name="cancelUserId">作废人操作编号</param>
/// <param name="cancelUserName">作废人名称</param>
/// <param name="cancelRemark">作废原因</param>
/// <exception cref="BussinessException">
/// 异常ID：5,数据异常
/// 异常ID：8,余额不足，不能作废
/// </exception>
public override Task Cancel(long orderId, string cancelUserId, string cancelUserName, string cancelRemark)
{
lock (LocalThreadLock.GetLockKeyName(LockKeyNames.LOCK_DEPOSITORDERCANCEL, this._schoolId, orderId.ToString()))
{
// 根据订金编号查询订金信息
TblOdrDepositOrder odrDepositOrder = _odrDepositOrderRepository.Value.GetOdrDepositOrder(orderId);
if (odrDepositOrder == null)
{
throw new BussinessException((byte)ModelType.Cash, 5);
}
// 1、数据校验
OdrDepositOrderCancelVerification(odrDepositOrder);
// 2、准备数据
odrDepositOrder.OrderStatus = (int)OrderStatus.Cancel;
odrDepositOrder.CancelDate = DateTime.Now;
odrDepositOrder.CancelUserId = cancelUserId;
odrDepositOrder.CancelUserName = cancelUserName;
odrDepositOrder.CancelRemark = cancelRemark;
// 3、作废之后，余额扣除掉相应的金额
bool isWalletSufficient = WalletService.IsWalletSufficient(_schoolId, odrDepositOrder.StudentId, odrDepositOrder.Amount);
if (!isWalletSufficient)
{
throw new BussinessException((byte)ModelType.Cash, 8);
}
DepositOrderTrade orderTrade = new DepositOrderTrade(odrDepositOrder);
using (UnitOfWork unitOfWork = new UnitOfWork())
{
try
{
unitOfWork.BeginTransaction();
// 1、资金交易
TradeService tradeService = new TradeService(orderTrade, unitOfWork);
tradeService.Invalid();
// 2、订金
unitOfWork.GetCustomRepository <TblOdrDepositOrderRepository, TblOdrDepositOrder>().UpdateTask(odrDepositOrder).Wait();
// 3、收款交接
new OrderHandoverService(_schoolId).DeleteHandleOver(orderId, OrderTradeType.DepositOrder, unitOfWork);
unitOfWork.CommitTransaction();
}
catch (Exception ex)
{
unitOfWork.RollbackTransaction();
throw ex;
}
}
}
return(Task.CompletedTask);
}
/// <summary>
/// 冻结交易成功
/// </summary>
/// <param name="transType"></param>
/// <param name="orderId"></param>
internal void TradeFrozeComplete(OrderTradeType transType, long orderId)
{
lock (LocalThreadLock.GetLockKeyName(LockKeyNames.LOCK_WALLET, this._studentId.ToString()))
{
//1、处理冻结余额数据
TblCashWalletForzenDetail detail = ProcessFrozeBalanceComplete(transType, orderId, BalanceFrozeStatus.Finish);
}
}
/// <summary>
/// 调整课次创建
/// <para>作 者：zhiwei.Tang</para>
/// <para>创建时间：2019-03-13</para>
/// </summary>
/// <param name="creator">调整课次的产生者接口</param>
public void Create(IReplenishLessonCreator creator)
{
List <ReplenishLessonCreatorInfo> lessonCreatorInfoList = creator.GetReplenishLessonCreatorInfo();
if (lessonCreatorInfoList == null || !lessonCreatorInfoList.Any())
{
//创建的课次为空
throw new BussinessException(ModelType.Timetable, 35);
}
var lessonCreatorInfo = lessonCreatorInfoList.FirstOrDefault();
List <long> outLessonIdList = lessonCreatorInfoList.Select(x => x.OutLessonId).ToList();
var outReplenishLessonList = _replenishLessonRepository.Value.GetLessonListByLessonId(outLessonIdList);
List <TblTimLesson> lessonList = new List <TblTimLesson>(); //课次
List <TblTimLessonProcess> lessonProceseList = new List <TblTimLessonProcess>(); //课次过程
List <TblTimReplenishLesson> replenishLessonList = new List <TblTimReplenishLesson>(); //课次调整
foreach (var m in lessonCreatorInfoList)
{
//课次
var lessonModel = this.GetTblTimLesson(m);
lessonList.Add(lessonModel);
//课次过程
var lessonProcessModel = this.GetTblTimLessonProcess(lessonModel);
lessonProceseList.Add(lessonProcessModel);
//补课
var replenishLessonModel = this.GetTblTimReplenishLesson(outReplenishLessonList, m, lessonModel);
replenishLessonList.Add(replenishLessonModel);
}
lock (LocalThreadLock.GetLockKeyName(
LockKeyNames.LOCK_AMSSCHOOLSTUDENT, lessonCreatorInfo.SchoolId,
lessonCreatorInfo.StudentId.ToString()))
{
//常规课校验排课时间是否冲突
base.VerifyClassTimeCross(lessonCreatorInfo.SchoolId,
lessonCreatorInfo.StudentId, this.GetVerifyClassTimeList(lessonCreatorInfoList),
lessonCreatorInfo.LessonType);
_replenishLessonRepository.Value.Add(replenishLessonList);
_lessonProcessRepository.Value.Add(lessonProceseList);
_lessonRepository.Value.Add(lessonList);
this.UpdateAdjustType(lessonCreatorInfoList, outReplenishLessonList);
}
creator.AfterReplenishLessonCreate();
}
/// <summary>
/// 描述：休学办理
/// <para>作 者：瞿琦</para>
/// <para>创建时间：2018-11-7</para>
/// </summary>
/// <param name="iRequest">休学的相关数据</param>
/// <param name="companyId">公司编号</param>
/// <exception cref="AMS.Core.BussinessException">
/// 异常ID：8,异常描述：没有要休学的课程
/// </exception>
public override void Transact(IRefundOrderTransactRequest iRequest, string companyId) //
{
lock (LocalThreadLock.GetLockKeyName(LockKeyNames.LOCK_AMSSCHOOLSTUDENT, base._schoolId, base._studentId.ToString()))
{
var request = iRequest as LeaveSchoolOrderAddRequest;
//获取学生课次费用明细
var courseLessonList = base.GetCourseLessonList(request.LeaveTime, companyId);
if (!courseLessonList.Any()) //如果订单课程已休学则获取不到学生课次费用明细，则抛出异常
{
throw new BussinessException(ModelType.Order, 8);
}
using (var unitOfWork = new UnitOfWork())
{
try
{
unitOfWork.BeginTransaction();
//1.写入退费订单主表 --休学订单表
var refundOrder = AddOdrRefundOrder(request, courseLessonList, unitOfWork);
//2.写入退费订单课程明细
AddOdrRefundOrdeEnroll(courseLessonList, refundOrder, unitOfWork);
//3.写入休学表详细信息表
var leaveSchoolOrder = AddOdrLeaveSchoolOrder(request, courseLessonList, refundOrder, unitOfWork);
//4.添加附件
AddAttachment(request, leaveSchoolOrder, unitOfWork);
//5、课次调用
LeaveSchoolLessonFinisher leaveSchoolFinisher = new LeaveSchoolLessonFinisher(refundOrder, leaveSchoolOrder, unitOfWork);
LessonService lessonService = new LessonService(unitOfWork);
lessonService.Finish(leaveSchoolFinisher);//课次销毁
//6、资金调用
LeaveSchoolOrderTrade orderTrade = new LeaveSchoolOrderTrade(refundOrder);
TradeService trade = new TradeService(orderTrade, unitOfWork);
trade.Trade();
//7、修改课程明细表为休学状态
EnrollOrderService service = new EnrollOrderService(this._schoolId);
var enrollOrderItemIdList = courseLessonList.Select(x => x.EnrollOrderItemId).ToList();
service.ChangeToLeaveSchool(enrollOrderItemIdList, unitOfWork).Wait();
//8.修改学生状态
var studentService = new StudentService(this._schoolId);
studentService.UpdateStudentStatusById(this._studentId, unitOfWork, StudyStatus.Suspension);
unitOfWork.CommitTransaction();
}
catch (Exception ex)
{
unitOfWork.RollbackTransaction();
throw ex;
}
}
}
}
/// <summary>
/// 钱包交易金额冻结
/// </summary>
/// <param name="transType"></param>
/// <param name="transAmount"></param>
/// <param name="unitOfWork">事务工作单元</param>
internal void TradeFroze(OrderTradeType transType, long orderId, decimal transAmount, string remark)
{
if (transAmount == 0)
{
return;
}
//TODO 以后应用分布式锁
lock (LocalThreadLock.GetLockKeyName(LockKeyNames.LOCK_WALLET, this._studentId.ToString()))
{
//1、钱包余额冻结金额
TblCashWallet tblCashWallet = this.TblCashWallet;
decimal transBefBalance = tblCashWallet.Balance; //交易前余额
decimal transAftBalance = tblCashWallet.Balance + transAmount; //交易后余额
tblCashWallet.Balance = transAftBalance;
tblCashWallet.FrozenAmount = transAmount;
tblCashWallet.UpdateTime = DateTime.Now;
//2、冻结明细记录
TblCashWalletForzenDetail detail = new TblCashWalletForzenDetail()
{
BusinessId = orderId,
BusinessType = (int)transType,
SchoolId = this._schoolId,
Status = 1,
Amount = transAmount,
StudentId = this._studentId,
WalletForzenDetailId = IdGenerator.NextId(),
CreateTime = DateTime.Now
};
//3、余额交易明细
TblCashWalletTrade walletTrade = new TblCashWalletTrade()
{
WalletTradeId = IdGenerator.NextId(),
OrderId = orderId,
StudentId = this._studentId,
SchoolId = this._schoolId,
TradeType = (int)transType,
TransBefBalance = transBefBalance,
TransAftBalance = transAftBalance,
TransAmount = transAmount,
TransDate = DateTime.Now,
Remark = remark
};
//4、写入数据
_walletTradeRepository.Value.Add(walletTrade);
_repository.Value.Update(tblCashWallet); //更新用户钱包余额
_forzenRepository.Value.Add(detail); //写入冻结明细
}
}
/*
* 打印序号规则：校区简称+年+5位数字，例如“深圳东海201800001”
* 每打印一次，就计数一次，连续，不能断号。
* 分文件计数，目前系统中的打印文件有报班报名表、、报班收据、定金收据、游学营报名表、游学营收据、零售票据。
* 计数规则如下：校区、年度、单据类型 从00001开始。
* 校区名称+年度+序号，例如：东海校区+2018+00001
*/
/// <summary>
/// 打印并计数
/// <para>作 者：zhiwei.Tang</para>
/// <para>创建时间：2019-02-20</para>
/// </summary>
/// <param name="schoolId">校区Id</param>
/// <param name="printBillType">打印类型</param>
/// <returns>打印序号</returns>
/// <exception cref="ArgumentNullException">
/// 校区Id为空;校区未找到；
/// </exception>
internal static string Print(string schoolId, PrintBillType printBillType)
{
if (string.IsNullOrWhiteSpace(schoolId))
{
throw new ArgumentNullException(nameof(schoolId));
}
OrgService orgService = new OrgService();
var allSchoolInfos = orgService.GetAllSchoolList();
var schoolInfo = allSchoolInfos.FirstOrDefault(m => m.SchoolId == schoolId);
if (schoolInfo == null)
{
throw new ArgumentNullException(nameof(schoolInfo));
}
int year = DateTime.Now.Year;
byte type = (byte)printBillType;
lock (LocalThreadLock.GetLockKeyName(LockKeyNames.LOCK_PRINT, schoolId, type.ToString()))
{
TblDatPrintCounterRepository printCounterRepository = new TblDatPrintCounterRepository();
TblDatPrintCounter counter = printCounterRepository.Get(schoolId, year, type);
if (counter == null)
{
counter = new TblDatPrintCounter
{
PrintCounterId = IdGenerator.NextId(),
PrintBillType = type,
SchoolId = schoolId,
Counts = 1,
Year = year,
CreateTime = DateTime.Now
};
printCounterRepository.Add(counter);
}
else
{
counter.Counts++;
printCounterRepository.Update(counter);
}
return($"{schoolInfo.SchoolName}{year}{counter.Counts.ToString().PadLeft(5, '0')}");
}
}
/// <summary>
/// 写生排课
/// <para>作 者：郭伟佳</para>
/// <para>创建时间：2018-11-12</para>
/// </summary>
/// <param name="request">学期班级学生请求列表</param>
/// <returns>写生排课结果</returns>
/// <exception cref="AMS.Core.BussinessException">
/// 异常ID：
/// 13. 系统不存在该写生课信息
/// 28. 系统不存在该报名订单课程明细信息
/// 29. 请选择学生进行写生排课
/// </exception>
internal LifeClassResultResponse Make(List <TimeLessonClassRequest> request)
{
lock (LocalThreadLock.GetLockKeyName(LockKeyNames.LOCK_LIFE_CLASS, _lifeClassId.ToString()))
{
//1.获取写生课信息
TblTimLifeClass lifeClassInfo = _repository.Value.GetLifeClassInfo(_lifeClassId);
//2.获取课次基础信息表
var lessonClassList = _vTimeLessonClassRepository.Value.GetTimeLessonClassList(_schoolId, request).Result;
//4.数据校验
CheckDataBeforeMake(request, lifeClassInfo, lessonClassList);
//5.写生排课
LifeClassResultResponse resultResponse = MakeLessonForStudent(request, lifeClassInfo, lessonClassList);
return(resultResponse);
}
}
/// <summary>
/// 写生排课(选择学生班级)
/// <para>作 者：郭伟佳</para>
/// <para>创建时间：2019-01-03</para>
/// </summary>
/// <param name="lifeClassSelectList">学生班级课程对象</param>
/// <returns>学生课次不够的信息列表</returns>
internal List <LifeClassLackTimesListResponse> SelectClassToMake(List <LifeClassSelectClassRequest> lifeClassSelectList)
{
lock (LocalThreadLock.GetLockKeyName(LockKeyNames.LOCK_LIFE_CLASS, _lifeClassId.ToString()))
{
List <LifeClassLackTimesListResponse> result = new List <LifeClassLackTimesListResponse>();
//1.获取写生课信息
TblTimLifeClass lifeClassInfo = _repository.Value.GetLifeClassInfo(_lifeClassId);
foreach (var studentId in lifeClassSelectList.Select(a => a.StudentId).Distinct())
{
lock (LocalThreadLock.GetLockKeyName(LockKeyNames.LOCK_AMSSCHOOLSTUDENT, _schoolId, studentId.ToString()))
{
//2.获取学生对应的班级课程信息
var studentLifeList = lifeClassSelectList.Where(a => a.StudentId == studentId);
//3.获取报名订单课程明细信息
var enrollOrderItemInfoList = EnrollOrderService.GetEnrollOrderItemByItemId(studentLifeList.Select(a => a.EnrollOrderItemId).Distinct());
//4.获取课次不够扣的报名订单课程明细信息
var enrollNotEnoughTimeList = enrollOrderItemInfoList.Where(a => a.Status == (int)OrderItemStatus.Enroll && a.ClassTimes - a.ClassTimesUse < lifeClassInfo.UseLessonCount);
//5.获取课次不够的学生列表
result.AddRange(GetNoEnoughTimeList(lifeClassInfo, studentLifeList, enrollNotEnoughTimeList));
//6.过滤课次不够的写生排课
var lifeClassList = studentLifeList.Where(a => !enrollNotEnoughTimeList.Any(b => b.EnrollOrderItemId == a.EnrollOrderItemId))
.Select(a => new LifeClassLessonMakeRequest()
{
StudentId = a.StudentId,
ClassId = a.ClassId,
EnrollOrderItemId = a.EnrollOrderItemId
}).ToList();
//7.写生排课
MakeLifeClass(lifeClassInfo, lifeClassList);
}
}
return(result);
}
}
/// <summary>
/// 取消写生排课
/// <para>作 者：郭伟佳</para>
/// <para>创建时间：2018-11-28</para>
/// </summary>
/// <exception cref="AMS.Core.BussinessException">
/// 异常ID：
/// 13. 系统不存在该写生课信息
/// 14. 该学期已结束，不可取消
/// 34. 写生课已取消
/// </exception>
public void Cancel()
{
lock (LocalThreadLock.GetLockKeyName(LockKeyNames.LOCK_LIFE_CLASS, _lifeClassId.ToString()))
{
var lifeClassInfo = _repository.Value.GetLifeClassInfo(_lifeClassId);
//1、根据写生课Id，获取写生课对应的课次基础信息的课程Id列表
var studentLessonInfoList = _timLessonRepository.Value.GetStudentLessonListAsync(_schoolId, new List <long> {
_lifeClassId
});
var lessonIdList = studentLessonInfoList.Where(a => a.Status == (int)LessonUltimateStatus.Normal).Select(a => a.LessonId).ToList();
//2、校验
CheckDataBeforeCancel(lifeClassInfo, lessonIdList);
using (UnitOfWork unitOfWork = new UnitOfWork())
{
try
{
unitOfWork.BeginTransaction(IsolationLevel.Snapshot);
//3、取消写生课Id对应的所有学生的课次
CancelLifeClass(unitOfWork, lifeClassInfo, lessonIdList);
//4、删除对应的写生课
TblTimLifeClassRepository lifeClassRepository = unitOfWork.GetCustomRepository <TblTimLifeClassRepository, TblTimLifeClass>();
lifeClassRepository.DeleteLifeClassById(_lifeClassId);
unitOfWork.CommitTransaction();
}
catch (Exception ex)
{
unitOfWork.RollbackTransaction();
throw ex;
}
}
}
}
/// <summary>
/// 添加订金
/// <para>作 者：Huang GaoLiang </para>
/// <para>创建时间:2018-10-30 </para>
/// </summary>
/// <param name="request">订金充值实体</param>
/// <param name="payeeId">收银人编号</param>
/// <param name="payeeName">收银人</param>
/// <returns>返回订金编号</returns>
public string Add(DepositOrderAddRequest request, string payeeId, string payeeName)
{
lock (LocalThreadLock.GetLockKeyName(LockKeyNames.LOCK_DEPOSITORDERADD, this._schoolId, request.StudentId.ToString()))
{
// 1、数据合法性校验
Verification(request);
long depositOrderId = IdGenerator.NextId();
// 2、准备数据
TblOdrDepositOrder odrDepositOrder = this.SetOdrDepositOrder(request, payeeId, payeeName, depositOrderId);
// 3、资金调用
DepositOrderTrade orderTrade = new DepositOrderTrade(odrDepositOrder);
// 4、添加事务
using (UnitOfWork unitOfWork = new UnitOfWork())
{
try
{
unitOfWork.BeginTransaction();
TradeService tradeService = new TradeService(orderTrade, unitOfWork);
tradeService.Trade();
unitOfWork.GetCustomRepository <TblOdrDepositOrderRepository, TblOdrDepositOrder>().AddTask(odrDepositOrder).Wait();
unitOfWork.CommitTransaction();
return(depositOrderId.ToString());
}
catch (Exception ex)
{
unitOfWork.RollbackTransaction();
throw ex;
}
}
}
}
/// <summary>
/// 余额交易
/// 余额交易分两种
/// </summary>
/// <param name="transType">交易类型</param>
/// <param name="transAmount">交易的金额</param>
public void Trade(OrderTradeType transType, long orderId, decimal transAmount, string remark)
{
if (transAmount == 0)
{
return;
}
//TODO 以后应用分布式锁
lock (LocalThreadLock.GetLockKeyName(LockKeyNames.LOCK_WALLET, this._studentId.ToString()))
{
//钱包汇总
TblCashWallet tblCashWallet = this.TblCashWallet;
decimal transBefBalance = tblCashWallet.Balance; //交易前余额
decimal transAftBalance = tblCashWallet.Balance + transAmount; //交易后余额
tblCashWallet.Balance = transAftBalance;
tblCashWallet.UpdateTime = DateTime.Now;
//余额交易明细
TblCashWalletTrade walletTrade = new TblCashWalletTrade()
{
WalletTradeId = IdGenerator.NextId(),
OrderId = orderId,
StudentId = this._studentId,
SchoolId = this._schoolId,
TradeType = (int)transType,
TransBefBalance = transBefBalance,
TransAftBalance = transAftBalance,
TransAmount = transAmount,
TransDate = DateTime.Now,
Remark = remark
};
//写入数据
_walletTradeRepository.Value.Add(walletTrade);
_repository.Value.Update(tblCashWallet);
}
}
/// <summary>
/// 描述：保存转班办理
/// <para>作 者：瞿琦</para>
/// <para>创建时间：2018-11-7</para>
/// </summary>
/// <param name="dto">要保存的转班信息</param>
/// <returns>无</returns>
public void ChangeIn(ChangeClassAddRequest dto)
{
lock (LocalThreadLock.GetLockKeyName(LockKeyNames.LOCK_AMSSCHOOLSTUDENT, this._schoolId, this._studentId.ToString()))
{
//验证
var outClassTimes = this.ValidateSubmit(dto); //实际转出课次
using (var unitOfWork = new UnitOfWork())
{
try
{
unitOfWork.BeginTransaction();
//1、插入转班表
var timChangeClassEntity = AddTimChangeClass(dto, outClassTimes, unitOfWork);
//2、课表数据操作---作废
ChangeClassLessonFinisher lessonFinisher = new ChangeClassLessonFinisher(timChangeClassEntity, unitOfWork);
LessonService lessonService = new LessonService(unitOfWork);
lessonService.Finish(lessonFinisher);//课次销毁
//3、课表数据操作---转班重新排课
ChangeClassLessonCreator creator = new ChangeClassLessonCreator(timChangeClassEntity, lessonFinisher.EnrollOrderItemId, unitOfWork);
lessonService.Create(creator);
//4.修改学生状态及课次
var studentService = new StudentService(this._schoolId);
studentService.UpdateStudentStatusById(this._studentId, unitOfWork);
unitOfWork.CommitTransaction();
}
catch (Exception e)
{
unitOfWork.RollbackTransaction();
throw;
}
}
}
}
/// <summary>
/// 删除已安排的补课周课次
/// <para>作 者：Huang GaoLiang </para>
/// <para>创建时间：2019-03-12 </para>
/// </summary>
/// <param name="adjustLessonIds">安排补课班级记录编号</param>
/// <exception>
/// 异常ID：1,未找到数据
/// </exception>
public void RemoveClassTime(List <long> adjustLessonIds)
{
var adjustLesson = _timAdjustLessonRepository.Value.GetTimAdjustLessonList(adjustLessonIds);
if (!adjustLesson.Any())
{
throw new BussinessException((byte)ModelType.Default, 1);
}
lock (LocalThreadLock.GetLockKeyName(LockKeyNames.LOCK_AMSSCHOOLSTUDENT, this._schoolId, adjustLesson.FirstOrDefault().StudentId.ToString()))
{
// 获取班级信息
TimAdjustLessonInDto inDto = new TimAdjustLessonInDto
{
SchoolId = this._schoolId,
ToTeacherId = this._teacherId,
BusinessType = ProcessBusinessType.C_AdjustLessonReplenishWeek
};
long classId = _timAdjustLessonRepository.Value.Load(adjustLesson.FirstOrDefault().AdjustLessonId).ClassId;
TblDatClass datClass = new ReplenishWeekClassService(classId).TblDatClass;
// 操作日志
TblDatOperationLog log = new TblDatOperationLog()
{
OperationLogId = IdGenerator.NextId(),
SchoolId = this._schoolId,
BusinessType = (int)LogBusinessType.ReplenishWeekCancel,
BusinessId = adjustLesson.FirstOrDefault().AdjustLessonId,
FlowStatus = (int)OperationFlowStatus.Cancel,
OperatorId = this._teacherId,
OperatorName = this._teacherName,
Remark = JsonConvert.SerializeObject($"ID是{adjustLesson.FirstOrDefault().StudentId}学生，被删除班级ID是{adjustLesson.FirstOrDefault().ClassId}，上课时间是{adjustLesson.FirstOrDefault().ClassDate.ToString("yyyy-MM-dd")} {adjustLesson.FirstOrDefault().ClassBeginTime}"),
CreateTime = DateTime.Now,
};
// 要判断该课次是否该老师的课次,防止别人乱传ID
if (adjustLesson.FirstOrDefault().ToTeacherId == this._teacherId)
{
adjustLesson.FirstOrDefault().Status = (int)TimAdjustLessonStatus.Invalid;
using (var unitOfWork = new UnitOfWork())
{
try
{
unitOfWork.BeginTransaction();
// 调用课次服务
var adjustLessonWeekRevokeFinisher = new AdjustLessonReplenishWeekFinisher(this._schoolId, adjustLesson.FirstOrDefault().StudentId, adjustLesson, datClass, log, unitOfWork);
LessonService lessonService = new LessonService(unitOfWork);
lessonService.Finish(adjustLessonWeekRevokeFinisher);
unitOfWork.CommitTransaction();
}
catch (Exception ex)
{
unitOfWork.RollbackTransaction();
throw ex;
}
}
}
}
}
/// <summary>
/// 描述：办理
/// <para>作 者：瞿琦</para>
/// <para>创建时间：2018-11-8</para>
/// </summary>
/// <param name="iRequest">要退费的信息</param>
/// <param name="companyId">公司编号</param>
/// <returns>无</returns>
/// <exception cref="AMS.Core.BussinessException">
/// 异常ID：22,异常描述：找不到可退班的订单课程
/// 异常ID：20,异常描述：该订单课程已退班退费
/// </exception>
public override void Transact(IRefundOrderTransactRequest iRequest, string companyId)
{
lock (LocalThreadLock.GetLockKeyName(LockKeyNames.LOCK_AMSSCHOOLSTUDENT, this._schoolId, this._studentId.ToString()))
{
var request = iRequest as LeaveClassOrderAddRequest;
var vailteRequest = EnrollOrderService.GetEnrollOrderItemIdByEnroOrderList(request.RefundCourseLesson);
if (!request.RefundCourseLesson.Any())
{
throw new BussinessException((byte)ModelType.Order, 22);
}
if (vailteRequest.Any(x => x.Status != OrderItemStatus.Enroll)) //如果订单课程不是已报名，则抛出异常
{
throw new BussinessException((byte)ModelType.Order, 20);
}
//获取要退班的课次
var courseLessonList = base.GetCourseLessonList(request.LeaveTime, companyId).Where(x => request.RefundCourseLesson.Contains(x.EnrollOrderItemId)).ToList();
if (!courseLessonList.Any()) //如果要退费的订单课程为空，则抛出异常
{
throw new BussinessException((byte)ModelType.Order, 22);
}
using (var unitOfWork = new UnitOfWork())
{
try
{
unitOfWork.BeginTransaction();
//1.退费订单
var tblOdrRefundOrder = AddOdrRefundOrder(request, courseLessonList, unitOfWork);
//2.退费订单课程明细
AddOdrRefundOrdeEnroll(courseLessonList, tblOdrRefundOrder, unitOfWork);
//3.其他费用
AddOdrRefundOrderCost(request, tblOdrRefundOrder, unitOfWork);
//4.支付信息
AddOdrRefundPay(request, tblOdrRefundOrder, unitOfWork);
//5.退班详细信息
var tblOdrLeaveClassOrder = AddOdrLeaveClassOrder(request, tblOdrRefundOrder, unitOfWork);
//6.添加附件
AddAttachment(request, tblOdrRefundOrder, unitOfWork);
//7、课次调用
LeaveClassLessonFinisher leaveSchoolFinisher = new LeaveClassLessonFinisher(tblOdrRefundOrder, tblOdrLeaveClassOrder, request.RefundCourseLesson, unitOfWork);
LessonService lessonService = new LessonService(unitOfWork);
lessonService.Finish(leaveSchoolFinisher);//课次销毁
//8、资金调用
LeaveClassOrderTrade orderTrade = new LeaveClassOrderTrade(tblOdrRefundOrder, request.RefundType);
TradeService trade = new TradeService(orderTrade, unitOfWork);
trade.Trade();
//9、修改为退班状态
EnrollOrderService service = new EnrollOrderService(this._schoolId);
var enrollOrderItemIdList = courseLessonList.Select(x => x.EnrollOrderItemId).ToList();
service.ChangeToLeaveClass(enrollOrderItemIdList, unitOfWork).Wait();
//10.修改学生状态
var studentService = new StudentService(this._schoolId);
studentService.UpdateStudentStatusById(this._studentId, unitOfWork);
unitOfWork.CommitTransaction();
}
catch (Exception ex)
{
unitOfWork.RollbackTransaction();
throw;
}
}
}
}
/// <summary>
/// 课次生产
/// <para>作 者：zhiwei.Tang</para>
/// <para>创建时间：2018-11-08</para>
/// </summary>
/// <param name="creator">课次的产生者接口</param>
/// <exception cref="BussinessException">
/// 异常ID：35 异常描述：创建的课次为空
/// </exception>
public void Create(ILessonCreator creator)
{
List <LessonCreatorInfo> lessonCreatorInfos = creator.GetLessonCreatorInfo();
if (lessonCreatorInfos == null || !lessonCreatorInfos.Any())
{
//创建的课次为空
throw new BussinessException(ModelType.Timetable, 35);
}
List <TblTimLesson> lessons = new List <TblTimLesson>(); //课次
List <TblTimLessonProcess> lessonProceses = new List <TblTimLessonProcess>(); //课次过程
List <TblTimLessonStudent> lessonStudents = new List <TblTimLessonStudent>(); //学生课次时间表
foreach (var m in lessonCreatorInfos)
{
DateTime classBeginDate; //上课开始时间
DateTime classEndDate; //上课结束时间
if (m.LessonType == LessonType.RegularCourse)
{
classBeginDate = DateTime.Parse($"{m.ClassDate:yyyy-MM-dd} {m.ClassBeginTime}");
classEndDate = DateTime.Parse($"{m.ClassDate:yyyy-MM-dd} {m.ClassEndTime}");
}
else
{
classBeginDate = DateTime.Parse(m.ClassBeginTime);
classEndDate = DateTime.Parse(m.ClassEndTime);
}
//课次
TblTimLesson lesson = new TblTimLesson
{
BusinessId = m.BusinessId,
BusinessType = m.BusinessType,
ClassBeginTime = m.ClassBeginTime,
ClassDate = m.ClassDate,
ClassEndTime = m.ClassEndTime,
ClassId = m.ClassId,
ClassRoomId = m.ClassRoomId,
CourseId = m.CourseId,
CourseLevelId = m.CourseLevelId,
EnrollOrderItemId = m.EnrollOrderItemId,
SchoolId = m.SchoolId,
StudentId = m.StudentId,
TeacherId = m.TeacherId,
TermId = m.TermId,
LessonId = IdGenerator.NextId(),
LessonType = (int)m.LessonType,
LessonCount = m.LessonCount,
Status = (int)LessonUltimateStatus.Normal,
CreateTime = DateTime.Now,
UpdateTime = DateTime.Now,
ClassBeginDate = classBeginDate,
ClassEndDate = classEndDate
};
//课次过程
TblTimLessonProcess lessonProcess = new TblTimLessonProcess
{
SchoolId = lesson.SchoolId,
BusinessId = lesson.BusinessId,
BusinessType = lesson.BusinessType,
LessonId = lesson.LessonId,
LessonProcessId = IdGenerator.NextId(),
ProcessStatus = (int)ProcessStatus.Create,
Remark = string.Empty,
ProcessTime = DateTime.Now,
CreateTime = DateTime.Now
};
//学生课次时间
TblTimLessonStudent lessonStudent = new TblTimLessonStudent
{
LessonId = lesson.LessonId,
LessonStudentId = IdGenerator.NextId(),
StudentId = lesson.StudentId,
SchoolId = lesson.SchoolId,
AttendStatus = (int)AttendStatus.NotClockIn,
CreateTime = DateTime.Now,
AdjustType = (int)AdjustType.DEFAULT,
AttendUserType = (int)AttendUserType.DEFAULT,
ReplenishCode = string.Empty,
};
lessons.Add(lesson);
lessonProceses.Add(lessonProcess);
lessonStudents.Add(lessonStudent);
}
var lessonCreatorInfo = lessonCreatorInfos.FirstOrDefault();
string schoolId = lessonCreatorInfo.SchoolId;
string studentId = lessonCreatorInfo.StudentId.ToString();
lock (LocalThreadLock.GetLockKeyName(LockKeyNames.LOCK_AMSSCHOOLSTUDENT, schoolId, studentId))
{
//校验排课时间是否冲突
base.VerifyClassTimeCross(
schoolId, lessonCreatorInfo.StudentId,
this.GetVerifyClassTimeList(lessonCreatorInfos),
lessonCreatorInfo.LessonType);
_lessonRepository.Value.Add(lessons);
_lessonProcessRepository.Value.Add(lessonProceses);
_lessonStudentRepository.Value.Add(lessonStudents);
}
//排课之后处理的业务
creator.AfterLessonCreate();
}
/// <summary>
/// 添加补课周课次
/// <para>作 者：Huang GaoLiang </para>
/// <para>创建时间：2019-03-12 </para>
/// </summary>
/// <param name="replenishWeekClassTime">安排补课参数信息</param>
public void AddClassTime(ReplenishWeekClassTimeAddRequest replenishWeekClassTime)
{
lock (LocalThreadLock.GetLockKeyName(LockKeyNames.LOCK_AMSSCHOOLSTUDENT, this._schoolId, replenishWeekClassTime.StudentId.ToString()))
{
// 1、根据编辑编号查询原班级信息
TblDatClass oldDatClass = new DefaultClassService(replenishWeekClassTime.ClassId).TblDatClass;
// 2、获取学生缺课的课次信息
List <ViewStudentTimeLess> studentTimeLessList = GetStudentMissClassList(replenishWeekClassTime);
// 3、数据校验
CheckDatClass(oldDatClass, replenishWeekClassTime.WeekClassTimeList.Count, studentTimeLessList.Count);
// 获取补课日期中该老师所有的课次
var classDates = replenishWeekClassTime.WeekClassTimeList.Select(m => m.ClassDate).Distinct().ToList();
var teacherClassList = new ViewTimAttendLessonRepository().GetClassDateTimAttendLessonList(this._schoolId, this._teacherId, classDates);
this.ValidationLesson(replenishWeekClassTime.WeekClassTimeList, teacherClassList);
// 4、获取所有补课周补课中的补课数据
List <TblTimAdjustLesson> timAdjustLessonList = GetTimAdjustLessonList();
// 用户补课周补课班级编号生成
var classNo = string.Empty;
classNo = oldDatClass.ClassNo.Substring(0, oldDatClass.ClassNo.IndexOf('-') + 1);
// 5、根据上课教室编号，查询教室信息
var roomIds = replenishWeekClassTime.WeekClassTimeList.Select(m => m.ClassRoomId).Distinct().ToList();
List <TblDatClassRoom> datClassRooms = ClassRoomService.GetClassRoomListByIds(roomIds);
List <TblTimAdjustLesson> adjustLessonList = new List <TblTimAdjustLesson>(); //业务调整表数据集合
List <TblDatClass> newClassList = new List <TblDatClass>(); //补课周班级集合
List <WeekClassTime> replenishWeekList = new List <WeekClassTime>();
int index = 0;
var batchNo = IdGenerator.NextId();
foreach (var m in replenishWeekClassTime.WeekClassTimeList)
{
var studentTimeLess = studentTimeLessList[index];
replenishWeekClassTime.EnrollOrderItemId = studentTimeLess.EnrollOrderItemId;
replenishWeekClassTime.CourseId = studentTimeLess.CourseId;
replenishWeekClassTime.CourseLevelId = studentTimeLess.CourseLevelId;
replenishWeekClassTime.TeacherId = studentTimeLess.TeacherId;
// 补课周补课班级编号生成规则
var newClassNo = $"{classNo}{datClassRooms.FirstOrDefault(x => x.ClassRoomId == m.ClassRoomId).RoomNo }{WeekDayConvert.DayOfWeekToInt(m.ClassDate)}{GetTimeNumNo(m.ClassBeginTime, m.ClassEndTime, oldDatClass.ClassNo)}{WeekClassNo}";
SetDatClass(replenishWeekClassTime, oldDatClass, timAdjustLessonList, newClassNo, newClassList, adjustLessonList, m, replenishWeekList, studentTimeLess, batchNo);
WeekClassTime week = new WeekClassTime
{
ClassDate = m.ClassDate,
ClassRoomId = m.ClassRoomId
};
replenishWeekList.Add(week);
index++;
}
using (var unitOfWork = new UnitOfWork())
{
try
{
unitOfWork.BeginTransaction();
// 1、写入调整课次业务表
unitOfWork.GetCustomRepository <TblTimAdjustLessonRepository, TblTimAdjustLesson>().Add <TblTimAdjustLesson>(adjustLessonList);
// 2、创建补课周补课班级
unitOfWork.GetCustomRepository <TblDatClassRepository, TblDatClass>().Add(newClassList);
// 3、调用课次服务
var adjustLessonReplenishWeekCreator = new AdjustLessonReplenishWeekCreator(replenishWeekClassTime, adjustLessonList, studentTimeLessList, replenishWeekClassTime.StudentId, replenishWeekClassTime.TermId, this._schoolId, this._teacherId);
ReplenishLessonService replenishLessonService = new ReplenishLessonService(unitOfWork);
replenishLessonService.Create(adjustLessonReplenishWeekCreator);
unitOfWork.CommitTransaction();
}
catch (Exception ex)
{
unitOfWork.RollbackTransaction();
throw ex;
}
}
}
}
/// <summary>
/// 描述：撤销排课
/// <para>作 者：Huang GaoLiang </para>
/// <para>创建时间：2019-03-11</para>
/// </summary>
/// <param name="iRequest">撤销排课请求参数</param>
/// <exception>
/// 异常ID：1,未找到数据
/// 异常ID：46,该课程已考勤，不能撤销！
/// </exception>
public override void Adjust(IAdjustLessonRequest iRequest)
{
AdjustRevokeRequest request = iRequest as AdjustRevokeRequest;
lock (LocalThreadLock.GetLockKeyName(LockKeyNames.LOCK_AMSSCHOOLSTUDENT, this._schoolId, request.StudentId.ToString()))
{
LessonFinisherInfo info = new LessonFinisherInfo();
// 根据课次编号获取学生课次信息
var timLessonStudent = new StudentTimetableService(this._schoolId, request.StudentId).GetStudentTimLessonByLessId(request.LessonId);
if (timLessonStudent == null)
{
throw new BussinessException(ModelType.Default, 1);
}
// 如果考勤状态是已考勤或者是已补签
if (timLessonStudent.AttendStatus == (int)AttendStatus.Normal || timLessonStudent.AdjustType == (int)AdjustType.SUPPLEMENTCONFIRMED)
{
throw new BussinessException(ModelType.Timetable, 46);
}
// 根据课次编号获取学生排课记录信息
TblTimLesson timLesson = new StudentTimetableService(this._schoolId, request.StudentId).GetTimLessonById(request.LessonId);
TblTimAdjustLesson timAdjustLesson = new TblTimAdjustLesson
{
AdjustLessonId = IdGenerator.NextId(),
SchoolId = this._schoolId,
BatchNo = IdGenerator.NextId(),
FromLessonId = timLesson.LessonId,
FromTeacherId = timLesson.TeacherId,
ToTeacherId = "",
StudentId = request.StudentId,
ClassRoomId = timLesson.ClassRoomId,
ClassId = timLesson.ClassId,
SchoolTimeId = 0,
ClassDate = timLesson.ClassDate,
ClassBeginTime = timLesson.ClassBeginTime,
ClassEndTime = timLesson.ClassEndTime,
BusinessType = (int)LessonBusinessType.CancelMakeLess,
Remark = LessonProcessConstants.Remark,
Status = (int)TimAdjustLessonStatus.Invalid,
CreateTime = DateTime.Now,
};
using (var unitOfWork = new UnitOfWork())
{
try
{
unitOfWork.BeginTransaction();
// 1、写入调整课次业务表
unitOfWork.GetCustomRepository <TblTimAdjustLessonRepository, TblTimAdjustLesson>().Add(timAdjustLesson);
// 2、调用课次服务
var adjustLessonRevokeFinisher = new AdjustLessonRevokeFinisher(this._schoolId, request.StudentId, request.LessonId, unitOfWork);
LessonService lessonService = new LessonService(unitOfWork);
lessonService.Finish(adjustLessonRevokeFinisher);
unitOfWork.CommitTransaction();
}
catch (Exception ex)
{
unitOfWork.RollbackTransaction();
throw ex;
}
}
}
}
