/// <summary>
/// 描述：获取最多可转入的课次
/// <para>作 者：瞿琦</para>
/// <para>创建时间：2018-11-7</para>
/// </summary>
/// <param name="inClassId">转入班级</param>
/// <param name="inDate">上课日期</param>
/// <returns>最多可以转入的课次</returns>
public int GetChangeInClassCount(long inClassId, DateTime inDate)
{
var service = new DefaultClassService(inClassId);
var inLesson = service.GetMaximumLessonByFirstTime(inDate);
return(inLesson);
}
/// <summary>
/// 校验学生上课时间是否冲突
/// <para>作 者：zhiwei.Tang</para>
/// <para>创建时间：2019-03-13</para>
/// </summary>
/// <param name="schoolId">校区ID</param>
/// <param name="studentId">学生ID</param>
/// <param name="verifyClassTimes">待校验的上课时间段</param>
/// <param name="lessonType">课次类型</param>
/// <exception cref="BussinessException">
/// 异常ID:32 异常描述：与XX班级时间段冲突
/// </exception>
protected virtual void VerifyClassTimeCross(
string schoolId, long studentId, List <VerifyClassTime> verifyClassTimes, LessonType lessonType)
{
if (lessonType != LessonType.RegularCourse)
{
return;
}
List <int> adjustTypes = new List <int> {
(int)AdjustType.DEFAULT, //默认
(int)AdjustType.SUPPLEMENTNOTCONFIRMED, //补签未确认
(int)AdjustType.SUPPLEMENTCONFIRMED //补签已确认
};
//学生上课时间
var stuClassTimeList = this.ViewCompleteStudentAttendanceRepository
.GetStudentAttendList(schoolId, studentId, adjustTypes, new List <int> {
(int)LessonType.RegularCourse
})
.Select(m => new StudentTimetableDto
{
ClassId = m.ClassId,
ClassBeginTime = DateTime.Parse($"{m.ClassDate:yyyy-MM-dd} {m.ClassBeginTime}"),
ClassEndTime = DateTime.Parse($"{m.ClassDate:yyyy-MM-dd} {m.ClassEndTime}")
}).ToList();
foreach (var classTime in verifyClassTimes)
{
//今天学生上课时间
var todayStuClassTimeList = stuClassTimeList
.Where(x => x.ClassBeginTime.Date == classTime.ClassDate.Date)
.ToList();
if (todayStuClassTimeList.Count == 0)
{
continue;
}
DateTime sTime = DateTime.Parse($"{classTime.ClassDate:yyyy-MM-dd} {classTime.ClassBeginTime}");
DateTime eTime = DateTime.Parse($"{classTime.ClassDate:yyyy-MM-dd} {classTime.ClassEndTime}");
foreach (var item in todayStuClassTimeList)
{
if ((item.ClassBeginTime <= sTime && sTime <= item.ClassEndTime) || (sTime <= item.ClassBeginTime && item.ClassBeginTime <= eTime))
{
var datClass = new DefaultClassService(item.ClassId).TblDatClass;
if (datClass != null)
{
throw new BussinessException(ModelType.Timetable, 32, $"与{datClass.ClassNo}班级上课时间冲突");
}
else
{
//班级上课时间冲突
throw new BussinessException(ModelType.Timetable, 32);
}
}
}
}
}
/// <summary>
/// 描述：获取转班明细列表
/// <para>作 者：瞿琦</para>
/// <para>创建时间：2019-3-6</para>
/// </summary>
/// <param name="searcher">列表筛选条件</param>
/// <returns>转班明细分页列表</returns>
public PageResult <ChangeClassListResponse> GetChangeClassList(ChangeClassListSearchRequest searcher)
{
var viewChangeClassRepository = new ViewTimChangeClassRepository();
//获取转班明细列表信息
var timChangeClassList = viewChangeClassRepository.GetTimeChangeClassList(this._schoolId, searcher);
var timChangeClassQuery = AutoMapper.Mapper.Map <List <ChangeClassListResponse> >(timChangeClassList.Data);
var classIdList = new List <long>();
classIdList.AddRange(timChangeClassQuery.Select(x => x.OutClassId)); //将转出班级Id集合添加到集合
classIdList.AddRange(timChangeClassQuery.Select(x => x.InClassId)); //将转入班级Id集合添加到集合
//获取所有的学期类型
var termTypeService = new TermTypeService();
var allTermTypeList = termTypeService.GetAll();
//获取班级信息集合
var classList = DefaultClassService.GetClassByClassIdAsync(classIdList).Result;
//获取所有的课程信息
var courseList = CourseService.GetAllAsync().Result;
//获取所有的人员
var userList = EmployeeService.GetAllBySchoolId(_schoolId);
foreach (var item in timChangeClassQuery)
{
//学期类型信息
var termModel = allTermTypeList.FirstOrDefault(x => x.TermTypeId == item.TermTypeId);
//转出班级信息
var outClassModel = classList.FirstOrDefault(x => x.ClassId == item.OutClassId);
//获取转出班级的课程信息
var outCourseModel = courseList.FirstOrDefault(x => x.CourseId == outClassModel.CourseId);
//获取转出班级教师
var outTeacherModel = userList.FirstOrDefault(x => x.EmployeeId == outClassModel.TeacherId);
//转入班级信息
var inClassModel = classList.FirstOrDefault(x => x.ClassId == item.InClassId);
//获取转入班级的课程信息
var inCourseModel = courseList.FirstOrDefault(x => x.CourseId == inClassModel.CourseId);
//获取转入班级老师
var inTeacherModel = userList.FirstOrDefault(x => x.EmployeeId == inClassModel.TeacherId);
item.TermTypeName = termModel == null ? "" : termModel.TermTypeName; //学期类型
item.OutClassName = outCourseModel == null?"": outCourseModel.ClassCnName;
item.OutClassNo = outClassModel == null ? "" : outClassModel.ClassNo;
item.OutClassTeacher = outTeacherModel == null?"": outTeacherModel.EmployeeName;
item.InClassName = inCourseModel == null?"": inCourseModel.ClassCnName;
item.InClassNo = inClassModel == null?"": inClassModel.ClassNo;
item.InClassTeacher = inTeacherModel == null?"": inTeacherModel.EmployeeName;
}
var result = new PageResult <ChangeClassListResponse>
{
Data = timChangeClassQuery,
CurrentPage = timChangeClassList.CurrentPage,
PageSize = timChangeClassList.PageSize,
TotalData = timChangeClassList.TotalData,
};
return(result);
}
/// <summary>
/// 获取排课数据基础数据源
/// <para>作 者：zhiwei.Tang</para>
/// <para>创建时间：2019-02-19</para>
/// </summary>
/// <param name="schoolId">校区Id</param>
/// <param name="classIds">班级Id</param>
/// <param name="companyId">公司编号</param>
/// <returns>返回排课数据源组合的基础数据源</returns>
private static MakeLessonResponseBasicData GetMakeLessonResponseBasicData(string schoolId, IEnumerable <long> classIds, string companyId)
{
MakeLessonResponseBasicData res = new MakeLessonResponseBasicData
{
ClassInfos = DefaultClassService.GetClassByClassIdAsync(classIds).Result,
ClassRooms = new SchoolClassRoomService(schoolId).GetAllEnableClassRoom(),
Courses = CourseService.GetAllAsync().Result,
CourseLevels = new CourseLevelService(companyId).GetList().Result
};
return(res);
}
/// <summary>
/// 根据排课Id构建一个课次生产对象
/// <para>作 者：zhiwei.Tang</para>
/// <para>创建时间：2019-02-19</para>
/// </summary>
/// <param name="makeLessonId">排课Id</param>
/// <param name="unitOfWork">工作单元</param>
public MakeLessonCreator(long makeLessonId, UnitOfWork unitOfWork) : base(makeLessonId)
{
this._unitOfWork = unitOfWork;
_makeLessonRepository = unitOfWork.GetCustomRepository <TblTimMakeLessonRepository, TblTimMakeLesson>();
_enrollOrderRepository = unitOfWork.GetCustomRepository <TblOdrEnrollOrderRepository, TblOdrEnrollOrder>();
_enrollOrderItemRepository = unitOfWork.GetCustomRepository <TblOdrEnrollOrderItemRepository, TblOdrEnrollOrderItem>();
_viewClassTeacherDateRepository = unitOfWork.GetCustomRepository <ViewClassTeacherDateRepository, ViewClassTeacherDate>();
_viewChangeClassTimeRepository = unitOfWork.GetCustomRepository <ViewChangeClassTimeRepository, ViewChangeClassTime>();
_makeLesson = _makeLessonRepository.Load(makeLessonId);
_classService = new DefaultClassService(_makeLesson.ClassId);
_viewClassTeacherDates = _viewClassTeacherDateRepository.Get(_makeLesson.ClassId);
_viewChangeClassTimeDates = _viewChangeClassTimeRepository.Get(_makeLesson.ClassId);
}
/// <summary>
/// 获取已安排补课或调课的详情
/// <para>作 者：zhiwei.Tang</para>
/// <para>创建时间：2019-03-12</para>
/// </summary>
/// <param name="studentId">学生Id</param>
/// <param name="lessonId">课次ID</param>
/// <returns>调课详情/补课详情</returns>
public StudentReplenishLessonsResponse GetStudentReplenishLessons(long studentId, long lessonId)
{
var studentAttendance = _viewCompleteStudentAttendanceRepository.Value.GetLesson(lessonId);
if (studentAttendance == null)
{
//未找到该学生的补课信息
throw new BussinessException(ModelType.Timetable, 47);
}
if (studentAttendance.StudentId != studentId)
{
//未找到该学生的补课信息
throw new BussinessException(ModelType.Timetable, 47);
}
//获取一个班级学生的课次信息
var stuDayAttendances = _viewCompleteStudentAttendanceRepository.Value.GetStudetnDayLessonList(
studentAttendance.SchoolId, studentAttendance.ClassId, studentAttendance.ClassDate,
studentId, LessonType.RegularCourse);
var lessonIds = stuDayAttendances.Select(x => x.LessonId).ToList();
var stuLessons = _viewTimReplenishLessonStudentRepository.Value.GetLessonListByParentLessonId(lessonIds);
if (stuLessons == null || !stuLessons.Any())
{
//未找到该学生的补课信息
throw new BussinessException(ModelType.Timetable, 47);
}
var stuLesson = stuLessons.OrderBy(x => x.ClassBeginTime).FirstOrDefault();
string classTime = string.Join(" ", stuLessons.Select(x => x.ClassBeginTime + "-" + x.ClassEndTime));
var classInfo = new DefaultClassService(stuLesson.ClassId).TblDatClass;
StudentReplenishLessonsResponse res = new StudentReplenishLessonsResponse
{
ClassId = stuLesson.ClassId,
ClassName = CourseService.GetByCourseId(stuLesson.CourseId)?.ClassCnName,
ClassRoom = new ClassRoomService(stuLesson.ClassRoomId).ClassRoomInfo?.RoomNo,
ClassTime = classTime,
ClassDate = stuLesson.ClassDate.ToString("yyyy.MM.dd"),
ClassNo = new DefaultClassService(stuLesson.ClassId).TblDatClass?.ClassNo,
TeacherName = TeachService.GetTeacher(stuLesson.TeacherId)?.TeacherName,
Week = WeekDayConvert.DayOfWeekToString(stuLesson.ClassDate.DayOfWeek)
};
return(res);
}
/// <summary>
/// 描述：根据学期获取本学期正式班级里面的课程信息
/// <para>作 者：瞿琦</para>
/// <para>创建时间：2018-10-17</para>
/// </summary>
/// <param name="termId">学期id</param>
/// <returns>已通过课程信息列表</returns>
public static List <ClassCourseResponse> GetTermClassCourseInfo(long termId)
{
var termClassList = DefaultClassService.GetClasssByTermId(termId);
//所有课程
var courseList = new TblDatCourseRepository().LoadList(x => x.IsDisabled == false);
//校区所属课程
var termClassCourseList = (from x1 in courseList
join x2 in termClassList on x1.CourseId equals x2.CourseId
select new ClassCourseResponse
{
CourseId = x1.CourseId,
ClassCnName = x1.ClassCnName
}).ToList();
return(termClassCourseList);
}
/// <summary>
/// 微信通知
/// <para>作 者：zhiwei.Tang</para>
/// <para>创建时间：2019-03-15</para>
/// </summary>
private void PushWeChatNoticeStart(List <ViewStudentScanCodeAttend> stuAttends, DateTime attendTime)
{
List <long> cIds = stuAttends.Select(x => x.ClassId).Distinct().ToList();
foreach (var item in cIds)
{
var temp = stuAttends.Where(x => x.ClassId == item).ToList();
var model = temp.FirstOrDefault();
var classTimeList = temp.Select(x => x.ClassBeginTime + "-" + x.ClassEndTime);
string classTime = $"{model.ClassDate:yyyy.MM.dd} {string.Join("、", classTimeList)}"; //上课时间段
var classService = new DefaultClassService(item);
var classInfo = classService.TblDatClass;
var classRoom = new ClassRoomService(classInfo.ClassRoomId).ClassRoomInfo.RoomNo; //教室门牌号
var className = CourseService.GetByCourseId(classInfo.CourseId)?.ClassCnName; //班级名称
PushWeChatNotice(className, classTime, classRoom, attendTime);
}
}
/// <summary>
/// 获取排课基础数据
/// <para>作 者：zhiwei.Tang</para>
/// <para>创建时间：2019-02-19</para>
/// </summary>
/// <param name="classId">班级Id</param>
/// <remarks>排课基础数据</remarks>
private CourseBasicData GetCourseBasicData(IEnumerable <long> classId)
{
CourseBasicData courseBasicData = new CourseBasicData
{
Classs = DefaultClassService.GetClassByClassIdAsync(classId).Result //班级
};
//学期
courseBasicData.Terms = TermService.GetTermByTermId(courseBasicData.Classs.Select(x => x.TermId));
//所有课程
courseBasicData.Courses = CourseService.GetAllAsync().Result;
//所有课程等级
courseBasicData.CourseLvs = CourseLevelService.GetAll();
//老师
courseBasicData.Teachers = TeachService.GetTeachers();
return(courseBasicData);
}
/// <summary>
/// 获取排课课次信息
/// <para>作 者：zhiwei.Tang</para>
/// <para>创建时间：2019-02-19</para>
/// </summary>
/// <param name="classInfo">班级信息</param>
/// <param name="companyId">公司编号</param>
/// <returns>排课课次信息</returns>
private static MakeLessonResponse GetMakeLessonResponse(ClassInfo classInfo, string companyId)
{
MakeLessonResponse response = new MakeLessonResponse
{
ClassId = classInfo.ClassId,
ClassName = classInfo.ClassName,
ClassNo = classInfo.ClassNo,
CourseLeaveName = classInfo.LevelName,
RoomNo = classInfo.RoomNo,
Week = new List <string>(),
ClassTime = new List <string>()
};
DefaultClassService classService = new DefaultClassService(classInfo.ClassId);
for (int i = 1; i <= 7; i++)
{
var schoolTimes = classService.ClassSchoolTimes.Where(x => x.WeekDay == i).ToList();
if (schoolTimes.Count == 0)
{
continue;
}
response.ClassTime.Add(WeekDayConvert.IntToString(i));
foreach (var item in schoolTimes)
{
var time = item.BeginTime + "-" + item.EndTime;
if (response.ClassTime.Any(x => x == time))
{
continue;
}
response.ClassTime.Add(time);
}
}
return(response);
}
/// <summary>
/// 获取需要生成的写生课和课次不够的学生列表
/// <para>作 者：郭伟佳</para>
/// <para>创建时间：2018-11-20</para>
/// </summary>
/// <param name="request">学期班级学生实体请求对象</param>
/// <param name="lifeClassInfo">写生课信息</param>
/// <param name="studentLessonList">学生课次基础信息表</param>
/// <param name="enrollItemList">学生报名订单课程明细信息</param>
/// <returns>
/// 1、学生课次不够的信息列表
/// 2、写生课排课列表
/// 3、写生学生班级列表
/// </returns>
private (List <LifeClassLackTimesListResponse>, List <LifeClassLessonMakeRequest>, List <LifeClassStudentClassResponse>) GetLifeClassLesson(List <TimeLessonClassRequest> request,
TblTimLifeClass lifeClassInfo,
IEnumerable <ViewTimeLessonClass> studentLessonList,
List <TblOdrEnrollOrderItem> enrollItemList)
{
//课次基础信息表
var lessonInfoList = studentLessonList.Where(a => request.Any(x => x.TermId == a.TermId && x.ClassId == a.ClassId));
//获取剩余课次不够写生课扣减课次的学生列表
var enrollOrderItemInfo = from a in enrollItemList
join b in lessonInfoList on a.EnrollOrderItemId equals b.EnrollOrderItemId
where a.Status == (int)OrderItemStatus.Enroll
select new LifeClassStudentListResponse
{
ClassTimes = a.ClassTimes,
ClassTimesUse = a.ClassTimesUse,
EnrollOrderItemId = b.EnrollOrderItemId,
StudentId = b.StudentId,
ClassId = b.ClassId
};
//获取班级信息
List <TblDatClass> classInfoList = DefaultClassService.GetClassByClassIdAsync(request.Select(a => a.ClassId).ToList()).Result;
//根据写生课Id，获取写生课对应的课次基础信息列表
var lifeInfoList = _timLessonRepository.Value.GetStudentLessonListAsync(_schoolId, new List <long> {
_lifeClassId
});
//课次不够扣的学生列表
List <LifeClassLackTimesListResponse> notEnoughTimeList = GetNotEnoughTimeStudnetList(lifeClassInfo, enrollOrderItemInfo, classInfoList, lifeInfoList);
//课次够扣的报班学生列表和学生多班级列表
(List <LifeClassLessonMakeRequest>, List <LifeClassStudentClassResponse>)lifeLessonList = GetEnoughTimeStudentList(lifeClassInfo, enrollOrderItemInfo, classInfoList, lifeInfoList);
return(notEnoughTimeList, lifeLessonList.Item1, lifeLessonList.Item2);
}
/// <summary>
/// 处理排课课次
/// <para>作 者：zhiwei.Tang</para>
/// <para>创建时间：2018-11-08</para>
/// </summary>
/// <param name="classId">班级Id</param>
/// <param name="classTimes">预计排课课次</param>
/// <param name="firstTime">首次上课时间</param>
/// <returns>实际需要排多少次课</returns>
private int GetClassTimes(long classId, int classTimes, DateTime firstTime)
{
int maximumLesson = new DefaultClassService(classId).GetMaximumLessonByFirstTime(firstTime);
return(maximumLesson < classTimes ? maximumLesson : classTimes);
}
/// <summary>
/// 获取的排课详情
/// <para>作 者：zhiwei.Tang</para>
/// <para>创建时间：2018-11-06</para>
/// </summary>
/// <param name="enrollOrderItemId">报名课程订单Id</param>
/// <returns>学生报名一个课程的排课详细信息</returns>
public MakeLessonDetailResponse GetMakeLessonDetail(long enrollOrderItemId)
{
MakeLessonDetailResponse res = new MakeLessonDetailResponse
{
CourseInfos = new List <CourseInformation>()
};
TblOdrEnrollOrderItem enrollOrderItem = _enrollOrderItemRepository.Load(enrollOrderItemId);
TblOdrEnrollOrder enrollOrder = _enrollOrderRepository.Load(enrollOrderItem.EnrollOrderId);
TblDatCourse course = CourseService.GetByCourseId(enrollOrderItem.CourseId);
res.RegisterInfo = new RegisterInformation()
{
ClassTimes = enrollOrderItem.ClassTimes,
ClassTimesUse = enrollOrderItem.ClassTimesUse,
CourseName = string.Empty,
LevelName = CourseLevelService.GetById(enrollOrderItem.CourseLevelId)?.LevelCnName ?? string.Empty,
Year = enrollOrderItem.Year,
CourseType = CourseType.Elective,
TermTypeId = enrollOrderItem.TermTypeId,
TermTypeName = TermTypeService.GetTermTypeName(enrollOrderItem.TermTypeId),
EnrollDate = enrollOrder.CreateTime
};
if (course != null)
{
res.RegisterInfo.CourseName = course.ShortName;
res.RegisterInfo.CourseType = CourseType.Compulsory;
}
List <TblTimMakeLesson> makeLessons =
_makeLessonRepository.GetUnconfirmedMakeLessonList(enrollOrderItem.EnrollOrderItemId);
if (makeLessons.Any())
{
List <long> classIds = makeLessons.Select(x => x.ClassId).ToList();
List <TblDatClass> classes = DefaultClassService.GetClassByClassIdAsync(classIds).Result;
List <ViewRoomCourse> classRooms = ClassRoomService.GetClassRoomBySchoolId(enrollOrder.SchoolId);
//老师
var teacherList = TeachService.GetTeachers();
foreach (var makeLesson in makeLessons)
{
var classInfo = classes.FirstOrDefault(x => x.ClassId == makeLesson.ClassId);
var classSchoolTimes = new DefaultClassService(classInfo.ClassId).ClassSchoolTimes;
//老师信息
var teacher = teacherList.FirstOrDefault(x => x.TeacherId == classInfo.TeacherId);
CourseInformation courseInformation = new CourseInformation
{
ClassId = classInfo.ClassId,
Year = enrollOrderItem.Year,
ClassNo = classInfo.ClassNo,
ClassTimesUse = makeLesson.ClassTimes,
CourseName = course?.ShortName ?? string.Empty,
FirstClassTime = makeLesson.FirstClassTime,
RoomNo = classRooms.FirstOrDefault(x => x.ClassRoomId == classInfo.ClassRoomId)?.RoomNo ?? string.Empty,
LevelName = CourseLevelService.GetById(classInfo.CourseLeveId)?.LevelCnName ?? string.Empty,
TeacherName = teacher?.TeacherName ?? string.Empty,
TermName = TermService.GetTermByTermId(classInfo.TermId)?.TermName ?? string.Empty,
Week = classSchoolTimes.Select(x => x.WeekDay)
.Distinct()
.OrderBy(x => x)
.Select(x => WeekDayConvert.IntToString(x))
.ToList(),
PeriodTime = new List <string>()
};
foreach (var item in classSchoolTimes)
{
string time = item.BeginTime + "-" + item.EndTime;
if (courseInformation.PeriodTime.Any(x => x == time))
{
continue;
}
courseInformation.PeriodTime.Add(time);
}
res.CourseInfos.Add(courseInformation);
}
}
return(res);
}
/// <summary>
/// 描述：获取可转入的课次信息
/// <para>作 者：瞿琦</para>
/// <para>创建时间：2018-11-7</para>
/// </summary>
/// <exception cref="AMS.Core.BussinessException">
/// 异常Id:1,异常描述：未找到数据
/// 异常Id:71，异常描述：转入班级时间段和课次信息调整时间段不一致
/// </exception>
/// <returns>可转入课次信息列表</returns>
public List <LessonCreatorInfo> GetLessonCreatorInfo()
{
var result = new List <LessonCreatorInfo>();
//获取转入班级信息
var classService = new DefaultClassService(base._entity.InClassId);
var firstTime = base._entity.InDate;
//1.获取学期信息
var termInfo = TermService.GetTermByTermId(classService.TblDatClass.TermId);
if (termInfo == null)
{
throw new BussinessException(ModelType.Default, 1);
}
//2.获取停课日
var schoolHoliday = TermService.GetSchoolHoliday(termInfo);
//首次上课时间大于学期结束时间则没有课次
if (firstTime > termInfo.EndDate)
{
return(result);
}
//首次上课时间小于学期开始时间，则首次上课时间等于学期开始时间
if (firstTime < termInfo.BeginDate)
{
firstTime = termInfo.BeginDate;
}
while (firstTime <= termInfo.EndDate)
{
//上课时间大于学期结束时间或者预计排课课次等于实际排课课次，则停止排课
if (firstTime > termInfo.EndDate || _entity.ClassTimes == _actualLesson)
{
break;
}
var isClosed = SchoolHolidayService.TodayIsSuspendClasses(schoolHoliday, firstTime);
//当前时间是否是停课日，如果是则加1
if (isClosed)
{
firstTime = firstTime.AddDays(1);
continue;
}
//星期转换
var week = WeekDayConvert.DayOfWeekToInt(firstTime);
//获取与当前时间匹配的班级上课时间
var schoolTimes = classService.ClassSchoolTimes.Where(x => x.WeekDay == week).OrderBy(x => x.BeginTime).ToList();
//获取班级是否有课程信息调整（上课日期和上课时间段 修改）
var classDateChangeList = _viewChangeClassTimeDates.Where(x => x.OldClassDate == firstTime).OrderBy(x => x.NewClassBeginTime).ToList();
if (classDateChangeList.Count > 0 && classDateChangeList.Count != schoolTimes.Count) //如果班级设置的上课时间段和课程调整的时间段不一致则抛出异常
{
throw new BussinessException(ModelType.Timetable, 71);
}
var lessonCount = 0;
foreach (var time in schoolTimes)
{
var lesson = new LessonCreatorInfo
{
BusinessId = base._entity.ChangeClassId,
BusinessType = base.BusinessType,
ClassId = base._entity.InClassId,
ClassDate = firstTime,
ClassBeginTime = time.BeginTime,
ClassEndTime = time.EndTime,
ClassRoomId = classService.TblDatClass.ClassRoomId,
CourseId = classService.TblDatClass.CourseId,
CourseLevelId = classService.TblDatClass.CourseLeveId,
EnrollOrderItemId = _enrollOrderItemId,
SchoolId = termInfo.SchoolId,
StudentId = base._entity.StudentId,
TeacherId = classService.TblDatClass.TeacherId,
TermId = termInfo.TermId
};
//获取是否有老师调课
var teacherLessonChangeInfo = _viewClassTeacherDates.FirstOrDefault(x => x.ClassId == lesson.ClassId && x.ClassDate == lesson.ClassDate);
if (teacherLessonChangeInfo != null && teacherLessonChangeInfo.TeacherId.Trim() != lesson.TeacherId.Trim())
{
lesson.TeacherId = teacherLessonChangeInfo.TeacherId;
}
//获取班级是否有修改上课日期和上课时间段,并赋值
if (classDateChangeList.Any())
{
lesson.ClassDate = classDateChangeList[lessonCount].NewClassDate;
lesson.ClassBeginTime = classDateChangeList[lessonCount].NewClassBeginTime;
lesson.ClassEndTime = classDateChangeList[lessonCount].NewClassEndTime;
}
result.Add(lesson);
lessonCount++;
//实际排课课次+1
_actualLesson++;
}
firstTime = firstTime.AddDays(1);
}
return(result);
}
/// <summary>
/// 复制正式学期排课数据到草稿
/// <para>作 者：zhiwei.Tang</para>
/// <para>创建时间：2018-09-25</para>
/// </summary>
/// <returns>得到审核Id</returns>
private long CopyClassToAutClass()
{
//获取所有班级信息
var classes = DefaultClassService.GetClasssByTermId(_termId);
//获取班级所有上课时间段
var classTime = DefaultClassService.GetClassTimeByClassId(classes.Select(x => x.ClassId));
TblAutAudit autAudit = new TblAutAudit
{
AuditId = IdGenerator.NextId(),
CreateTime = DateTime.Now,
AuditDate = DateTime.Now,
AuditStatus = (int)AuditStatus.WaitAudit,
AuditUserId = string.Empty,
AuditUserName = string.Empty,
BizType = (int)AuditBusinessType.TermCourseTimetable,
DataExt = string.Empty,
DataExtVersion = string.Empty,
ExtField1 = _termId.ToString(),
ExtField2 = string.Empty,
FlowNo = string.Empty,
UpdateTime = DateTime.Now,
SchoolId = base.TblAutAudit.SchoolId,
CreateUserId = string.Empty,
CreateUserName = string.Empty
};
List <TblAutClass> autClasses = classes.Select(x => new TblAutClass
{
AutClassId = IdGenerator.NextId(),
AuditId = autAudit.AuditId,
ClassId = x.ClassId,
ClassNo = x.ClassNo,
ClassRoomId = x.ClassRoomId,
CourseId = x.CourseId,
CourseLeveId = x.CourseLeveId,
CourseNum = x.CourseNum,
CreateTime = DateTime.Now,
DataStatus = 0,
RoomCourseId = x.RoomCourseId,
StudentsNum = x.StudentsNum,
TeacherId = x.TeacherId,
TermId = x.TermId,
UpdateTime = DateTime.Now,
SchoolId = base.TblAutAudit.SchoolId
}).ToList();
List <TblAutClassTime> autClassTime = classTime.Select(x => new TblAutClassTime
{
AutClassTimeId = IdGenerator.NextId(),
AuditId = autAudit.AuditId,
ClassId = x.ClassId,
ClassTimeId = x.ClassTimeId,
CreateTime = DateTime.Now,
DataStatus = 0,
SchoolTimeId = x.SchoolTimeId,
SchoolId = base.TblAutAudit.SchoolId
}).ToList();
//TODO:事物
Task[] tasks = new Task[3];
tasks[0] = _tblAutAuditRepository.AddTask(autAudit);
tasks[1] = _tblAutClassRepository.Value.SaveTask(autClasses);
tasks[2] = _tblAutClassTimeRepository.Value.SaveTask(autClassTime);
Task.WaitAll(tasks);
return(autAudit.AuditId);
}
/// <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;
}
}
}
}
