public ActionResult GetProfileInfoCalendar(string userLogin)
{
var userService = new UsersManagementService();
var subjectService = new SubjectManagementService();
var user = userService.GetUser(userLogin);
var labsEvents =
subjectService.GetLabEvents(user.Id)
.Select(e => new ProfileCalendarViewModel()
{
color = e.Color, title = e.Title, start = e.Start
})
.ToList();
var lectEvents =
subjectService.GetLecturesEvents(user.Id)
.Select(e => new ProfileCalendarViewModel()
{
color = e.Color, title = e.Title, start = e.Start
})
.ToList();
return(Json(new
{
Labs = labsEvents,
Lect = lectEvents
}));
}
public ActionResult GetProfileInfoSubjects(string userLogin)
{
var userService = new UsersManagementService();
var subjectService = new SubjectManagementService();
var user = userService.GetUser(userLogin);
var model = new List <Subject>();
if (user.Lecturer == null)
{
model = subjectService.GetSubjectsByStudent(user.Id);
}
else
{
model = subjectService.GetSubjectsByLector(user.Id);
}
var returnModel = new List <object>();
foreach (var subject in model)
{
returnModel.Add(new
{
Name = subject.Name,
Id = subject.Id,
ShortName = subject.ShortName,
Completing = subjectService.GetSubjectCompleting(subject.Id)
});
}
return(Json(returnModel));
}
public ActionResult GetProfileStatistic(string userLogin)
{
var userService = new UsersManagementService();
var subjectService = new SubjectManagementService();
var user = userService.GetUser(userLogin);
var labs = 0;
var lects = 0;
if (user.Lecturer == null)
{
labs = subjectService.LabsCountByStudent(user.Id);
}
else
{
labs = subjectService.LabsCountByLector(user.Id);
}
return(Json(new
{
Labs = labs,
Lects = lects
}));
}
public SubjectEditViewModel(int subjectId)
{
SubjectId = subjectId;
Title = SubjectId == 0 ? "Создание предмета" : "Редактирование предмета";
Modules = ModulesManagementService.GetModules().Where(e => e.Visible).Select(e => new ModulesViewModel(e)).ToList();
FillSubjectGroups();
if (subjectId != 0)
{
var subject = SubjectManagementService.GetSubject(subjectId);
SubjectId = subjectId;
ShortName = subject.ShortName;
DisplayName = subject.Name;
foreach (var module in Modules)
{
if (subject.SubjectModules.Any(e => e.ModuleId == module.ModuleId))
{
module.Checked = true;
}
}
SelectedGroups = new List <int>();
foreach (var group in Groups)
{
var groupId = int.Parse(group.Value);
if (subject.SubjectGroups.Any(e => e.GroupId == groupId))
{
SelectedGroups.Add(groupId);
}
}
}
}
public void SaveSubGroups(int subjectId, int groupId, string subGroupFirst, string subGroupSecond,
string subGroupThird)
{
var listSubGroupFirst = new List<int>();
var listSubGroupSecond = new List<int>();
var listSubGroupThird = new List<int>();
if (!string.IsNullOrWhiteSpace(subGroupFirst))
{
subGroupFirst = subGroupFirst.Remove(subGroupFirst.Length - 1);
listSubGroupFirst = subGroupFirst.Split(new[] {','}).Select(int.Parse).ToList();
}
if (!string.IsNullOrWhiteSpace(subGroupSecond))
{
subGroupSecond = subGroupSecond.Remove(subGroupSecond.Length - 1);
listSubGroupSecond = subGroupSecond.Split(new[] {','}).Select(int.Parse).ToList();
}
if (!string.IsNullOrWhiteSpace(subGroupThird))
{
subGroupThird = subGroupThird.Remove(subGroupThird.Length - 1);
listSubGroupThird = subGroupThird.Split(new[] {','}).Select(int.Parse).ToList();
}
SubjectManagementService.SaveSubGroup(subjectId, groupId, listSubGroupFirst, listSubGroupSecond,
listSubGroupThird);
}
public void ReturnEmptyCollection_WhenThereIsNoSubjectsWithoutTeacher()
{
var mockedSubjectRepo = new Mock <IRepository <Subject> >();
var mockedSubjClassRepo = new Mock <IRepository <SubjectClassOfStudents> >();
var mockedUow = new Mock <IUnitOfWork>().Object;
IEnumerable <SubjectBasicInfoModel> expected = null;
var expectedCount = 0;
var data = new List <Subject>()
{
new Subject()
{
Id = 1, Name = "Subj1", TeacherId = "someid"
},
new Subject()
{
Id = 1, Name = "Subj1", TeacherId = "anotherTeacherId"
}
};
mockedSubjectRepo.Setup(x =>
x.GetAll(It.IsAny <Expression <Func <Subject, bool> > >(), It.IsAny <Expression <Func <Subject, SubjectBasicInfoModel> > >()))
.Returns((Expression <Func <Subject, bool> > predicate, Expression <Func <Subject, SubjectBasicInfoModel> > select) =>
expected = data.Where(predicate.Compile()).Select(select.Compile()).ToList()
);
var subjectsManagementService = new SubjectManagementService(mockedSubjectRepo.Object, mockedSubjClassRepo.Object, () => mockedUow);
var result = subjectsManagementService.GetAllSubjectsWithoutTeacher();
CollectionAssert.AreEquivalent(expected, result);
Assert.AreEqual(expectedCount, result.Count());
}
public LmsViewModel(int userId, bool isLector)
{
Subjects = SubjectManagementService.GetUserSubjects(userId).Where(e => !e.IsArchive).Select(e => new SubjectViewModel(e)).ToList();
CurrentSubjects = Subjects.Count();
TotalSubject = SubjectManagementService.GetSubjects().Count();
var modelStudents = new List <int>();
CurrentStudents = 0;
if (isLector)
{
TotalStudents = StudentManagementService.GetStudents().Count();
foreach (var subjects in SubjectManagementService.GetUserSubjects(userId))
{
if (subjects.SubjectGroups != null)
{
foreach (var group in subjects.SubjectGroups)
{
foreach (var student in group.SubjectStudents)
{
if (modelStudents.All(e => e != student.StudentId))
{
modelStudents.Add(student.StudentId);
CurrentStudents += 1;
}
}
}
}
}
}
}
public SubjectManagementViewModel(string userId)
{
Subjects = SubjectManagementService.GetUserSubjects(int.Parse(userId)).Where(e => !e.IsArchive)
.Select(e => new SubjectViewModel(e)).ToList();
//Subjects = SubjectManagementService.GetSubjectsByLectorOwner(int.Parse(userId)).Where(e => !e.IsArchive).Select(e => new SubjectViewModel(e)).ToList();
}
public void ReturnEmptyCollection_WhenThereAreNotSubjectsAvaiableToAssignForThisClass()
{
var mockedSubjectRepo = new Mock <IRepository <Subject> >();
var mockedSubjClassRepo = new Mock <IRepository <SubjectClassOfStudents> >();
var mockedUow = new Mock <IUnitOfWork>().Object;
var classId = 1;
var classOfStudents = new ClassOfStudents()
{
Id = classId, Name = "classOfStudents"
};
var subject = new Subject()
{
Id = 1, Name = "Subj1"
};
var subjects = new List <Subject>()
{
subject
};
var data = new List <SubjectClassOfStudents>();
{
new SubjectClassOfStudents()
{
SubjectId = subject.Id, ClassOfStudentsId = classId
};
};
subject.SubjecClassOfStudents = data;
IEnumerable <int> alreadyassigndedSubjectIds = null;
mockedSubjClassRepo.Setup(x =>
x.GetAll(It.IsAny <Expression <Func <SubjectClassOfStudents, bool> > >(),
It.IsAny <Expression <Func <SubjectClassOfStudents, int> > >(),
It.IsAny <Expression <Func <SubjectClassOfStudents, object> >[]>()))
.Returns((Expression <Func <SubjectClassOfStudents, bool> > predicate,
Expression <Func <SubjectClassOfStudents, int> > select) =>
alreadyassigndedSubjectIds = data.Where(predicate.Compile()).Select(select.Compile()).ToList()
);
IEnumerable <SubjectBasicInfoModel> expected = null;
mockedSubjectRepo.Setup(x =>
x.GetAll(It.IsAny <Expression <Func <Subject, bool> > >(),
It.IsAny <Expression <Func <Subject, SubjectBasicInfoModel> > >()))
.Returns((Expression <Func <Subject, bool> > predicate,
Expression <Func <Subject, SubjectBasicInfoModel> > select) =>
expected = subjects.Where(predicate.Compile()).Select(select.Compile()).ToList()
);
var subjectsManagementService = new SubjectManagementService(mockedSubjectRepo.Object, mockedSubjClassRepo.Object, () => mockedUow);
var result = subjectsManagementService.GetSubjectsNotYetAssignedToTheClass(classId);
CollectionAssert.AreEquivalent(expected, result);
Assert.AreEqual(0, result.Count());
}
public ModulesScheduleProtectionLabsViewModel(int subjectId, Module module)
: base(subjectId, module)
{
var subject = SubjectManagementService.GetSubject(subjectId);
var firstOrDefault = subject.SubjectGroups.FirstOrDefault();
var defaultOr = firstOrDefault?.SubGroups.FirstOrDefault();
if (defaultOr != null)
{
SubGroupId = defaultOr.Id.ToString(CultureInfo.InvariantCulture);
}
var subjectGroup = subject.SubjectGroups.FirstOrDefault();
if (subjectGroup != null)
{
GroupId = subjectGroup.GroupId.ToString(CultureInfo.InvariantCulture);
}
ScheduleProtectionLabs = subject.Labs
.Select(e => new ScheduleProtectionLabsDataViewModel(e, int.Parse(SubGroupId))).ToList();
var groups = GroupManagementService.GetGroups(
new Query <Group>(e => e.SubjectGroups.Any(x => x.SubjectId == subjectId)).Include(e => e.Students));
FillGroupsList(groups);
}
public ResultViewData Save(string subjectId, string id, string theme, string duration, string order, string shortName, string pathFile, string attachments)
{
try
{
var attachmentsModel = JsonConvert.DeserializeObject <List <Attachment> >(attachments).ToList();
var subject = int.Parse(subjectId);
SubjectManagementService.SaveLabs(new Models.Labs
{
SubjectId = subject,
Duration = int.Parse(duration),
Theme = theme,
Order = int.Parse(order),
ShortName = shortName,
Attachments = pathFile,
Id = int.Parse(id)
}, attachmentsModel, WebSecurity.CurrentUserId);
return(new ResultViewData()
{
Message = "Лабораторная работа успешно сохранена",
Code = "200"
});
}
catch (Exception)
{
return(new ResultViewData()
{
Message = "Произошла ошибка при сохранении лабораторной работы",
Code = "500"
});
}
}
public void Return_EmtyCollecctionOfSubjectsAssignedToTheTeacher_WhenThereAreNone()
{
var mockedSubjectRepo = new Mock <IRepository <Subject> >();
var mockedSubjClassRepo = new Mock <IRepository <SubjectClassOfStudents> >();
var mockedUow = new Mock <IUnitOfWork>().Object;
var teacherUserName = "******";
var data = new List <Subject>();
IEnumerable <SubjectBasicInfoModel> expected = null;
mockedSubjectRepo.Setup(x =>
x.GetAll(It.IsAny <Expression <Func <Subject, bool> > >(),
It.IsAny <Expression <Func <Subject, SubjectBasicInfoModel> > >(),
It.IsAny <Expression <Func <Subject, object> >[]>()))
.Returns((Expression <Func <Subject, bool> > predicate,
Expression <Func <Subject, SubjectBasicInfoModel> > select,
Expression <Func <Subject, object> >[] include) =>
expected = data.Where(predicate.Compile()).Select(select.Compile()).ToList()
);
var subjectsManagementService = new SubjectManagementService(mockedSubjectRepo.Object, mockedSubjClassRepo.Object, () => mockedUow);
var result = subjectsManagementService
.GetSubjectsPerTeacher(teacherUserName);
CollectionAssert.AreEquivalent(expected, result);
Assert.AreEqual(0, result.Count());
}
public UserLabFilesResult GetFilesLab(string userId, string subjectId)
{
try
{
var model = new List <UserlabFilesViewData>();
var data = SubjectManagementService.GetUserLabFiles(int.Parse(userId), int.Parse(subjectId));
model = data.Select(e => new UserlabFilesViewData()
{
Comments = e.Comments,
Id = e.Id,
PathFile = e.Attachments,
Date = e.Date != null ? e.Date.Value.ToString("dd.MM.yyyy HH:mm") : string.Empty,
Attachments = FilesManagementService.GetAttachments(e.Attachments).ToList()
}).ToList();
return(new UserLabFilesResult()
{
UserLabFiles = model,
Message = "Данные получены",
Code = "200"
});
}
catch (Exception)
{
return(new UserLabFilesResult()
{
Message = "Произошла ошибка при получении данных",
Code = "500"
});
}
}
public ResultViewData SendFile(string subjectId, string userId, string id, string comments, string pathFile, string attachments)
{
try
{
var attachmentsModel = JsonConvert.DeserializeObject <List <Attachment> >(attachments).ToList();
SubjectManagementService.SaveUserLabFiles(new Models.UserLabFiles()
{
SubjectId = int.Parse(subjectId),
Date = DateTime.Now,
UserId = int.Parse(userId),
Comments = comments,
Attachments = pathFile,
Id = int.Parse(id)
}, attachmentsModel);
return(new ResultViewData()
{
Message = "Файл(ы) успешно отправлен(ы)",
Code = "200"
});
}
catch (Exception)
{
return(new ResultViewData()
{
Message = "Произошла ошибка",
Code = "500"
});
}
}
public ResultViewData SaveLabsVisitingData(List <StudentsViewData> students)
{
try
{
foreach (var student in students)
{
SubjectManagementService.SaveLabsVisitingData(student.LabVisitingMark.Select(e => new ScheduleProtectionLabMark {
Id = e.LabVisitingMarkId, Comment = e.Comment, Mark = e.Mark, StudentId = e.StudentId, ScheduleProtectionLabId = e.ScheduleProtectionLabId
}).ToList());
}
return(new ResultViewData()
{
Message = "Данные успешно добавлены",
Code = "200"
});
}
catch (Exception)
{
return(new ResultViewData()
{
Message = "Произошла ошибка при добавлении данных",
Code = "500"
});
}
}
public ResultViewData SaveStudentLabsMark(List <StudentsViewData> students)
{
try
{
foreach (var student in students)
{
SubjectManagementService.SaveStudentLabsMark(student.StudentLabMarks.Select(e => new StudentLabMark {
Id = e.StudentLabMarkId, LabId = e.LabId, StudentId = e.StudentId, Mark = e.Mark
}).ToList());
}
return(new ResultViewData()
{
Message = "Данные успешно добавлены",
Code = "200"
});
}
catch (Exception)
{
return(new ResultViewData()
{
Message = "Произошла ошибка при добавлении данных",
Code = "500"
});
}
}
public ModulesPracticalViewModel(int subjectId, Module module)
: base(subjectId, module)
{
PracticalsData =
SubjectManagementService.GetSubject(subjectId).Practicals.Select(e => new PracticalsDataViewModel(e))
.ToList();
}
public SubjectWorkingViewModel(int subjectId)
{
SubjectId = subjectId;
Subject = SubjectManagementService.GetSubject(subjectId);
SubjectName = Subject.Name;
Modules = Subject.SubjectModules.OrderBy(e => e.Module.Order).Select(e => new ModulesViewModel(e.Module)).ToList();
NotVisibleModules = ModulesManagementService.GetModules().Where(e => !e.Visible).Select(e => new ModulesViewModel(e)).ToList();
}
public ModulesDataWorkingViewModel(int subjectId, int moduleId, ModuleType type)
{
SubjectId = subjectId;
ParentModule = type;
var subject = SubjectManagementService.GetSubject(subjectId);
Module = subject.SubjectModules.First(e => e.Module.Id == moduleId).Module;
switch (type)
{
case ModuleType.Practical:
{
switch (Module.ModuleType)
{
case ModuleType.ScheduleProtection:
{
break;
}
case ModuleType.Results:
{
break;
}
case ModuleType.StatisticsVisits:
{
break;
}
}
break;
}
case ModuleType.Labs:
{
switch (Module.ModuleType)
{
case ModuleType.ScheduleProtection:
{
ScheduleProtectionLabsGenerate();
break;
}
case ModuleType.Results:
{
break;
}
case ModuleType.StatisticsVisits:
{
break;
}
}
break;
}
}
}
public void ThrowArgumentNllExcepion_WhenSubjectClassOfStudentRepoIsNull()
{
var mockedRepo = new Mock <IRepository <Subject> >().Object;
var mockedUow = new Mock <IUnitOfWork>().Object;
Assert.Throws <ArgumentNullException>(() =>
{
var subjectManagementService = new SubjectManagementService(mockedRepo, null, () => mockedUow);
});
}
public void ThrowArgumentNullException_WhenUnitOfWorkIsNull()
{
var mockedRepo = new Mock <IRepository <Subject> >().Object;
var mockedSubjClassRepo = new Mock <IRepository <SubjectClassOfStudents> >().Object;
Assert.Throws <ArgumentNullException>(() =>
{
var subjectManagementService = new SubjectManagementService(mockedRepo, mockedSubjClassRepo, null);
});
}
public void ThrowArgumentNullException_WhenSubjectNameIsNull()
{
var mockedRepo = new Mock <IRepository <Subject> >().Object;
var mockedUow = new Mock <IUnitOfWork>().Object;
var mockedSubjClassRepo = new Mock <IRepository <SubjectClassOfStudents> >();
var service = new SubjectManagementService(mockedRepo, mockedSubjClassRepo.Object, () => mockedUow);
Assert.Throws <ArgumentNullException>(() => service.CreateSubject(null, "test"));
}
public void ThrowArgumentNullException_WithMessageContainingSubjectIds_WhenSubjectIdsAreNull()
{
var mockedSubjectRepo = new Mock <IRepository <Subject> >();
var mockedSubjClassRepo = new Mock <IRepository <SubjectClassOfStudents> >();
var mockedUow = new Mock <IUnitOfWork>().Object;
var subjectsManagementService = new SubjectManagementService(mockedSubjectRepo.Object, mockedSubjClassRepo.Object, () => mockedUow);
Assert.That(() => subjectsManagementService.AddSubjectsToTeacher("TeacherName", null),
Throws.ArgumentNullException.With.Message.Contain("subjectIds"));
}
public void NotThrow_IfAllArgumentsAreValid()
{
var mockedSubjectRepo = new Mock <IRepository <Subject> >().Object;
var mockedSubjClassRepo = new Mock <IRepository <SubjectClassOfStudents> >().Object;
var mockedUow = new Mock <IUnitOfWork>().Object;
Assert.DoesNotThrow(() =>
{
var subjectManagementService = new SubjectManagementService(mockedSubjectRepo, mockedSubjClassRepo, () => mockedUow);
});
}
public void ThrowArgumentNullException_WithMsgContainingSubjectName_WhenSubjectNameIsNull()
{
var mockedRepo = new Mock <IRepository <Subject> >().Object;
var mockedUow = new Mock <IUnitOfWork>().Object;
var mockedSubjClassRepo = new Mock <IRepository <SubjectClassOfStudents> >();
var service = new SubjectManagementService(mockedRepo, mockedSubjClassRepo.Object, () => mockedUow);
Assert.That(() => service.CreateSubject(null, "test"),
Throws.ArgumentNullException.With.Message.Contain("subjectName"));
}
public void ThrowArgumentException_WithMessageContainingTeacherId_WhenTeacheIdIsEmpty()
{
var mockedSubjectRepo = new Mock <IRepository <Subject> >();
var mockedSubjClassRepo = new Mock <IRepository <SubjectClassOfStudents> >();
var mockedUow = new Mock <IUnitOfWork>().Object;
var subjectsManagementService = new SubjectManagementService(mockedSubjectRepo.Object, mockedSubjClassRepo.Object, () => mockedUow);
Assert.That(() => subjectsManagementService.AddSubjectsToTeacher(string.Empty, new List <int>()),
Throws.ArgumentException.With.Message.Contain("teacherId"));
}
public SubjectWorkingViewModel(int subjectId)
{
SubjectId = subjectId;
Subject = SubjectManagementService.GetSubject(new Query <Subject>(e => e.Id == subjectId)
.Include(e => e.SubjectModules.Select(x => x.Module))
.Include(e => e.SubjectLecturers.Select(x => x.Lecturer.User)));
SubjectName = Subject.Name;
Modules = Subject.SubjectModules.OrderBy(e => e.Module.Order).Select(e => new ModulesViewModel(e.Module))
.ToList();
NotVisibleModules = ModulesManagementService.GetModules().Where(e => !e.Visible)
.Select(e => new ModulesViewModel(e)).ToList();
}
public ActionResult GetSideNav(int groupId)
{
var group = GroupManagementService.GetGroup(groupId);
var subjects = SubjectManagementService.GetGroupSubjects(groupId);
var model = new ParentalViewModel(group)
{
Subjects = subjects
};
return(PartialView("_ParentalSideNavPartial", model));
}
public void CallGetAllWithIdOfTheClass_Once_AndReturnEmptyCollection_WhenTheSubjectsDoNotHaveTeacher()
{
var mockedSubjectRepo = new Mock <IRepository <Subject> >();
var mockedSubjClassRepo = new Mock <IRepository <SubjectClassOfStudents> >();
var mockedUow = new Mock <IUnitOfWork>().Object;
var classId = 1;
var subjectId = 1;
var subject = new Subject()
{
Id = subjectId
};
var data = new List <SubjectClassOfStudents>()
{
new SubjectClassOfStudents()
{
ClassOfStudentsId = classId,
Subject = subject
}
};
IEnumerable <Subject> expected = null;
mockedSubjClassRepo.Setup(x =>
x.GetAll(It.IsAny <Expression <Func <SubjectClassOfStudents, bool> > >(),
It.IsAny <Expression <Func <SubjectClassOfStudents, Subject> > >(),
It.IsAny <Expression <Func <SubjectClassOfStudents, object> >[]>()))
.Returns((Expression <Func <SubjectClassOfStudents, bool> > predicate,
Expression <Func <SubjectClassOfStudents, Subject> > select,
Expression <Func <SubjectClassOfStudents, object> >[] include) =>
expected = data.Where(predicate.Compile()).Select(select.Compile()).ToList()
);
var subjectsManagementService = new SubjectManagementService(mockedSubjectRepo.Object, mockedSubjClassRepo.Object, () => mockedUow);
var result = subjectsManagementService
.GetAllSubjectsAlreadyAssignedToTheClass(classId);
mockedSubjClassRepo.Verify(
x => x.GetAll(
It.IsAny <Expression <Func <SubjectClassOfStudents, bool> > >(),
It.IsAny <Expression <Func <SubjectClassOfStudents, Subject> > >(),
It.IsAny <Expression <Func <SubjectClassOfStudents, object> > >()),
Times.Once);
Assert.AreEqual(0, result.Count());
CollectionAssert.AreEquivalent(expected, result);
}
public LecturesDataViewModel(int id, int subjectId)
{
SubjectId = subjectId;
Attachments = new List <Attachment>();
if (id != 0)
{
var lectures = SubjectManagementService.GetLectures(id);
Order = lectures.Order;
Theme = lectures.Theme;
Duration = lectures.Duration;
LecturesId = id;
PathFile = lectures.Attachments;
Attachments = FilesManagementService.GetAttachments(lectures.Attachments);
}
}
