/// <summary>
/// Deletes a lesson.
/// </summary>
/// <param name="id">The lesson identifier.</param>
/// <param name="accountId">The account identifier.</param>
/// <returns>The result.</returns>
public ResultDto DeleteLesson(Guid id, Guid accountId)
{
ResultDto result = new ResultDto();
using (BzsEntityContainer ctx = this.CreateContainer())
{
LessonEntity entity = ctx.LessonSet.FirstOrDefault(f => f.Id == id);
if (entity == null)
{
result.Error = "ERR-LESSON-NOT-EXISTS";
return(result);
}
if (entity.AccountId != accountId)
{
result.Error = "ERR-LESSON-ACCOUNT-INVALID";
return(result);
}
ctx.LessonSet.Remove(entity);
ctx.SaveChanges();
result.Success = true;
return(result);
}
}
private DataGridColumn BuildStudentLessonColumn(string id, LessonEntity entity)
{
var dataGridTemplateColumn =
new TextColumn {
Width = new DataGridLength(90),
MinWidth = 50,
Header = new TextBlock {
Text = Localization["common.lesson.type." + entity.LessonType] + "\n " +
entity.Date?.ToString("dd.MM"),
Foreground = entity.Id == _currentLesson.Id ? Brushes.Red : Brushes.Black
},
Binding = new Binding {
Path = new PropertyPath($"LessonToLessonMark[{id}].Mark")
},
CanUserSort = false
};
var cellStyle = new Style {
BasedOn = DataGridCellResources["StudentLessonMarkCell"] as Style,
TargetType = typeof(DataGridCell)
};
var backGround = new Setter(Control.BackgroundProperty, new Binding($"LessonToLessonMark[{id}].Color"));
var menu = new Setter(FrameworkElement.ContextMenuProperty, BuildLessonCellContextMenu(id));
cellStyle.Setters.Add(backGround);
cellStyle.Setters.Add(menu);
dataGridTemplateColumn.CellStyle = cellStyle;
return(dataGridTemplateColumn);
}
private async void Init(LessonEntity lesson)
{
if (lesson == null)
{
return;
}
this.Lesson = await _db.Lessons.FindAsync(lesson.Id) ?? lesson.Clone();
StopTimer();
this.LessonStudents.Clear();
this.RegisteredStudents.Clear();
var loadedStudentLessons = lesson.StudentLessons?.ToList() ?? new List <StudentLessonEntity>();
AddMissingStudents(loadedStudentLessons, this.Lesson);
_studentLessons = loadedStudentLessons
.Select(entity => new StudentLessonInfoViewModel(entity, AddStudentNote, ShowStudent)).ToList();
var notRegisteredStudentLessons =
_studentLessons.Where(lessonModel => !(lessonModel.StudentLesson.IsRegistered ?? false)).ToList();
this.LessonStudents.AddRange(notRegisteredStudentLessons);
var registeredStudentLesson =
_studentLessons.Where(lessonModel => lessonModel.StudentLesson.IsRegistered == true).ToList();
this.RegisteredStudents.AddRange(registeredStudentLesson);
_internalStudentLessons = FindInternalStudents(_studentLessons, lesson);
this.IsLessonChecked = lesson.Checked;
UpdateRegistrationInfo();
StartTimer(this.Lesson);
}
/// <summary>
/// Updates a lesson.
/// </summary>
/// <param name="itemToSave">The item to save.</param>
/// <param name="accountId">The account identifier.</param>
/// <returns>The result.</returns>
public ResultDto UpdateLesson(LessonEditDto itemToSave, Guid accountId)
{
ResultDto result = new ResultDto();
using (BzsEntityContainer ctx = this.CreateContainer())
{
LessonEntity entity = ctx.LessonSet.FirstOrDefault(f => f.Id == itemToSave.Id);
if (entity == null)
{
result.Error = "ERR-LESSON-NOT-EXISTS";
return(result);
}
if (entity.AccountId != accountId)
{
result.Error = "ERR-LESSON-ACCOUNT-INVALID";
return(result);
}
entity.DayId = itemToSave.DayId;
entity.FromDate = DateTimeHelper.StringToDateTime(itemToSave.FromDate);
entity.ToDate = DateTimeHelper.StringToDateTime(itemToSave.ToDate);
entity.SubjectId = itemToSave.SubjectId;
entity.TeacherId = itemToSave.TeacherId;
entity.RoomId = itemToSave.RoomId;
entity.Remark = itemToSave.Remark;
entity.ModDate = DateTime.Now;
entity.ModUser = Environment.UserName;
ctx.SaveChanges();
result.Success = true;
return(result);
}
}
private async void Init(LessonEntity lesson)
{
_items.Clear();
this.Columns.Clear();
_currentLesson = lesson;
List <LessonEntity> lessonModels;
lessonModels = lesson.Group == null
? await _db.Lessons.Include("StudentLessons").Where(model =>
model._StreamId == lesson._StreamId && (model._GroupId == null || model._GroupId == 0))
.ToListAsync()
: await _db.Lessons
.Include("StudentLessons")
.Where(model => model._GroupId == lesson._GroupId ||
(model._StreamId == lesson._StreamId &&
!model._GroupId.HasValue))
.ToListAsync();
lessonModels.Reverse();
foreach (var lessonModel in lessonModels)
{
var lessonId = IdGenerator.GenerateId();
this.Lessons.Add(lessonId, lessonModel);
this.Columns.Add(BuildStudentLessonColumn(lessonId, lessonModel));
}
var studentModels = ((lesson.Group == null
? lesson.Stream.Groups?.SelectMany(group =>
group.Students ?? new List <StudentEntity>())
: lesson.Group.Students?.ToList()) ?? new List <StudentEntity>())
.Select(model => new StudentLessonViewModel(model, this.Lessons, _scope, _host, _db))
.OrderBy(view => view.FullName).ToList();
_items.AddRange(studentModels);
}
private async Task AddExam()
{
var schedules = await _context.Schedules.ToListAsync();
var lesson = new LessonEntity();
var now = DateTime.Now;
var time = now.TimeOfDay;
var examSchedule =
schedules.OrderBy(model => model.Begin)
.FirstOrDefault
(
schedule =>
schedule.Begin > time || (schedule.Begin <time && schedule.End> time)
);
lesson.Schedule = examSchedule;
lesson.Date = now;
lesson.LessonType = LessonType.Exam;
lesson.Stream = this.SelectedStream;
lesson.Group = this.SelectedGroup;
lesson._Order = this.StudentExams.Count + 1;
lesson.CreationDate = now;
lesson._Checked = 0;
_context.Lessons.Add(lesson);
await _context.SaveChangesAsync();
if (this.SelectedGroup != null)
{
var newStudentLessons = this.SelectedGroup.Students?.Select
(
groupStudent => new StudentLessonEntity {
Student =
groupStudent,
Lesson = lesson
}
)
.ToArray() ?? new StudentLessonEntity[] { };
_context.StudentLessons.AddRange(newStudentLessons);
this.StudentExams.Add
(
new StudentAttestationExamView
(
newStudentLessons.FirstOrDefault
(
studentLesson =>
studentLesson.Student == this.Student &&
studentLesson.Lesson == lesson
),
this,
0
)
);
}
await _context.SaveChangesAsync();
UpdateExamMark();
}
public LessonScheduleView(SchedulePageModel sm, LessonEntity entity)
{
this.Lesson = entity;
this.Model = sm;
this.LocalizedType = LocalizationContainer.Localization[$"common.lesson.type.{entity.LessonType}"];
this.Date = $"{entity.Schedule?.Begin:hh\\:mm}-{entity.Schedule?.End:hh\\:mm}";
this.IconColor = this.Lesson.Checked ? Brushes.Black : Brushes.Red;
}
public LessonEntity toEntity(LessonCreateRequest request)
{
LessonEntity entity = new LessonEntity();
entity.Ename = request.Ename;
entity.Title = request.Title;
return(entity);
}
public void Update(LessonEntity entity)
{
string sql = "update lesson set ename = @Ename, title = @Title where id = @Id;";
using (var sqliteConn = connectionProvider.GetConnection())
{
sqliteConn.Execute(sql, new { id = entity.Id, Ename = entity.Ename, Title = entity.Title });
}
}
public void Create(LessonEntity entity)
{
string sql = "insert into lesson(ename, title) values (@Ename, @Title);";
using (var sqliteConn = connectionProvider.GetConnection())
{
sqliteConn.Execute(sql, new { Ename = entity.Ename, Title = entity.Title });
}
}
/// <summary>
/// Inserts or updates a lesson.
/// </summary>
/// <param name="itemToSave">The item to save.</param>
/// <param name="accountId">The account identifier.</param>
/// <returns>The result.</returns>
public ResultDto InsertUpdateLesson(LessonEditDto itemToSave, Guid accountId)
{
ResultDto result = new ResultDto();
using (BzsEntityContainer ctx = this.CreateContainer())
{
LessonEntity entity = ctx.LessonSet.FirstOrDefault(f => f.Id == itemToSave.Id);
if (entity != null)
{
result.Error = "ERR-LESSON-ALREADY-EXISTS";
return(result);
}
if (!new DayServerService().DayExists(itemToSave.DayId, ctx))
{
result.Error = "ERR-LESSON-DAY-NOT-EXISTS";
return(result);
}
if (!new SubjectServerService().SubjectExists(itemToSave.SubjectId, ctx))
{
result.Error = "ERR-LESSON-SUBJECT-NOT-EXISTS";
return(result);
}
if (itemToSave.TeacherId.HasValue && !new TeacherServerService().TeacherExists(itemToSave.TeacherId.Value, ctx))
{
result.Error = "ERR-LESSON-TEACHER-NOT-EXISTS";
return(result);
}
if (itemToSave.RoomId.HasValue && !new RoomServerService().RoomExists(itemToSave.RoomId.Value, ctx))
{
result.Error = "ERR-LESSON-ROOM-NOT-EXISTS";
return(result);
}
entity = new LessonEntity();
entity.Id = itemToSave.Id;
entity.AccountId = accountId;
entity.DayId = itemToSave.DayId;
entity.FromDate = DateTimeHelper.StringToDateTime(itemToSave.FromDate);
entity.ToDate = DateTimeHelper.StringToDateTime(itemToSave.ToDate);
entity.SubjectId = itemToSave.SubjectId;
entity.TeacherId = itemToSave.TeacherId;
entity.RoomId = itemToSave.RoomId;
entity.Remark = itemToSave.Remark;
entity.ModDate = DateTime.Now;
entity.ModUser = Environment.UserName;
ctx.LessonSet.Add(entity);
ctx.SaveChanges();
result.Success = true;
return(result);
}
}
public ActionResult Edit(LessonEntity lesson)
{
if (!ModelState.IsValid)
{
return(Edit(lesson.Id));
}
_dbContext.Entry(lesson).State = EntityState.Modified;
_dbContext.SaveChanges();
return(RedirectToAction("Index"));
}
public LessonEntity toEntity(LessonUpdateRequest request, LessonEntity oldEntity)
{
LessonEntity entity = new LessonEntity();
entity.Id = request.Id;
entity.Ename = request.Ename;
entity.Title = request.Title;
return(entity);
}
public void AddLessonAsync(LessonEntity lesson)
{
lesson.State = true;
lesson.Status = true;
lesson.UpdateDate = DateTime.Now;
lesson.CreateDate = DateTime.Now;
lesson.Uid = "123";
PIDBContext.Entry(lesson.Course).State = EntityState.Unchanged;
PIDBContext.Lessons.Add(lesson);
}
/// <summary>
/// 将entity转换为vo。不包括来自元数据的属性
/// </summary>
private LessonVo toVo(LessonEntity entity)
{
LessonVo vo = new LessonVo();
vo.Id = entity.Id;
vo.Ename = entity.Ename;
vo.Title = entity.Title;
return(vo);
}
public IActionResult Create(LessonEntity lessonEntity)
{
if (!ModelState.IsValid)
{
return(Create());
}
_dbContext.Lessons.Add(lessonEntity);
_dbContext.SaveChanges();
return(RedirectToAction("Index"));
}
private void OpenLesson([CanBeNull] LessonEntity lesson)
{
if (lesson == null)
{
return;
}
var registrationPageToken = new RegistrationPageToken("Регистрация", lesson);
_tabPageHost.AddPageAsync(registrationPageToken);
}
private List <StudentLessonInfoViewModel> FindInternalStudents(
List <StudentLessonInfoViewModel> allStudentLessons,
LessonEntity lesson
)
{
var internalStudents = lesson.Group?.Students ?? lesson.Stream.Students;
return(allStudentLessons
.Where(sl => internalStudents.Any(student => student.Id == sl.StudentLesson._StudentId))
.ToList());
}
public async Task UpdateLessonAsync(int courseId, int id, LessonEntity lesson)
{
var lessonPut = await PIDBContext.Lessons.SingleAsync(c => c.Id == lesson.Id);
lessonPut.Title = lesson.Title;
lessonPut.URLVideo = lesson.URLVideo;
lessonPut.Description = lesson.Description;
lessonPut.Order = lesson.Order;
lessonPut.Uid = lesson.Uid;
lessonPut.Status = lesson.Status;
lessonPut.UpdateDate = DateTime.Now;
}
private void Init(LessonEntity lesson)
{
_originalEntity = lesson.Id == default ? lesson : _db.Lessons.Find(lesson.Id);
this.Streams.Clear();
var streamsWithGroups = _db.Streams.Include(stream => stream.Groups)
.Where(entity => entity._Active > 0).ToList();
this.Streams.AddRange(streamsWithGroups);
this.ScheduleList.Clear();
this.ScheduleList.AddRange(_db.Schedules.ToList());
this.Lesson = new LessonEntity(lesson);
}
public static LessonDomain Create(LessonEntity lessonEntity)
{
return(new LessonDomain(
lessonEntity.Name,
lessonEntity.LessonCode,
lessonEntity.AKTS,
lessonEntity.LessonType,
lessonEntity.WeeklyHour,
lessonEntity.SemesterType,
lessonEntity.Credit
));
}
/// <summary>
/// Fills the lesson edit data transfer object.
/// </summary>
/// <param name="item">The item to fill.</param>
/// <param name="entity">The entity.</param>
/// <returns>The filled item.</returns>
private LessonEditDto FillLessonEditDto(LessonEditDto item, LessonEntity entity)
{
item.Id = entity.Id;
item.DayId = entity.DayId;
item.DayCaption = entity.DayNavProp.Caption;
item.FromDate = DateTimeHelper.DateTimeToString(entity.FromDate);
item.ToDate = DateTimeHelper.DateTimeToString(entity.ToDate);
item.SubjectId = entity.SubjectId;
item.SubjectCode = entity.SubjectNavProp.Code;
item.TeacherId = entity.TeacherId;
item.RoomId = entity.RoomId;
item.Remark = entity.Remark;
return(item);
}
public void SetLessonOrder(LessonEntity entity)
{
var lessons = this.Lessons.Where(lessonEntity =>
lessonEntity._StreamId == entity._StreamId &&
lessonEntity._GroupId == entity._GroupId &&
lessonEntity._Date != null &&
lessonEntity._ScheduleId.HasValue)
.OrderBy(lessonEntity => lessonEntity._Order)
.ToList();
LessonEntity previous = null;
bool isOrderSet = false;
foreach (var lessonEntity in lessons)
{
if (isOrderSet)
{
lessonEntity.Order++;
continue;
}
var dateCompare = lessonEntity.Date.Value.CompareTo(entity.Date.Value);
if (dateCompare < 0)
{
previous = lessonEntity;
continue;
}
if (dateCompare > 0)
{
entity.Order = (previous?.Order ?? 0) + 1;
isOrderSet = true;
continue;
}
var compareTo = lessonEntity.Schedule.Begin.Value.CompareTo(entity.Schedule.Begin.Value);
if (compareTo > 0)
{
entity.Order = (previous?.Order ?? 0) + 1;
isOrderSet = true;
}
previous = lessonEntity;
}
if (!isOrderSet)
{
entity.Order = 1;
}
}
/// <summary>
/// Returns the lesson.
/// </summary>
/// <param name="id">The lesson identifier.</param>
/// <param name="accountId">The account identifier.</param>
/// <returns>The lesson data.</returns>
public LessonEditDto GetLesson(Guid id, Guid accountId)
{
LessonEditDto data = null;
using (BzsEntityContainer ctx = this.CreateContainer())
{
LessonEntity entity = ctx.LessonSet.FirstOrDefault(f => f.Id == id && f.AccountId == accountId);
if (entity != null)
{
data = this.FillLessonEditDto(new LessonEditDto(), entity);
}
}
return(data);
}
private async Task RegisterAllStudents(LessonEntity persistentLesson)
{
List <StudentEntity> studentsShouldBeRegistered = null;
if (this.IsGroupsAvailable)
{
if (this.SelectedGroup == null)
{
return;
}
var groupStudents = this.SelectedGroup.Students?.ToList() ?? new List <StudentEntity>();
studentsShouldBeRegistered = groupStudents;
}
else
{
var streamStudents = this.Groups
.SelectMany(group => group.Students)
.Distinct(new StudentEqualityComparer())
.ToList();
studentsShouldBeRegistered = streamStudents;
}
var studentLessons = new List <StudentLessonEntity>();
studentLessons.AddRange(_db.StudentLessons.Where(entity => entity._LessonId == this.Lesson.Id));
var notRegisteredStudents = studentsShouldBeRegistered.Where(student =>
studentLessons.All(studentLesson => studentLesson._StudentId != student.Id));
var registrationTime = DateTime.Now;
var studentLessonsToRegister = notRegisteredStudents
.Select(student => new StudentLessonEntity {
Lesson = persistentLesson,
_LessonId = persistentLesson.Id,
Student = student,
_StudentId = student.Id,
IsRegistered = true,
RegistrationTime = registrationTime
});
foreach (var studentLesson in persistentLesson.StudentLessons ?? new List <StudentLessonEntity>())
{
studentLesson.IsRegistered = true;
studentLesson.RegistrationTime = studentLesson.RegistrationTime ?? registrationTime;
}
_db.StudentLessons.AddRange(studentLessonsToRegister);
await _db.SaveChangesAsync();
}
public LessonUpdateResponse Update([FromBody] LessonUpdateRequest request)
{
LessonUpdateResponse response = new LessonUpdateResponse();
if (request.Id == 0 || request.Id < 0)
{
response.Status = -1;
return(response);
}
LessonEntity entity = lessonRepository.GetById(request.Id);
if (entity == null)
{
response.Status = 404;
return(response);
}
lessonRepository.Update(lessonConvertor.toEntity(request, entity));
response.Status = 1;
return(response);
}
public LessonItemResponse Item([FromBody] LessonItemRequest request)
{
LessonItemResponse response = new LessonItemResponse();
if (request.Id <= 0)
{
response.Status = -1;
return(response);
}
LessonEntity entity = lessonRepository.GetById(request.Id);
if (entity == null)
{
response.Status = 404;
return(response);
}
response.Item = lessonConvertor.toLessVo(entity);
response.Status = 1;
return(response);
}
private void StartTimer(LessonEntity entity)
{
TimeSpan timeLeft;
var now = DateTime.Now;
if (entity.Date.HasValue && entity.Schedule.End.HasValue)
{
timeLeft = entity.Date.Value.Date + entity.Schedule.End.Value - now;
}
else
{
timeLeft = TimeSpan.Zero;
}
this.TimerState = new TimerState {
TimeLeft = timeLeft,
CurrentTime = now
};
_timerToEnd = Observable
.Interval(TimeSpan.FromMilliseconds(1000))
.ObserveOnDispatcher(DispatcherPriority.Background)
.Subscribe(UpdateTimer);
}
public LessonVo toMoreVo(LessonEntity entity)
{
LessonVo vo = toVo(entity);
return(vo);
}
public RegistrationPageToken(string title, LessonEntity lesson) :
base(title)
{
this.Lesson = lesson;
}
