public TableLessonViewPageModel(
TableLessonViewToken token, LocalDbContext db, IExportLocatorScope scope, TabPageHost host
)
{
_db = db;
_scope = scope;
_host = host;
this.Items = new CollectionViewSource {
Source = _items
};
this.Columns.Add(BuildMissedLessonsColumn());
this.WhenActivated(c => {
this.WhenAnyValue(model => model.FilterText)
.Throttle(TimeSpan.FromMilliseconds(300))
.ObserveOnDispatcher(DispatcherPriority.Background)
.Subscribe(_ => {
if (string.IsNullOrWhiteSpace(this.FilterText))
{
this.Items.View.Filter = null;
return;
}
this.Items.View.Filter =
o => o is StudentLessonViewModel item &&
item.FullName.ToUpper().Contains(this.FilterText.ToUpper());
}).DisposeWith(c);
});
Init(token.Lesson);
}
private void ActivateContent(PageControllerToken token)
{
var tabControllerToken = new TabControllerToken();
if (token.Content == null)
{
_activator.ActivateAsync(tabControllerToken)
.ToObservable()
.ObserveOnDispatcher(DispatcherPriority.Background)
.Subscribe(module => {
_host = module.Injector.Locate <TabPageHost>();
this.CentralControl = module.GetEntryComponent();
_host.AddPageAsync(token.ContentToken);
});
}
else
{
var tabModule = _activator.Activate(tabControllerToken);
_host = tabModule.Injector.Locate <TabPageHost>();
this.CentralControl = tabModule.GetEntryComponent();
// _host.Attach(token.Content);
}
}
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));
});
}
public StudentTableModel(
StudentTableToken token,
PageControllerReducer reducer,
PhotoService photoService,
TabPageHost pageHost,
LocalDbContext context)
{
_context = context;
this.PhotoService = photoService;
this.StudentTableConfig = new TableConfig {
Sorts = this.Sorts,
Filter = this.FilterFunction,
DragConfig = new DragConfig {
DragValuePath = nameof(StudentViewModel.Student)
}
};
this.StudentTableConfig.SelectedItem
.AsObservable()
.Where(LambdaHelper.NotNull)
.Subscribe(model => UpdatePhoto(((StudentViewModel)model).Student));
this.ShowStudent = new CommandHandler(() => {
var selectedItem = this.StudentTableConfig.SelectedItem.Value;
if (selectedItem == null)
{
return;
}
var studentEntity = ((StudentViewModel)selectedItem).Student;
pageHost.AddPageAsync(new StudentViewPageToken(studentEntity.LastName, studentEntity));
}
);
this.DeleteStudent = ReactiveCommand.Create
(
() => {
var selectedItem = this.StudentTableConfig.SelectedItem.Value;
if (selectedItem == null)
{
return;
}
var student = ((StudentViewModel)selectedItem).Student;
var persistentEntity = context.Students.Find(student.Id);
if (persistentEntity != null)
{
context.Students.Remove(persistentEntity);
context.SaveChanges();
}
RunInUiThread(() => {
this.StudentTableConfig.TableItems.Remove(selectedItem);
});
}
);
this.RefreshSubject
.AsObservable()
.ObserveOnDispatcher(DispatcherPriority.Background)
.Subscribe(_ => {
this.StudentTableConfig.TableItems.Clear();
var studentEntities = context.Students
.Include("Groups")
.ToList();
var studentViewModels = studentEntities.Select(entity => new StudentViewModel(entity)).ToList();
this.StudentTableConfig.TableItems.AddRange(studentViewModels);
});
reducer.Dispatch(new RegisterControlsAction(token, GetControls()));
}
public StudentViewPageModel(
StudentViewPageToken token,
PageControllerReducer reducer,
TabPageHost host,
WindowPageHost windowPageHost,
PhotoService photoService,
LocalDbContext context
)
{
_host = host;
_windowPageHost = windowPageHost;
_photoService = photoService;
_context = context;
this.AddAttestationButtonConfig = new ButtonConfig {
Command = ReactiveCommand.Create(AddAttestation),
Text = "+"
};
this.AddExamButtonConfig = new ButtonConfig {
Command = ReactiveCommand.Create(AddExam),
Text = "+"
};
this.OpenExternalLessonHandler = ReactiveCommand.Create(() => {
var selectedExternalLesson = this.SelectedExternalLesson;
if (selectedExternalLesson == null)
{
return;
}
host.AddPageAsync(new RegistrationPageToken("Регистрация", selectedExternalLesson.Lesson));
});
this.OpenStudentLessonHandler = ReactiveCommand.Create(() =>
OpenLesson(this.SelectedStudentLessonNote?.Note.StudentLesson.Lesson));
Initialize(token.Student);
this.WhenActivated(c => {
this.WhenAnyValue(model => model.Student)
.Where(LambdaHelper.NotNull)
.ObserveOnDispatcher(DispatcherPriority.Background)
.Subscribe
(
student => {
UpdateExternalLessons(student);
UpdateStudentLessonNotes(student);
UpdateStudentNotes(student);
}
).DisposeWith(c);
this.WhenAnyValue(model => model.SelectedStream).Subscribe(OnSelectedStreamUpdate).DisposeWith(c);
this.WhenAnyValue(model => model.SelectedGroup).Subscribe(OnSelectedGroupUpdate).DisposeWith(c);
this.WhenAdded <StudentLessonNote>().Merge(this.WhenRemoved <StudentLessonNote>())
.Merge(WhenUpdated <StudentLessonNote>())
.ObserveOnDispatcher(DispatcherPriority.Background)
.Subscribe(_ => UpdateStudentLessonNotes(this.Student)).DisposeWith(c);
this.WhenAdded <StudentLessonEntity>()
.Merge(this.WhenRemoved <StudentLessonEntity>())
.Merge(WhenUpdated <StudentLessonEntity>())
.ObserveOnDispatcher(DispatcherPriority.Background)
.Subscribe(_ => {
OnSelectedGroupUpdate(this.SelectedGroup);
UpdateExternalLessons(this.Student);
UpdateStudentLessonNotes(this.Student);
}).DisposeWith(c);
this.WhenAdded <StudentNote>()
.Merge(this.WhenRemoved <StudentNote>())
.Merge(WhenUpdated <StudentNote>())
.ObserveOnDispatcher(DispatcherPriority.Background)
.Subscribe(_ => UpdateStudentNotes(this.Student)).DisposeWith(c);
});
reducer.Dispatch(new RegisterControlsAction(token, GetControls()));
}
