private List <ButtonConfig> GetControls()
{
var buttonConfigs = new List <ButtonConfig> {
GetRefreshButtonConfig(),
new ButtonConfig {
Command = ReactiveCommand.Create(() => {
_host.AddPageAsync(
new StudentFormToken("Редактирование " + this.Student.LastName, this.Student));
}),
Text = "Редактировать"
},
new ButtonConfig {
Command = ReactiveCommand.Create(() => {
var noteListFormToken = new NoteListFormToken("Заметки", () => new StudentNote {
Student = this.Student,
EntityId = this.Student.Id
}, _context.StudentNotes.Where(note => note.EntityId == this.Student.Id).ToList());
_windowPageHost.AddPageAsync(noteListFormToken);
}),
Text = "Заметки"
}
};
return(buttonConfigs);
}
private async Task <List <ButtonConfig> > GetControls()
{
var buttonConfigs = new List <ButtonConfig>();
var nextLesson = (await _db.Lessons.Where(lesson => lesson._Date != null &&
lesson.Schedule != null &&
lesson._Date.Equals(this.Lesson._Date))
.ToListAsync())
.OrderBy(lesson => lesson.Schedule.Begin)
.FirstOrDefault(lesson => lesson.Schedule.Begin > this.Lesson.Schedule.Begin);
if (nextLesson != null)
{
buttonConfigs.Add(new ButtonConfig
{
Command = ReactiveCommand.Create(() =>
{
_tabPageHost.AddPageAsync(new RegistrationPageToken("Регистрация", nextLesson));
}),
Text = "Следующее занятие",
});
}
buttonConfigs.Add(new ButtonConfig
{
Command = ReactiveCommand.Create(() =>
{
var title = this.Lesson.Group == null
? this.Lesson.Stream.Name
: this.Lesson.Group.Name + " " +
Localization["common.lesson.type." + this.Lesson.LessonType] + " " +
this.Lesson.Date?.ToString("dd.MM");
var token = new TableLessonViewToken(title, this.Lesson);
_tabPageHost.AddPageAsync <TableLessonViewModule, TableLessonViewToken>(token);
}),
Text = "Занятие 1"
});
buttonConfigs.Add(new ButtonConfig
{
Command = ReactiveCommand.Create(() =>
_windowPageHost.AddPageAsync(new NoteListFormToken(
"Заметки",
() => new LessonNote {
Lesson = Lesson, EntityId = Lesson.Id
},
Lesson.Notes
))
),
Text = "Заметки"
});
buttonConfigs.Add(new ButtonConfig
{
Command = ReactiveCommand.Create(() =>
_windowPageHost.AddPageAsync(new LessonFormToken("Занятие", this.Lesson, _tabPageHost))
),
Text = "Редактировать"
});
return(buttonConfigs);
}
private void OpenLessonEditForm()
{
if (this.SelectedLesson == null)
{
return;
}
var lesson = this.SelectedLesson.Lesson;
var lessonFormModuleToken = new LessonFormToken("Lesson", lesson, _currentHost);
_windowPageHost.AddPageAsync <LessonFormModule, LessonFormToken>(lessonFormModuleToken);
}
private void AddStudent_Click()
{
_windowPageHost.AddPageAsync(new StudentFormToken("Добавить студента", new StudentEntity()));
}
public RegistrationPageModel(
StudentCardService studentCardService,
PhotoService photoService,
TabPageHost tabPageHost,
WindowPageHost windowPageHost,
LocalDbContext db,
RegistrationPageToken token,
MainReducer mainReducer,
PageControllerReducer reducer
)
{
_tabPageHost = tabPageHost;
_windowPageHost = windowPageHost;
_db = db;
_token = token;
_mainReducer = mainReducer;
this.StudentCardService = studentCardService;
this.PhotoService = photoService;
this.DoRegister = ReactiveCommand.Create(() => {
if (this.AllStudentsMode)
{
foreach (IStudentViewModel selectedStudent in this.SelectedStudents.ToList())
{
RegisterExtStudent(selectedStudent.Student);
}
}
else
{
Register();
}
});
this.DoUnRegister = ReactiveCommand.Create(UnRegister);
this.OpenStudentLessonHandler = ReactiveCommand.Create(() =>
OpenLesson(this.SelectedStudentLessonNote?.Note?.StudentLesson?.Lesson));
this.ShowStudent = ReactiveCommand.Create(() => {
var selectedStudent = _selectedStudent;
var studentViewPageToken = new StudentViewPageToken("Студент", selectedStudent);
tabPageHost.AddPageAsync <StudentViewPageModule, StudentViewPageToken>(studentViewPageToken);
});
this.AddStudentNote = ReactiveCommand.Create(() => {
var noteFormToken = new NoteListFormToken("Заметки", () => new StudentLessonNote()
{
StudentLesson = _selectedStudentLesson.StudentLesson,
EntityId = _selectedStudentLesson.StudentLesson.Id
}, _selectedStudentLesson.StudentLesson.Notes);
windowPageHost.AddPageAsync <NoteListFormModule, NoteListFormToken>(noteFormToken);
});
this.ToggleAllStudentTable = new ButtonConfig {
Command = ReactiveCommand.Create(() => this.AllStudentsMode = !this.AllStudentsMode),
Text = Localization["Все студенты"]
};
this.AllStudentsFilter = (o, s) => {
var student = ((IStudentViewModel)o).Student;
var alreadyAdded =
IsStudentAlreadyRegistered(RegisteredStudents.Cast <StudentLessonInfoViewModel>(), student) ||
IsStudentAlreadyRegistered(LessonStudents.Cast <StudentLessonInfoViewModel>(), student);
if (alreadyAdded)
{
return(false);
}
s = s.ToLowerInvariant();
return(student.FirstName != null &&
student.FirstName.ToLowerInvariant()
.Contains(s) ||
student.LastName != null &&
student.LastName.ToLowerInvariant()
.Contains(s) ||
student.SecondName != null &&
student.SecondName.ToLowerInvariant()
.Contains(s));
};
InitTableConfigs();
Init(token.Lesson);
this.WhenActivated(disposable => {
this.WhenAnyValue(model => model.TimerState)
.Where(LambdaHelper.NotNull)
.ObserveOnDispatcher(DispatcherPriority.Background)
.Subscribe(state => {
this.TimerString = $"{state.TimeLeft:hh\\:mm\\:ss}/{state.CurrentTime:HH:mm:ss}";
}).DisposeWith(disposable);
this.WhenAnyValue(model => model.Lesson)
.Where(LambdaHelper.NotNull)
.ObserveOnDispatcher(DispatcherPriority.Background)
.Subscribe(entity => {
var groupName = entity.Group?.Name ?? entity.Stream.Name;
var lessonInfo =
$"{Localization["common.lesson.type." + entity.LessonType]}: {entity.Order}/{entity.GetLessonsCount()}";
this.LessonInfoState = new LessonInfoState {
GroupName = groupName,
LessonInfo = lessonInfo,
Date = entity.Date?.ToString("dd.MM.yyyy"),
Time =
$"[{entity.Schedule.OrderNumber}] {entity.Schedule.Begin:hh\\:mm} - {entity.Schedule.End:hh\\:mm}"
};
}).DisposeWith(disposable);
this.WhenAnyValue(model => model.AllStudentsMode)
.Throttle(TimeSpan.FromMilliseconds(100))
.ObserveOnDispatcher(DispatcherPriority.Background)
.Subscribe(b => {
this.ToggleAllStudentTable.Text = b ? Localization["Занятие"] : Localization["Все студенты"];
if (!b || this.AllStudents.Count != 0)
{
return;
}
var studentViewModels = db.Students
.Include(model => model.Groups)
.ToList() // create query and load
.Select(model => new StudentViewModel(model))
.ToList();
this.AllStudents.AddRange(studentViewModels);
}).DisposeWith(disposable);
this.WhenAnyValue(model => model.IsLessonChecked)
.ObserveOnDispatcher(DispatcherPriority.Background)
.Subscribe(b => {
if (this.Lesson == null)
{
return;
}
this.Lesson.Checked = b;
this._db.ThrottleSave();
}).DisposeWith(disposable);
this.LessonStudentsTableConfig.SelectedItem
.Where(LambdaHelper.NotNull)
.Merge(this.RegisteredStudentsTableConfig.SelectedItem.AsObservable().Where(LambdaHelper.NotNull))
.Cast <StudentLessonInfoViewModel>()
.Do(o => this._selectedStudentLesson = o)
.Select(o => o.StudentLesson.Student)
.Merge(this.AllStudentsTableConfig.SelectedItem.Where(LambdaHelper.NotNull))
.Throttle(TimeSpan.FromMilliseconds(200))
.Subscribe
(
async o => {
var studentEntity = o as StudentEntity;
_selectedStudent = studentEntity;
await UpdateDescription(studentEntity);
await UpdateStudentLessonNotes(studentEntity);
}
).DisposeWith(disposable);
this.WhenRemoved <LessonEntity>()
.Where(entities => entities.Any(entity => entity.Id == this.Lesson?.Id))
.Subscribe(_ => token.Deactivate())
.DisposeWith(disposable);
this.WhenRemoved <StudentLessonNote>()
.Merge(this.WhenAdded <StudentLessonNote>())
.Merge(this.WhenUpdated <StudentLessonNote>())
.Where(notes => this._selectedStudent != null &&
notes.Any(note => note.StudentLesson._StudentId == this._selectedStudent.Id))
.ObserveOnDispatcher(DispatcherPriority.Background)
.Subscribe(_ => UpdateStudentLessonNotes(this._selectedStudent));
this.StudentCardService.ReadStudentCard.Subscribe(ReadStudentData);
});
GetControls()
.ToObservable()
.TakeUntil(DestroySubject)
.Subscribe(controls =>
{
reducer.Dispatch(new RegisterControlsAction(token, controls));
});
}