/// <summary>
/// 校验老师在同一时间段不同教室是否存在
/// <para>作 者：zhiwei.Tang</para>
/// <para>创建时间：2019-02-20</para>
/// </summary>
/// <param name="schoolTimeId">时间段</param>
/// <param name="notClassId">排除的班级Id</param>
/// <param name="duration">时长</param>
/// <param name="teacherId">老师Id</param>
/// <param name="termId">学期Id</param>
/// <exception cref="BussinessException">
/// 异常ID：10,异常描述：老师上课时间冲突
/// </exception>
private static void VerifyTeacherOccupy(IEnumerable <long> inputSchoolTimeId, string teacherId, long termId)
{
//1.获取老师上课段
TermCourseTimetableAuditService termCourseTimetableAuditService = new TermCourseTimetableAuditService(termId);
List <long> teacherClassTimes = termCourseTimetableAuditService.GetAutClassTime(teacherId)
.Select(x => x.SchoolTimeId)
.ToList();
if (!teacherClassTimes.Any())
{
return; //该老师未排课
}
//2.获取重叠的上课时间段
var termSchoolTimes = new SchoolTimeService(termCourseTimetableAuditService._termId).TblDatSchoolTime.ToList();
List <long> overlappingSchoolTime = OverlappingSchoolTime(termSchoolTimes, inputSchoolTimeId);
//3.比较
var intersectedList = teacherClassTimes.Intersect(overlappingSchoolTime);
if (intersectedList.Any())
{
throw new BussinessException(ModelType.Timetable, 10); //老师上课时间冲突
}
}
/// <summary>
/// 获取拼接好的上课时间数据
/// <para>作 者:Huang GaoLiang </para>
/// <para>创建时间：2018-11-02 </para>
/// </summary>
/// <param name="classId">编辑编号</param>
/// <returns>获取上课时间字符串</returns>
private static string GetSchoolTime(long classId)
{
// 1、根据班级编号，获取班级中的上课时间编号
List <long> schoolTimeIds = new TimClassTimeService(classId).GetSchoolTimeIds();
// 2、根据上课时间段编号，获取上课时间表
List <TblDatSchoolTime> schoolTimeList = SchoolTimeService.GetBySchoolTimeIds(schoolTimeIds).Select(m => new TblDatSchoolTime
{
WeekDay = m.WeekDay,
BeginTime = m.BeginTime,
EndTime = m.EndTime
}).ToList();
// 星期
string week = string.Join("、", schoolTimeList.Select(m => EnumName.GetDescription(typeof(Week), m.WeekDay)).Distinct());
schoolTimeList = schoolTimeList.Where((x, i) => schoolTimeList.FindIndex(z => z.BeginTime == x.BeginTime) == i).ToList();
string classTime = string.Empty;
foreach (TblDatSchoolTime s in schoolTimeList)
{
classTime += $"{s.BeginTime}-{s.EndTime}，";
}
classTime = $"{week}（{classTime.TrimEnd('，')}）";
return(classTime);
}
/// <summary>
/// 修改班级课表
/// <para>作 者：zhiwei.Tang</para>
/// <para>创建时间：2018-09-25</para>
/// </summary>
/// <param name="classId">班级Id</param>
/// <param name="request">学期班级排课课表修改</param>
/// <param name="createUserName">创建人用户名称</param>
/// <returns></returns>
public async Task ModifyClassAsync(long classId, EditClassScheduleRequest request, string createUserName)
{
//1.校验并获取审核Id
long auditId = VerifyGetAuditId(base.TblAutAudit.SchoolId);
//2.获取待修改的班级
var waitEditClass = await _tblAutClassRepository.Value.GetAsync(auditId, classId);
if (waitEditClass == null)
{
throw new BussinessException(ModelType.Default, 1);
}
//3.判断老师是否修改,有则校验老师上课时间段是否冲突
if (waitEditClass.TeacherId != request.TeacherId)
{
var classTime = _tblAutClassTimeRepository.Value.GetByClassId(auditId, classId).Result.Select(x => x.SchoolTimeId);
TblDatSchoolTime schoolTime = SchoolTimeService.GetBySchoolTimeId(classTime.FirstOrDefault());
//校验老师是否重复
VerifyTeacherOccupy(classTime, request.TeacherId, schoolTime.TermId);
}
//4.准备数据
waitEditClass.CourseId = request.CourseId;
waitEditClass.CourseLeveId = request.CourseLevelId;
waitEditClass.ClassNo = request.ClassNo;
waitEditClass.TeacherId = request.TeacherId;
waitEditClass.CourseNum = request.CourseNum;
waitEditClass.StudentsNum = request.StudentsNum;
//5.写入更新的班级数据
await _tblAutClassRepository.Value.UpdateTask(waitEditClass);
}
/// <summary>
///描述： 获取班级上课的时间段
///<para>作者：瞿琦</para>
///<para>创建时间：2019-3-16</para>
/// </summary>
/// <param name="classId">班级Id</param>
/// <returns>上课时间段列表</returns>
private List <TblDatSchoolTime> GetClassTimesList(long classId)
{
//班级上课时间
var classTimesList = new TimClassTimeService(classId).GetSchoolTimeIds();
var schoolTimeList = SchoolTimeService.GetBySchoolTimeIds(classTimesList);
return(schoolTimeList);
}
/// <summary>
/// 待添加到审核中班级
/// <para>作 者：zhiwei.Tang</para>
/// <para>创建时间：2019-02-19</para>
/// </summary>
/// <param name="input">待添加的班级信息</param>
/// <param name="classRoomId">教室Id</param>
/// <param name="schoolTimeId">上课时间段Id</param>
/// <param name="createUserName">创建人</param>
/// <returns>审核中的班级课表信息</returns>
private static TblAutClass GetTblAutClass(ClassScheduleRequest input, long classRoomId, long schoolTimeId, string createUserName)
{
//教室信息
var classRoom = new ClassRoomService(classRoomId).ClassRoomInfo;
ValidateObject(classRoom);
//上课时间信息
var schoolTime = SchoolTimeService.GetBySchoolTimeId(schoolTimeId);
ValidateObject(schoolTime);
//根据学期编号获取学期信息
TblDatTerm term = TermService.GetTermByTermId(schoolTime.TermId);
ValidateObject(term);
//获取课程
TblDatRoomCourse roomCourse = new ClassRoomService(classRoomId).GetByCourseId(input.CourseId).Result;
ValidateObject(roomCourse);
//复制课表到审核中得到审核主表id
long auditId = new TermCourseTimetableAuditService(schoolTime.TermId).VerifyGetAuditId(classRoom.SchoolId);
TblAutClass autClass = new TblAutClass
{
AutClassId = IdGenerator.NextId(),
SchoolId = classRoom.SchoolId,
ClassId = IdGenerator.NextId(),
AuditId = auditId,
ClassNo = input.ClassNo,
TermId = term.TermId,
RoomCourseId = roomCourse.RoomCourseId,
ClassRoomId = classRoomId,
CourseId = roomCourse.CourseId,
CourseLeveId = input.CourseLevelId,
TeacherId = input.TeacherId,
CourseNum = input.CourseNum,
StudentsNum = input.StudentsNum,
CreateTime = DateTime.Now,
UpdateTime = DateTime.Now,
DataStatus = 0
};
return(autClass);
}
/// <summary>
/// 描述：删除学期
/// <para>作 者：瞿琦</para>
/// <para>创建时间：2018-11-7</para>
/// </summary>
/// <param name="termId">学期Id</param>
/// <returns>无</returns>
/// <exception cref="AMS.Core.BussinessException">
/// 异常ID：10, 异常描述:本学期已被占用，不可删除
/// 异常ID：12, 异常描述:当前数据已在审核中，不能删除
/// </exception>
public void DeleteTerm(long termId)
{
//3.上课时间段
var schoolTimeService = new SchoolTimeService(termId);
var schoolTimeList = schoolTimeService.TblDatSchoolTime;
if (schoolTimeList.Any()) //classList.Any() || || auditClassService.IsAuditing
{
throw new BussinessException((byte)ModelType.Datum, 10); //, "本学期已被占用，不可删除。"
}
if (_auditService.IsAuditing)
{
throw new BussinessException((byte)ModelType.Audit, 12); //, "审核中的数据不可以删除。"
}
//_auditService.RemoveTerm(termId); //如果有,则移除审核中的学期信息
}
/// <summary>
/// 获取未安排课表的班级课表信息
/// <para>作 者：zhiwei.Tang</para>
/// <para>创建时间：2018-11-06</para>
/// </summary>
/// <param name="classRoomId">教室ID</param>
/// <param name="schoolTimeId">时间段ID</param>
/// <returns>课次表详情</returns>
public static ClassTimetableResponse GetNoClassTimetable(long classRoomId, long schoolTimeId)
{
ClassTimetableResponse res = new ClassTimetableResponse
{
IsClassJoin = false
};
SchoolTimeService service = SchoolTimeService.CreateSchoolTimeService(schoolTimeId);
List <TblDatSchoolTime> allSchoolTimes = service.TblDatSchoolTime;
TblDatTerm term = service.TblDatTerm;
//获取当前时间段
var firstTime = allSchoolTimes.FirstOrDefault(x => x.SchoolTimeId == schoolTimeId);
//第一节课时间段
res.Time1 = new List <string> {
firstTime.BeginTime, firstTime.EndTime
};
//上课老师
res.Teacher = TeachService.GetIncumbentTeachers(term.SchoolId);
//当前教室门牌号
res.RoomNo = new SchoolClassRoomService(term.SchoolId).GetClassRoom(classRoomId)?.RoomNo;
//课程与课程等级
res.ClassTimetableCourse = GetClassTimetableCourseResponse(term.SchoolId, classRoomId);
ClassTimetableSchoolTimeResult classTimetableSchoolTimeResult = GetClassTimetableSchoolTimeResult(allSchoolTimes, classRoomId, schoolTimeId, term.TermId);
//星期几与上课时间的数据
res.WeekDaySchoolTimes = classTimetableSchoolTimeResult
.WeekDaySchoolTimes
.OrderBy(m => m.WeekDay).ToList();
res.CanClassJoin = classTimetableSchoolTimeResult.CanClassJoin;
//第二节课时间段
res.Time2 = classTimetableSchoolTimeResult.Time2;
return(res);
}
/// <summary>
/// 获取已排课的时间段
/// <para>作 者：zhiwei.Tang</para>
/// <para>创建时间：2018-11-06</para>
/// </summary>
/// <param name="classRooms">教室列表数据</param>
/// <param name="termId">学期Id</param>
/// <returns>上课时间段列表</returns>
private static List <TblDatSchoolTime> GetScheduledTimes(List <TimetableClassRoomResponse> classRooms, long termId)
{
List <TblDatSchoolTime> res = new List <TblDatSchoolTime>();
List <TblDatSchoolTime> schoolTimes = new SchoolTimeService(termId).TblDatSchoolTime;
foreach (var classRoom in classRooms) //教室
{
foreach (var @class in classRoom.Classes) //班级
{
if (@class.ClassId != 0)
{
if (!res.Any(x => x.SchoolTimeId == @class.SchoolTimeId))
{
res.Add(schoolTimes.FirstOrDefault(x => x.SchoolTimeId == @class.SchoolTimeId));
}
}
}
}
return(res.OrderBy(x => x.WeekDay).ThenBy(x => x.BeginTime).ToList());
}
/// <summary>
/// 根据班级编号，获取班级上课时间信息
/// <para>作 者:Huang GaoLiang </para>
/// <para>创建时间：2018-11-02 </para>
/// </summary>
/// <param name="classId">班级编号</param>
/// <returns>返回班级上课信息集合</returns>
private static List <SchoolTime> GetDatSchoolTimeInfo(long classId)
{
List <SchoolTime> tiems = new List <SchoolTime>();
//1、根据班级编号，获取班级上课时间表中的上课时间段
List <long> schoolTimeIds = new TimClassTimeService(classId).GetSchoolTimeIds();
//2、根据上课时间段编号，获取上课时间表
List <TblDatSchoolTime> schoolTimeList = SchoolTimeService.GetBySchoolTimeIds(schoolTimeIds);
//3、返回数据
foreach (TblDatSchoolTime s in schoolTimeList)
{
SchoolTime time = new SchoolTime();
time.SchoolTimeId = s.SchoolTimeId;
time.WeekDay = s.WeekDay;
time.BeginTime = s.BeginTime;
time.EndTime = s.EndTime;
tiems.Add(time);
}
return(tiems);
}
/// <summary>
/// 获取已安排课表的班级课表信息
/// <para>作 者：zhiwei.Tang</para>
/// <para>创建时间：2018-11-06</para>
/// </summary>
/// <remarks>课程表班级的详情信息</remarks>
/// <exception cref="BussinessException">
/// 异常ID：1，异常描述：班级信息为空
/// </exception>
private ClassTimetableResponse GetClassTimetable()
{
//获取班级
var classInfo = this.GetClass();
if (classInfo == null)
{
throw new BussinessException(ModelType.Default, 1);
}
//基础数据
ClassTimetableResponse res = new ClassTimetableResponse()
{
ClassNo = classInfo.ClassNo,
CourseId = classInfo.CourseId,
CourseLevelId = classInfo.CourseLeveId,
CourseNum = classInfo.CourseNum,
StudentsNum = classInfo.StudentsNum,
TeaherId = classInfo.TeacherId,
CanClassJoin = false,
WeekDaySchoolTimes = new List <ClassTimetableSchoolTimeResponse>()
};
SchoolTimeService schoolTimeService = new SchoolTimeService(classInfo.TermId);
//获取学期信息
TblDatTerm term = schoolTimeService.TblDatTerm;
//这个学期所有的上课时间
var allTermClassTime = schoolTimeService.TblDatSchoolTime.OrderBy(x => x.BeginTime).ToList();
//校区老师
res.Teacher = TeachService.GetIncumbentTeachers(term.SchoolId, classInfo.TeacherId);
//课程信息与课程等级
res.ClassTimetableCourse = GetClassTimetableCourseResponse(term.SchoolId, classInfo.ClassRoomId, classInfo.CourseId);
//当前教室门牌号
res.RoomNo = new SchoolClassRoomService(term.SchoolId).GetClassRoom(classInfo.ClassRoomId)?.RoomNo;
var timClassTime = _classTimeRepository.Value.GetByClassId(classInfo.ClassId);
//当前班级对应的上课时间段
var currentClassTimes = allTermClassTime
.Where(m => timClassTime.Select(x => x.SchoolTimeId).Contains(m.SchoolTimeId))
.OrderBy(x => x.BeginTime).ToList();
//班级第一个时间段
var firstClassTime = currentClassTimes[0];
res.Time1 = new List <string> {
firstClassTime.BeginTime, firstClassTime.EndTime
};
res.Time2 = new List <string>();
var isJoinClass = currentClassTimes.Where(x => x.WeekDay == firstClassTime.WeekDay).OrderBy(x => x.BeginTime).ToList();
//班级第二个时间段
if (isJoinClass.Count > 1)
{
var secondClassTime = isJoinClass[1];
res.Time2 = new List <string> {
secondClassTime.BeginTime, secondClassTime.EndTime
};
res.IsClassJoin = true;
}
//星期几与上课时间的数据
for (int i = 1; i <= 7; i++)
{
var classTime = currentClassTimes.Where(x => x.WeekDay == i).ToList();
ClassTimetableSchoolTimeResponse ctst = new ClassTimetableSchoolTimeResponse
{
HasSchoolTime1 = false,
SchoolTimeId1 = 0,
HasSchoolTime2 = false,
SchoolTimeId2 = 0,
IsChecked = false,
WeekDay = i
};
if (classTime.Any())
{
ctst.HasSchoolTime1 = true;
ctst.SchoolTimeId1 = classTime[0].SchoolTimeId;
ctst.IsChecked = true;
if (classTime.Count > 1)
{
ctst.HasSchoolTime2 = true;
ctst.SchoolTimeId2 = classTime[1].SchoolTimeId;
}
}
res.WeekDaySchoolTimes.Add(ctst);
}
return(res);
}
/// <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>作 者：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);
}
