/// <summary>
/// 获取未交接的报班订单列表（问题单与未交接）
/// <para>作 者：郭伟佳</para>
/// <para>创建时间：2018-11-21</para>
/// </summary>
/// <param name="personalId">招生专员Id</param>
/// <returns>收款交接订单添加的实体列表</returns>
public List <OrderHandleAddResponse> GetUnHandleAddList(string personalId)
{
var result = new List <OrderHandleAddResponse>();
//获取招生专员对应的学生报名信息
var enrollOrderInfoList = new EnrollOrderService(_schoolId).GetEnrollOrderByCreatorId(personalId).Result.Where(a => a.OrderStatus == (int)OrderStatus.Paid).ToList();
if (enrollOrderInfoList != null && enrollOrderInfoList.Count > 0)
{
//获取招生专员对应的订单交接核对明细信息
var handoverDetailList = _detailRepository.Value.GetDetailsByPersonalId(_schoolId, personalId).Result;
//获取报班订单问题单/未交接的数据
var enrollOrderList = enrollOrderInfoList.Where(a => !handoverDetailList.Any(b => b.OrderId == a.EnrollOrderId && b.OrderTradeType == (int)OrderTradeType.EnrollOrder) ||
(handoverDetailList.Exists(c => a.EnrollOrderId == c.OrderId && c.OrderTradeType == (int)OrderTradeType.EnrollOrder && c.HandoverStatus == (int)HandoverStatus.Problematic)));
if (enrollOrderList != null && enrollOrderList.Any())
{
result = enrollOrderList.Select(a => new OrderHandleAddResponse
{
OrderId = a.EnrollOrderId,
OrderTradeType = (int)OrderTradeType.EnrollOrder,
CreateTime = a.CreateTime
}).ToList();
}
}
return(result);
}
/// <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>作 者：郭伟佳</para>
/// <para>创建时间：2018-11-20</para>
/// </summary>
/// <param name="request">学期班级学生实体请求对象</param>
/// <param name="lifeClassInfo">写生课对象</param>
/// <param name="lessonClassList">课次基础信息表</param>
/// <exception cref="AMS.Core.BussinessException">
/// 异常ID：
/// 13. 系统不存在该写生课信息
/// 28. 系统不存在该报名订单课程明细信息
/// 29. 请选择学生进行写生排课
/// </exception>
private void CheckDataBeforeMake(List <TimeLessonClassRequest> request, TblTimLifeClass lifeClassInfo, List <ViewTimeLessonClass> lessonClassList)
{
//获取写生课信息
if (lifeClassInfo == null)
{
throw new BussinessException(ModelType.Timetable, 13);
}
if (request == null || request.Count == 0)
{
throw new BussinessException(ModelType.Timetable, 29);
}
//获取报名订单课程明细信息
var enrollOrderItemInfoList = EnrollOrderService.GetEnrollOrderItemByItemId(lessonClassList.Select(a => a.EnrollOrderItemId).Distinct());
//检查课次基础信息是否存在
var classEnrollOrderItemList = lessonClassList.Where(a => request.Any(b => b.TermId == a.TermId && b.ClassId == a.ClassId)).GroupBy(g => new { g.EnrollOrderItemId, g.StudentId, g.ClassId })
.Select(s => new { s.Key.ClassId, s.Key.EnrollOrderItemId, s.Key.StudentId });
//如果学生不存在课次基础信息，则直接抛出异常信息
if (!enrollOrderItemInfoList.Exists(a => classEnrollOrderItemList.Any(b => b.EnrollOrderItemId == a.EnrollOrderItemId) && a.Status == (int)OrderItemStatus.Enroll))
{
throw new BussinessException(ModelType.Timetable, 28);
}
}
/// <summary>
/// 描述：课次创建完成后的回调方法
/// <para>作 者：瞿琦</para>
/// <para>创建时间：2018-11-7</para>
/// </summary>
public void AfterLessonCreate()
{
//已排课次的影响
if (base._entity.ClassTimes != _actualLesson)
{
EnrollOrderService service = new EnrollOrderService(base._entity.SchoolId);
service.AddClassTimesUse(_enrollOrderItemId, base._entity.ClassTimes - _actualLesson, base._unitOfWork);
}
}
/// <summary>
/// 获取学生课次费用明细（已排课+未排课）
/// <para>作 者：瞿琦</para>
/// <para>创建时间：2018-11-8</para>
/// </summary>
/// <param name="leaveTime">休学日期</param>
/// <param name="companyId">公司编号</param>
/// <returns>报名课次费用明细</returns>
/// <exception cref="AMS.Core.BussinessException">无</exception>
internal List <RefundOrderTransactDetailListResponse> GetCourseLessonList(DateTime leaveTime, string companyId)
{
//获取所有的课程信息
var courseList = CourseService.GetAllAsync().Result;
//获取所有的学期类型
var termTypeList = new TermTypeService().GetAll();
//获取所有的课程级别集合
var courseLevelList = new CourseLevelService(companyId).GetList().Result;
var enrollOrderTrade = new EnrollOrderService(this._schoolId);
//已排课的信息
var studentTimetableService = new StudentTimetableService(this._schoolId, this._studentId);
var hasLessonList = studentTimetableService.GetLeaveSchoolLessonCount(leaveTime); //获取休学课次信息
var enroOrderList = new List <RefundOrderTransactDetailListResponse>();
var enroOrderItemList = enrollOrderTrade.GetStudentEnroOrderItem(this._studentId, leaveTime);
foreach (var item in enroOrderItemList)
{
var lessonArray = hasLessonList.FirstOrDefault(x => x.EnrollOrderItemId == item.EnrollOrderItemId);
var lessonCount = lessonArray?.Count ?? 0; //休学课次
//上课课次
var haveClassLesson = item.ClassTimes - (item.ClassTimes - item.ClassTimesUse) - lessonCount; //上课课次=报名课次-未排课次-休学课次
var refundNum = item.PayAmount - (haveClassLesson * (item.TuitionFee + item.MaterialFee));
var refundAmount = refundNum > 0 ? refundNum : 0; //退费金额=实收金额-扣除金额 退费金额为负数时等于0
var entity = new RefundOrderTransactDetailListResponse
{
Year = item.Year,
TermTypeId = item.TermTypeId,
TermTypeName = termTypeList.FirstOrDefault(k => k.TermTypeId == item.TermTypeId)?.TermTypeName,
EnrollOrderItemId = item.EnrollOrderItemId,
CourseId = item.CourseId,
CourseName = courseList.FirstOrDefault(k => k.CourseId == item.CourseId)?.CourseCnName,
CourseLevelId = item.CourseLevelId,
CourseLevelName = courseLevelList.FirstOrDefault(k => k.CourseLevelId == item.CourseLevelId)?.LevelCnName,
ClassTimes = item.ClassTimes,
PaidAmount = item.PayAmount,
HaveClassLesson = haveClassLesson, //上课课次=报名课次-休学课次-未排课课次
DeductAmount = haveClassLesson * (item.TuitionFee + item.MaterialFee), //扣除费用=上课课次*原课次单价
LeaveSchoolLessons = lessonCount, //排课部分休学课次
RefundAmount = refundAmount, ////退费金额=实收金额-扣除金额 退费金额为负数时等于0 没有排课时退费金额=实收金额
TuitionFee = item.TuitionFee,
MaterialFee = item.MaterialFee,
DiscountFee = item.DiscountFee,
Status = item.Status
};
enroOrderList.Add(entity);
}
return(enroOrderList);
}
/// <summary>
/// 生成写生课之后的操作
/// <para>作 者：郭伟佳</para>
/// <para>创建时间：2018-11-13</para>
/// </summary>
public void AfterLessonCreate()
{
if (this._data != null && this._data.Count > 0)
{
//对报名的课程明细的已排课次进行累加
EnrollOrderService service = new EnrollOrderService(_entity.SchoolId);
foreach (var itemId in _data.Select(a => a.EnrollOrderItemId).Distinct())
{
service.AddClassTimesUse(itemId, _entity.UseLessonCount, _unitOfWork);
}
}
}
/// <summary>
/// 描述:根据退费订单的Id获取退费订单的课程明细
/// <para>作 者：瞿 琦</para>
/// <para>创建时间：2018-12-20</para>
/// </summary>
/// <param name="refundOrderId">退费订单表Id</param>
/// <param name="companyId">公司编号</param>
/// <returns>休学订单课程明细</returns>
internal static List <RefundOrderTransactDetailListResponse> GetRefundCourseAmountDetail(long refundOrderId, string companyId)
{
//获取所有的课程信息
var courseList = CourseService.GetAllAsync().Result;
//获取所有的学期类型
var termTypeList = new TermTypeService().GetAll();
//获取所有的课程级别集合
var courseLevelList = new CourseLevelService(companyId).GetList().Result;
var refundCourseList = new TblOdrRefundOrdeEnrollRepository().GetRefundOrderByOrderEnroll(refundOrderId);
var leaveSchoolCourseIdList = refundCourseList.Select(x => x.EnrollOrderItemId);
var courseOrderDetailList = EnrollOrderService.GetEnrollOrderItemIdByEnroOrderList(leaveSchoolCourseIdList);
var refundCourseDetail = new List <RefundOrderTransactDetailListResponse>();
foreach (var item in courseOrderDetailList)
{
var refundCourseInfo = refundCourseList.FirstOrDefault(k => k.EnrollOrderItemId == item.EnrollOrderItemId);
//获取上课课次
var haveClassLesson = refundCourseInfo?.UseLessonCount ?? 0;
//获取扣除费用
var deductAmount = haveClassLesson * (item.MaterialFee + item.TuitionFee);
//获取休学/退班课次
var leaveSchoolLessons = refundCourseInfo?.LessonCount ?? 0;
//获取退费金额
var refundAmount = refundCourseInfo?.Amount ?? 0;
var entity = new RefundOrderTransactDetailListResponse
{
Year = item.Year,
TermTypeId = item.TermTypeId,
TermTypeName = termTypeList.FirstOrDefault(k => k.TermTypeId == item.TermTypeId)?.TermTypeName,
EnrollOrderItemId = item.EnrollOrderItemId,
CourseId = item.CourseId,
CourseName = courseList.FirstOrDefault(k => k.CourseId == item.CourseId)?.CourseCnName,
CourseLevelId = item.CourseLevelId,
CourseLevelName = courseLevelList.FirstOrDefault(k => k.CourseLevelId == item.CourseLevelId)?.LevelCnName,
ClassTimes = item.ClassTimes,
PaidAmount = item.PayAmount,
HaveClassLesson = haveClassLesson, //上课课次
DeductAmount = deductAmount, //扣除费用
LeaveSchoolLessons = leaveSchoolLessons, //休学/退班课次
RefundAmount = refundAmount, //退费金额
TuitionFee = item.TuitionFee,
MaterialFee = item.MaterialFee,
DiscountFee = item.DiscountFee,
};
refundCourseDetail.Add(entity);
}
return(refundCourseDetail);
}
/// <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>
/// 排课之后跟家长确认
/// <para>作 者：zhiwei.Tang</para>
/// <para>创建时间：2019-02-19</para>
/// </summary>
public void AfterLessonCreate()
{
ValidateObject(_makeLesson);
//跟家长确认
_makeLesson.IsConfirm = true;
_makeLesson.ClassTimes = _lessonCount;
_makeLessonRepository.Update(_makeLesson);
EnrollOrderService service = new EnrollOrderService(_makeLesson.SchoolId);
service.AddClassTimesUse(_makeLesson.EnrollOrderItemId, this._lessonCount, _unitOfWork);
}
/// <summary>
/// 获取学生正常的订单
/// <para>作 者：zhiwei.Tang</para>
/// <para>创建时间：2018-11-09</para>
/// </summary>
/// <returns>报名订单集合</returns>
private List <TblOdrEnrollOrder> GetStudentOrders()
{
EnrollOrderService enrollOrderService = new EnrollOrderService(_schoolId);
List <TblOdrEnrollOrder> studentAllOrders = enrollOrderService.GetStudentOrders(_studentId).Result;
int paid = (int)OrderStatus.Paid;
int finish = (int)OrderStatus.Finish;
List <TblOdrEnrollOrder> studentNormalOrders =
studentAllOrders.Where(x => x.OrderStatus == paid || x.OrderStatus == finish).ToList();
return(studentNormalOrders);
}
/// <summary>
/// 取消之后的操作
/// <para>作 者：郭伟佳</para>
/// <para>创建时间：2018-11-10</para>
/// </summary>
public void AfterLessonFinish()
{
var lessonInfoList = _lessonRepository.Value.GetByLessonIdTask(_lessonIdList).Result;
if (lessonInfoList != null && lessonInfoList.Count > 0)
{
//对报名的课程明细的已排课次进行扣减
EnrollOrderService service = new EnrollOrderService(_entity.SchoolId);
foreach (var itemId in lessonInfoList.Select(a => a.EnrollOrderItemId).Distinct())
{
service.AddClassTimesUse(itemId, -_entity.UseLessonCount, _unitOfWork);
}
}
}
/// <summary>
/// 获取学生报名订单课程明细
/// <para>作 者：zhiwei.Tang</para>
/// <para>创建时间：2018-11-09</para>
/// </summary>
/// <param name="enrollOrderId">报名订单ID</param>
/// <returns>报名订单课程明细集合</returns>
private List <TblOdrEnrollOrderItem> GetStudentOrderItems(IEnumerable <long> enrollOrderId)
{
EnrollOrderService enrollOrderService = new EnrollOrderService(_schoolId);
//已报名
int enroll = (int)OrderItemStatus.Enroll;
List <TblOdrEnrollOrderItem> studentOrderItems =
enrollOrderService.GetEnrollOrderItemByEnrollOrderId(enrollOrderId)
.Result
.Where(x => x.Status == enroll)
.ToList();
return(studentOrderItems);
}
/// <summary>
/// 获取下一需要交接的订单
/// <para>作 者：郭伟佳</para>
/// <para>创建时间：2018-11-19</para>
/// </summary>
/// <param name="personalId">招生专员Id</param>
/// <param name="orderId">已核对的订单Id</param>
/// <returns>收款交接订单添加的实体</returns>
public OrderHandleAddResponse GetNextHandoverOrder(string personalId, long orderId)
{
OrderHandleAddResponse result = new OrderHandleAddResponse();
var enrollOrderInfoList = new EnrollOrderService(_schoolId).GetEnrollOrderByCreatorId(personalId).Result.Where(a => a.OrderStatus == (int)OrderStatus.Paid).ToList();
if (enrollOrderInfoList != null && enrollOrderInfoList.Count > 0)
{
//获取时间最早的一笔未交接的报名订单，下一步进行核对
var enrollOrderInfo = enrollOrderInfoList.OrderBy(o => o.CreateTime).FirstOrDefault(a => a.EnrollOrderId != orderId);
if (enrollOrderInfo != null)
{
result.OrderId = enrollOrderInfo.EnrollOrderId;
result.OrderTradeType = (int)OrderTradeType.EnrollOrder;
}
}
return(result);
}
/// <summary>
/// 获取报班未交接的列表
/// <para>作 者：郭伟佳</para>
/// <para>创建时间：2018-11-15</para>
/// </summary>
/// <param name="personalId">招生专员Id</param>
/// <returns>订单未交接列表</returns>
public List <OrderUnHandoverListResponse> GetUnHandList(string personalId)
{
List <OrderUnHandoverListResponse> result = new List <OrderUnHandoverListResponse>();
//获取招生专员对应的学生报名信息
var enrollOrderInfoList = new EnrollOrderService(_schoolId).GetEnrollOrderByCreatorId(personalId).Result.Where(a => a.OrderStatus == (int)OrderStatus.Paid).ToList();
if (enrollOrderInfoList != null && enrollOrderInfoList.Count > 0)
{
//获取学生信息
var studentInfoList = StudentService.GetStudentByIds(enrollOrderInfoList.Select(a => a.StudentId)).Result;
//获取招生专员对应的订单交接核对明细信息
var handoverDetailList = _detailRepository.Value.GetDetailsByPersonalId(_schoolId, personalId).Result;
//过滤报班订单已交接的数据
var enrollOrderList = enrollOrderInfoList.Where(a => !handoverDetailList.Any(b => b.OrderId == a.EnrollOrderId && b.OrderTradeType == (int)OrderTradeType.EnrollOrder) ||
(handoverDetailList.Exists(c => a.EnrollOrderId == c.OrderId && c.OrderTradeType == (int)OrderTradeType.EnrollOrder && c.HandoverStatus != (int)HandoverStatus.Handover)));
foreach (var item in enrollOrderList)
{
//学生对应的学生信息
var studentInfo = studentInfoList.FirstOrDefault(s => s.StudentId == item.StudentId);
OrderUnHandoverListResponse handoverModel = new OrderUnHandoverListResponse()
{
OrderId = item.EnrollOrderId,
OrderNo = item.OrderNo,
StudentNo = studentInfo?.StudentNo,
StudentName = studentInfo?.StudentName,
PayAmount = item.PayAmount,
TradeType = (int)OrderTradeType.EnrollOrder,
TradeTypeName = EnumName.GetDescription(typeof(OrderTradeType), (int)OrderTradeType.EnrollOrder),//报班
Status = (int)TransferStatus.UnTransfer,
StatusName = EnumName.GetDescription(typeof(TransferStatus), (int)TransferStatus.UnTransfer),
Remark = item.Remark,
CreateTime = item.CreateTime
};
//报单订单对应的订单交接核对明细信息
var handoverDetail = handoverDetailList.FirstOrDefault(h => h.PersonalId == item.CreateId && h.OrderId == item.EnrollOrderId);
if (handoverDetail != null)
{
handoverModel.Status = handoverDetail.HandoverStatus.Value;
handoverModel.StatusName = EnumName.GetDescription(typeof(HandoverStatus), handoverDetail.HandoverStatus);
}
result.Add(handoverModel);
}
}
return(result);
}
/// <summary>
/// 描述：预览生成优惠数据（满减金额+转介绍）
/// <para>作 者：瞿琦</para>
/// <para>创建时间：2018-11-2</para>
/// </summary>
/// <param name="studentId">学生Id</param>
/// <returns>优惠信息集合</returns>
public async Task <List <CouponGenerateResponse> > Peek(long studentId)
{
var result = new List <CouponGenerateResponse>();
//1.满减信息
var resultFullReduce = new CouponGenerateResponse();
//获取赠与奖学金金额
var query = (await _tblDctCouponRuleRepository.Value.GetAmountByCouponRule(_schoolId, _totalAmount)).FirstOrDefault();
resultFullReduce.CouponRuleId = query?.CouponRuleId ?? 0;
resultFullReduce.CouponRuleAmount = query?.CouponAmount ?? 0;
resultFullReduce.CouponType = CouponType.FullReduce;
result.Add(resultFullReduce);
//2.转介绍信息
//获取学生是否有转介绍Id
var studentService = new StudentService(_schoolId);
var studenInfo = studentService.GetStudent(studentId);
//获取学生是否有报名信息
var enrollOrderService = new EnrollOrderService(_schoolId);
var studentOrder = enrollOrderService.GetStudentOrders(studentId).Result;
if (!studentOrder.Any()) //没有报过名，并且有转介绍人 才返回转介绍信息
{
if (studenInfo.ParentId <= 0)
{
return(result);
}
var couponRuleService = new CouponRuleService(_schoolId);
var couponRuleResult = couponRuleService.GetTblDctCouponRuleInfo();
var resultRecommend = new CouponGenerateResponse
{
CouponRuleId = couponRuleResult?.CouponRuleId ?? 0,
CouponRuleAmount = couponRuleResult?.CouponAmount ?? 0,
CouponType = CouponType.Recommend
};
result.Add(resultRecommend);
}
return(result);
}
/// <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-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;
}
}
}
}
