/// <summary>
/// 获取老师要上课的班级信息
/// <para>作 者：zhiwei.Tang</para>
/// <para>创建时间：2019-03-08</para>
/// </summary>
/// <param name="classDate">上课日期</param>
/// <returns>老师上课班级列表</returns>
public List <ClassLessonResponse> GetClassLessons(DateTime classDate)
{
var abnormalStates = _totalClassStudentAbnormalStateRepository.Value.Get(this._schoolId, this._teacherId, classDate);
List <ClassLessonResponse> res = _viewClassLessonRepository
.Value.GetClassLessons(this._schoolId, this._teacherId, classDate)
.Select(x => new ClassLessonResponse
{
ClassId = x.ClassId,
ClassName = x.ClassName,
ClassRoom = x.ClassRoom,
ClassTime = ConvClassTime(x.ClassTime, x.LessonType),
LessonType = (LessonType)x.LessonType,
ClassDate = x.ClassDate.ToString("yyyy-MM-dd"),
Week = WeekDayConvert.DayOfWeekToString(x.ClassDate.DayOfWeek),
ClassNo = x.ClassNo
}).OrderBy(x => x.ClassTime).ToList();
res.ForEach(x =>
{
x.Mark = false;
var temp = abnormalStates.FirstOrDefault(m => m.LessonType == (int)x.LessonType && m.ClassId == x.ClassId);
if (temp != null && temp.Total > 0)
{
x.Mark = true;
}
});
return(res);
}
/// <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>创建时间：2019-3-14</para>
/// </summary>
/// <param name="schoolId">校区Id</param>
/// <param name="day">日期</param>
/// <returns>时间段集合</returns>
public static List <SchoolDayTimeListResponse> GetDayTimeList(string schoolId, DateTime day)
{
//获取今天属于星期几
int dayInt = WeekDayConvert.DayOfWeekToInt(day);
//获取日期所属学期
var termList = new TblDatTermRepository().GetDateByTermList(day);
var schoolTimeList = new TblDatSchoolTimeRepository().GetSchoolOrTermBySchoolTimeList(schoolId, termList.Select(x => x.TermId));
var daySchoolTimeList = schoolTimeList.Where(x => x.WeekDay == dayInt).Select(x => new SchoolDayTimeListResponse
{
BeginTime = x.BeginTime,
EndTime = x.EndTime
}).Distinct(new Compare <SchoolDayTimeListResponse>((x, y) => (x != null && y != null && x.BeginTime == y.BeginTime && x.EndTime == y.EndTime)))
.ToList();
return(daySchoolTimeList);
}
/// <summary>
/// 获取上课时间表
/// <para>作 者：zhiwei.Tang</para>
/// <para>创建时间：2018-09-19</para>
/// </summary>
/// <returns>上课时间段信息</returns>
private TupleSchoolTime GetTimetableSchoolTimeResponse(TimeType duration)
{
TupleSchoolTime res = new TupleSchoolTime
{
TblDatSchoolTimes = new SchoolTimeService(this._termId)
.TblDatSchoolTime
.Where(x => x.Duration == (int)duration)
.OrderBy(x => x.WeekDay)
.ThenBy(x => x.BeginTime)
.ToList(),
TimetableSchoolTimeResponses = new List <TimetableSchoolTimeResponse>()
};
for (int i = 1; i <= 7; i++)
{
TimetableSchoolTimeResponse schoolTime = new TimetableSchoolTimeResponse
{
WeekDay = WeekDayConvert.IntToString(i),
Times = new List <SchoolTimePeriodResponse>()
};
var weekDayTime = res.TblDatSchoolTimes
.Where(x => x.WeekDay == i)
.Select(x => new SchoolTimePeriodResponse
{
SchoolTimeId = x.SchoolTimeId,
BeginTime = x.BeginTime,
EndTime = x.EndTime
})
.OrderBy(x => x.BeginTime)
.ToList();
schoolTime.Times.AddRange(weekDayTime);
//如果该星期没有时间，则不加入该数据
if (schoolTime.Times != null && schoolTime.Times.Count > 0)
{
res.TimetableSchoolTimeResponses.Add(schoolTime);
}
}
return(res);
}
/// <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>作 者：zhiwei.Tang</para>
/// <para>创建时间：2018-11-07</para>
/// </summary>
/// <param name="firstTime">首次上课时间</param>
/// <returns>插班补上本学期已上课程数</returns>
/// <exception cref="BussinessException">
/// 异常ID：1 异常描述：学期信息为空
/// </exception>
public int GetTransferLessonByFirstTime(DateTime?firstTime)
{
int transferLesson = 0;
//1.获取学期信息
var termInfo = TermService.GetTermByTermId(TblDatClass.TermId);
if (termInfo == null)
{
throw new BussinessException(ModelType.Default, 1);
}
if (!firstTime.HasValue)
{
firstTime = termInfo.BeginDate;
}
//时间不在学期的开始、结束范围类则没有插班补课
if (firstTime < termInfo.BeginDate || firstTime > termInfo.EndDate)
{
return(transferLesson);
}
//2.获取停课日
List <SchoolHolidayResponse> schoolHoliday = TermService.GetSchoolHoliday(termInfo);
while (termInfo.BeginDate < firstTime)
{
//今天
DateTime today = termInfo.BeginDate;
termInfo.BeginDate = termInfo.BeginDate.AddDays(1);
bool isClosed = SchoolHolidayService.TodayIsSuspendClasses(schoolHoliday, today);
if (isClosed)
{
continue;
}
int weekDay = WeekDayConvert.DayOfWeekToInt(today);
var todayClassTimes = ClassSchoolTimes
.Where(x => x.WeekDay == weekDay)
.OrderBy(x => x.BeginTime)
.ToList();
if (todayClassTimes.Count == 0)
{
continue;
}
var firstClassTime = todayClassTimes.FirstOrDefault();
if (todayClassTimes.Count == 1)
{
switch ((TimeType)firstClassTime.Duration)
{
case TimeType.Sixty when termInfo.Classes60 <= transferLesson:
return(transferLesson);
case TimeType.Ninety when termInfo.Classes60 <= transferLesson:
return(transferLesson);
}
}
else
{
if (termInfo.Classes180 <= transferLesson)
{
return(transferLesson);
}
}
transferLesson += todayClassTimes.Count;
}
return(transferLesson);
}
/// <summary>
/// 根据首次上课时间获取排课最大课次
/// <para>作 者：zhiwei.Tang</para>
/// <para>创建时间：2018-11-05</para>
/// </summary>
/// <param name="firstTime">首次上课时间</param>
/// <returns>获取排课最大课次</returns>
/// <exception cref="BussinessException">
/// 异常ID：1 异常描述：学期信息为空
/// </exception>
public int GetMaximumLessonByFirstTime(DateTime firstTime)
{
int maximumLesson = 0;
//1.获取学期信息
var termInfo = TermService.GetTermByTermId(TblDatClass.TermId);
if (termInfo == null)
{
throw new BussinessException(ModelType.Default, 1);
}
//获取停课日
List <SchoolHolidayResponse> schoolHoliday = TermService.GetSchoolHoliday(termInfo);
//首次上课时间大于学期结束时间则没有课次
if (firstTime > termInfo.EndDate)
{
return(maximumLesson);
}
//首次上课时间小于学期开始时间则以学期开始时间为准
if (firstTime < termInfo.BeginDate)
{
firstTime = termInfo.BeginDate;
}
bool isStandard180 = this.IsStandard180(ClassSchoolTimes); //180分钟
TimeType duration = (TimeType)ClassSchoolTimes.FirstOrDefault().Duration; //时长
while (firstTime <= termInfo.EndDate)
{
//判断停课日
bool isClosed = SchoolHolidayService.TodayIsSuspendClasses(schoolHoliday, firstTime);
if (isClosed)
{
firstTime = firstTime.AddDays(1);
continue;
}
//执行60分钟标准
if (duration == TimeType.Sixty && maximumLesson == termInfo.Classes60)
{
return(maximumLesson);
}
//执行90分钟标准
else if (duration == TimeType.Ninety && !isStandard180 && maximumLesson == termInfo.Classes90)
{
return(maximumLesson);
}
//执行180分钟标准
else if (duration == TimeType.Ninety && isStandard180 && maximumLesson >= termInfo.Classes180)
{
//180分钟标准由90分钟标准构成
//180分钟标准设置可能会是奇数
//最大课次排课超过标准,则按标准执行
if (maximumLesson > termInfo.Classes180)
{
return(termInfo.Classes180);
}
break;
}
int weekDay = WeekDayConvert.DayOfWeekToInt(firstTime);
int lessonCount = ClassSchoolTimes.Count(x => x.WeekDay == weekDay);
maximumLesson += lessonCount;
firstTime = firstTime.AddDays(1);
}
return(maximumLesson);
}
/// <summary>
/// 获取排课课次信息列表
/// <para>作 者：zhiwei.Tang</para>
/// <para>创建时间：2019-02-19</para>
/// </summary>
/// <returns>课次信息列表</returns>
public List <LessonCreatorInfo> GetLessonCreatorInfo()
{
List <LessonCreatorInfo> res = new List <LessonCreatorInfo>();
//校验排课信息是否为空
ValidateObject(_makeLesson);
if (_makeLesson.IsConfirm)
{
throw new BussinessException(ModelType.SignUp, 9);
}
//1.获取学期信息
var termInfo = TermService.GetTermByTermId(_classService.TblDatClass.TermId);
ValidateObject(termInfo);
//订单明细
TblOdrEnrollOrderItem orderItem =
_enrollOrderItemRepository.Load(_makeLesson.EnrollOrderItemId);
//订单
TblOdrEnrollOrder order =
_enrollOrderRepository.Load(orderItem.EnrollOrderId);
//2.获取停课日
List <SchoolHolidayResponse> schoolHoliday = TermService.GetSchoolHoliday(termInfo);
//上课时间
DateTime classDate = _makeLesson.FirstClassTime;
//首次上课日期大于学期结束日期则没有课次
if (classDate > termInfo.EndDate)
{
return(res);
}
//首次上课日期未到学期开始时间取学期设置开始日期
if (classDate < termInfo.BeginDate)
{
classDate = termInfo.BeginDate;
}
bool isStandard180 = this.IsStandard180(_classService.ClassSchoolTimes); //180分钟
TimeType duration = (TimeType)_classService.ClassSchoolTimes.FirstOrDefault().Duration; //时长
int standard180 = termInfo.Classes180; //设置180分钟标准
int makeLessonTotal = _makeLesson.ClassTimes; //设置排课总数
if (isStandard180)
{
//180分钟设置的标准是否是奇数
bool class180IsOddNumber = Convert.ToBoolean(termInfo.Classes180 % 2);
standard180 = class180IsOddNumber ? termInfo.Classes180 - 1 : termInfo.Classes180;
//排课是否是奇数
bool makeIsOddNumber = Convert.ToBoolean(_makeLesson.ClassTimes % 2);
//报名课次数量 考虑180分钟排2个课次的完整性
makeLessonTotal = makeIsOddNumber ? _makeLesson.ClassTimes - 1 : _makeLesson.ClassTimes;
}
//上课日期大于学期结束日期停止排课
while (classDate <= termInfo.EndDate)
{
//当天是否停课
bool isClosed = SchoolHolidayService.TodayIsSuspendClasses(schoolHoliday, classDate);
if (isClosed)
{
classDate = classDate.AddDays(1);
continue;
}
int week = WeekDayConvert.DayOfWeekToInt(classDate);
List <TblDatSchoolTime> classTimes = _classService.ClassSchoolTimes
.Where(x => x.WeekDay == week)
.OrderBy(x => x.BeginTime)
.ToList();
//处理上课时间发生变化
var changeTimes = _viewChangeClassTimeDates
.Where(x => x.OldClassDate == classDate)
.OrderBy(x => x.NewClassBeginTime)
.ToList();
if (!classTimes.Any() && !changeTimes.Any())
{
classDate = classDate.AddDays(1);
continue;
}
//180分钟课程
if (duration == TimeType.Ninety && isStandard180 == true)
{
if (!changeTimes.Any())
{
var ct1 = classTimes[0];
var ct2 = classTimes[1];
res.Add(this.GetCreatorInfo(classDate, ct1.BeginTime, ct1.EndTime, termInfo.SchoolId, order.StudentId, termInfo.TermId));
res.Add(this.GetCreatorInfo(classDate, ct2.BeginTime, ct2.EndTime, termInfo.SchoolId, order.StudentId, termInfo.TermId));
}
else
{
var ct1 = changeTimes[0];
var ct2 = changeTimes[1];
res.Add(this.GetCreatorInfo(ct1.NewClassDate, ct1.NewClassBeginTime, ct1.NewClassEndTime, termInfo.SchoolId, order.StudentId, termInfo.TermId));
res.Add(this.GetCreatorInfo(ct2.NewClassDate, ct2.NewClassBeginTime, ct2.NewClassEndTime, termInfo.SchoolId, order.StudentId, termInfo.TermId));
}
_lessonCount += 2;
}
else
{
if (!changeTimes.Any())
{
var ct1 = classTimes[0];
res.Add(this.GetCreatorInfo(classDate, ct1.BeginTime, ct1.EndTime, termInfo.SchoolId, order.StudentId, termInfo.TermId));
}
else
{
var ct1 = changeTimes[0];
res.Add(this.GetCreatorInfo(ct1.NewClassDate, ct1.NewClassBeginTime, ct1.NewClassEndTime, termInfo.SchoolId, order.StudentId, termInfo.TermId));
}
_lessonCount += 1;
}
//上课时间大于学期结束时间停止排课或者预计排课课次等于实际排课课次停止排课
if (this._lessonCount == makeLessonTotal)
{
return(res);
}
//执行60分钟标准
else if (duration == TimeType.Sixty && this._lessonCount == termInfo.Classes60)
{
return(res);
}
//执行90分钟标准
else if (duration == TimeType.Ninety && isStandard180 == false && this._lessonCount == termInfo.Classes90)
{
return(res);
}
//执行180分钟标准
else if (duration == TimeType.Ninety && isStandard180 == true && this._lessonCount == standard180)
{
return(res);
}
classDate = classDate.AddDays(1);
}
return(res);
}
/// <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>创建时间：2019-03-15</para>
/// </summary>
/// <param name="studentLessonList">学生课次信息</param>
/// <param name="teacherInfoList">老师信息</param>
/// <param name="notAttendStatusList">未考勤集合</param>
/// <param name="replenishLessonList">学生补课信息</param>
/// <returns>学生考勤课程信息</returns>
private List <StudentAttendLessonResponse> GetStudentAttendLessonList(IEnumerable <ViewStudentAttendance> studentLessonList,
List <ClassTimetableTeacherResponse> teacherInfoList,
List <int> notAttendStatusList,
IEnumerable <ViewTimReplenishLessonStudent> replenishLessonList)
{
string classTime = string.Empty; //上课时间
string teacherName = string.Empty; //老师名称
string replenishTips = string.Empty; //补课/调课提示
List <StudentAttendLessonResponse> lessonList = studentLessonList.OrderBy(x => x.LessonType).ThenBy(y => y.ClassDate)
.GroupBy(g => new { g.ClassDate, g.LessonType, g.AttendStatus, g.AdjustType, g.BusinessType, g.ProcessStatus })
.Select(b =>
{
var studentLessonDateList = studentLessonList.Where(x => x.ClassDate == b.Key.ClassDate); //上课日期对应的课程信息
var replenhishList = replenishLessonList.Where(a => studentLessonDateList.Select(s => s.LessonId).Contains(a.RootLessonId)); //补课信息
replenishTips = string.Empty; //补课/调课提示
if (replenhishList.Any())
{
var replenishLesson = replenhishList.FirstOrDefault();
classTime = string.Join("，", replenhishList.OrderBy(o => o.ClassBeginTime).Select(x => $"{x.ClassBeginTime}-{x.ClassEndTime}").Distinct());
teacherName = teacherInfoList.FirstOrDefault(a => a.TeacherId == replenishLessonList.FirstOrDefault().TeacherId)?.TeacherName;
replenishTips = $"{replenishLesson?.ClassDate.ToString("yyyy-MM-dd")} {WeekDayConvert.DayOfWeekToString(replenishLesson.ClassDate.DayOfWeek)}（{classTime}）{teacherName}老师补课";
}
var lessonCount = studentLessonList.Where(x => x.ClassDate == b.Key.ClassDate).Sum(y => y.LessonCount);
return(new StudentAttendLessonResponse()
{
LessonDate = b.Key.ClassDate.ToString("MM/dd"), //课次日期
LessonType = (LessonType)b.Key.LessonType, //1表示常规课；2表示写生课
LessonCount = lessonCount, //课次：一般情况下常规课是1节，写生课是4节
AttendStatus = notAttendStatusList.Contains(b.Key.AttendStatus ?? 0) ? 0 : 1, //考勤状态：0表示学生未考勤；1表示学生已考勤；
ReplenishStatus = (b.Key.AdjustType == (int)AdjustType.DEFAULT ? 0 : 1), //是否补课调课
ReplenishLessonTips = replenishTips,
StatusName = (b.Key.AttendStatus == (int)LessonStatus.Attended ? lessonCount.ToString()
: (b.Key.ProcessStatus == (int)ProcessStatus.End ? GetStatusNameByProcessStatus(b.Key.BusinessType ?? 0) : "")) //状态名称
});
}).ToList();
return(lessonList);
}
/// <summary>
/// 获取教室查看课表
/// <para>作 者：zhiwei.Tang</para>
/// <para>创建时间：2018-11-06</para>
/// </summary>
/// <param name="termId">学期Id</param>
/// <param name="companyId">公司编号</param>
/// <returns>教室查看课表数据列表</returns>
public async Task <List <ClassRoomCourseTimetableResponse> > GetCourseTimetable(long termId, string companyId)
{
List <ClassRoomCourseTimetableResponse> res = new List <ClassRoomCourseTimetableResponse>();
//1.获取教室下有哪些班级
List <TblDatClass> classes = _classRepository.Value.GetClassByTermIdAsync(termId)
.Result
.Where(x => x.ClassRoomId == _classRoomId)
.ToList();
//2.获取班级上课时间
List <TblTimClassTime> classTimes = await _classTimeRepository.Value.GetByClassId(classes.Select(x => x.ClassId));
//3.获取基础数据
//3.1 课程
List <TblDatCourse> courses = CourseService.GetAllAsync().Result;
//3.2 课程等级
List <CourseLevelResponse> courseLevels = new CourseLevelService(companyId).GetList().Result;
//3.3 获取老师
List <ClassTimetableTeacherResponse> teachers = TeachService.GetTeachers();
//3.4.获取上课时间段基础数据
List <TblDatSchoolTime> schoolTimes = new SchoolTimeService(termId).TblDatSchoolTime;
int maxLength = 0;
//4.整合数据
for (int i = 1; i <= 7; i++)
{
ClassRoomCourseTimetableResponse classRoom = new ClassRoomCourseTimetableResponse
{
Week = WeekDayConvert.IntToString(i),
ClassTimes = new List <ClassRoomClassTime>()
};
var cts = (from a in classTimes //教室下的班级上课时间段
join b in classes on a.ClassId equals b.ClassId //教室下的班级
join c in schoolTimes on a.SchoolTimeId equals c.SchoolTimeId //基础数据 学期下所有上课时间段
join d in courseLevels on b.CourseLeveId equals d.CourseLevelId //基础数据 课程等级
join e in courses on b.CourseId equals e.CourseId //基础数据 课程
join f in teachers on b.TeacherId equals f.TeacherId //基础数据 老师信息
where c.WeekDay == i
select new ClassRoomClassTime
{
BeginTime = c.BeginTime,
EndTime = c.EndTime,
CourseName = e.ShortName,
LevelCnName = d.LevelCnName,
TeacherName = f.TeacherName
}).OrderBy(x => x.BeginTime);
classRoom.ClassTimes.AddRange(cts);
if (cts.Count() > maxLength)
{
maxLength = cts.Count();
}
res.Add(classRoom);
}
//补齐
foreach (var item in res)
{
if (item.ClassTimes.Count >= maxLength)
{
continue;
}
while (item.ClassTimes.Count < maxLength)
{
item.ClassTimes.Add(new ClassRoomClassTime());
}
}
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-11-23</para>
/// </summary>
/// <param name="request">待添加的班级信息</param>
/// <param name="autClass">审核中的班级</param>
/// <param name="hasBeenClassTimeIds">一组已排课的上课时间Id</param>
/// <param name="schoolTimeId">要添加的上课时间段Id</param>
/// <returns>班级上课时间列表</returns>
/// <exception cref="BussinessException">
/// 异常ID:2,异常描述：没有此时间段;时间段已占用;不能与下一个时间段连上;下一个时间段已排课;
/// </exception>
private static List <TblAutClassTime> GetTblAutClassTimes(ClassScheduleRequest request, TblAutClass autClass, List <long> hasBeenClassTimeIds, long schoolTimeId)
{
List <TblAutClassTime> res = new List <TblAutClassTime>();
List <TblDatSchoolTime> schoolTimes = new SchoolTimeService(autClass.TermId)
.TblDatSchoolTime
.OrderBy(x => x.BeginTime)
.ToList();
TblDatSchoolTime schoolTime = schoolTimes.FirstOrDefault(x => x.SchoolTimeId == schoolTimeId);
ValidateObject(schoolTime);
foreach (var weekDay in request.WeekDay)
{
var dayAllClassTime = schoolTimes
.Where(x => x.WeekDay == weekDay && x.Duration == schoolTime.Duration)
.OrderBy(x => x.BeginTime)
.ToList();
var firstClassTime = dayAllClassTime.FirstOrDefault(x => x.BeginTime == schoolTime.BeginTime && x.EndTime == schoolTime.EndTime);
if (firstClassTime == null)
{
throw new BussinessException(ModelType.Default, 2, $"{WeekDayConvert.IntToString(weekDay)}没有此时间段");
}
//判断是否有排课
if (hasBeenClassTimeIds.Any(x => x == firstClassTime.SchoolTimeId))
{
throw new BussinessException(ModelType.Default, 2, $"{WeekDayConvert.IntToString(weekDay)}时间段已占用");
}
res.Add(new TblAutClassTime
{
AutClassTimeId = IdGenerator.NextId(),
SchoolId = autClass.SchoolId,
ClassTimeId = IdGenerator.NextId(),
AuditId = autClass.AuditId,
ClassId = autClass.ClassId,
CreateTime = DateTime.Now,
DataStatus = 0,
SchoolTimeId = firstClassTime.SchoolTimeId
});
if (schoolTime.Duration == (int)TimeType.Ninety && request.IsLink)
{
int firstIndex = dayAllClassTime.IndexOf(firstClassTime);
int secondIndex = firstIndex + 1;
//最后一个时间段
if (secondIndex >= dayAllClassTime.Count)
{
throw new BussinessException(ModelType.Default, 2, $"{WeekDayConvert.IntToString(weekDay)}不能与下一个时间段连上");
}
var secondClassTime = dayAllClassTime[secondIndex];
//判断是否有排课
if (hasBeenClassTimeIds.Any(x => x == secondClassTime.SchoolTimeId))
{
throw new BussinessException(ModelType.Default, 2, $"{WeekDayConvert.IntToString(weekDay)}下一个时间段已排课");
}
res.Add(new TblAutClassTime
{
AutClassTimeId = IdGenerator.NextId(),
ClassTimeId = IdGenerator.NextId(),
AuditId = autClass.AuditId,
ClassId = autClass.ClassId,
CreateTime = DateTime.Now,
DataStatus = 0,
SchoolId = autClass.SchoolId,
SchoolTimeId = secondClassTime.SchoolTimeId
});
}
}
return(res);
}
/// <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;
}
}
}
}
