private void AddGroupBth_Click(object sender, RoutedEventArgs e)
{
if (groupID == 0 && GroupTitleTxt.Text != "")
{
try
{
StudentGroup group = new StudentGroup();
group.GroupTitle = GroupTitleTxt.Text;
group.GroupDesc = GroupDescTxt.Text;
CourseData.db.StudentGroup.InsertOnSubmit(group);
CourseData.db.SubmitChanges();
Clear();
LoadData();
GroupField.Visibility = Visibility.Hidden;
MessageBox.Show("Added Group");
ListGroup.IsEnabled = true;
AddButtun.IsEnabled = true;
DeleteButton.IsEnabled = true;
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
else
{
MessageBox.Show("Group Title Can't Empty");
}
}
public Discipline(string name, StudentGroup studentGroup,
int attestation, int auditoriumHours, int lectureHours, int practicalHours)
{
Name = name;
StudentGroup = studentGroup;
Attestation = attestation;
AuditoriumHours = auditoriumHours;
LectureHours = lectureHours;
PracticalHours = practicalHours;
}
// Add Stuedents to Group
public async Task AddStudentToGroup(StudentGroup studentGroup)
{
_context.StudentsGroups.Add(studentGroup);
await _context.SaveChangesAsync();
}
public ConsoleStudentGroupLogger(StudentGroup group)
{
group.SubscribeLogger(this);
}
//methods
public Schedule GetSchedule(string path)
{
string[,] excel = this.getValuesFromExcel(path);
var plan = new Schedule();
plan.Name = excel[0, 0];
int bufor_wiersz = excel.GetLength(0);
int bufor_kolumna = excel.GetLength(1);
var dzien = new ScheduleDayOfWeek();
dzien.Day = SubjectTimeResolver.Instance.GetDayOfWeekFromString(excel[1, 0]);
var grupa = new StudentGroup();
for (int wiersz = 1; wiersz < bufor_wiersz; wiersz++)
{
Subject aktualnyPrzedmiot = new Subject();
for (int kolumna = 0; kolumna < bufor_kolumna; kolumna++)
{
if (kolumna == 0 && (!String.IsNullOrEmpty(excel[wiersz, kolumna]) || excel[wiersz, kolumna] == plan.Name))
{
if (wiersz + 1 == bufor_wiersz)
{
// skonczył sie ostatni dzień
plan.DaysOfWeek.Add(dzien);
}
else if (SubjectTimeResolver.Instance.IsValidDay(excel[wiersz + 1, kolumna]) && dzien.Day != SubjectTimeResolver.Instance.GetDayOfWeekFromString(excel[wiersz + 1, kolumna]))
{
// skonczył się aktualny dzień i zaczyna nowy
plan.DaysOfWeek.Add(dzien);
dzien = new ScheduleDayOfWeek();
dzien.Day = SubjectTimeResolver.Instance.GetDayOfWeekFromString(excel[wiersz + 1, kolumna]);
}
}
else if (kolumna == 1 && excel[wiersz, kolumna] != "Grupa")
{
grupa.Name = excel[wiersz, kolumna];
}
else
{
if (!String.IsNullOrEmpty(excel[wiersz, kolumna]))// jest coś w komórce
{
if (excel[wiersz, kolumna] != aktualnyPrzedmiot.Name)
{
// zaczyna sie nowy przedmiot i konczy stary lub po prostu zaczyna sie przedmiot
if (!String.IsNullOrEmpty(aktualnyPrzedmiot.Name))
{
aktualnyPrzedmiot.TimeEnds = Tools.SubjectTimeResolver.Instance.GetMinutesFromCell(kolumna);
grupa.Subjects.Add(aktualnyPrzedmiot);
}
aktualnyPrzedmiot = new Subject();
aktualnyPrzedmiot.TimeStarts = Tools.SubjectTimeResolver.Instance.GetMinutesFromCell(kolumna);
aktualnyPrzedmiot.Name = excel[wiersz, kolumna];
}
else
{
// trwa stary
}
}
else // komórka jest pusta
{
if (!String.IsNullOrEmpty(aktualnyPrzedmiot.Name)) // aktualny przedmiot nie jest pusty
{
// skonczyl sie aktualny przedmiot
aktualnyPrzedmiot.TimeEnds = Tools.SubjectTimeResolver.Instance.GetMinutesFromCell(kolumna);
grupa.Subjects.Add(aktualnyPrzedmiot);
aktualnyPrzedmiot = new Subject();
}
}
}
}
dzien.StudentGroups.Add(grupa);
grupa = new StudentGroup();
}
return(plan);
}
private async Task <bool> CreationIsAllowed(int teacherId, int studentId)
{
StudentGroup group = await groupStorage.StudentGroupGetByUserId(studentId);
return(await groupStorage.GetBelongnessOfGroupToTheTeacher(Convert.ToInt32(group.GroupId), teacherId));
}
public async Task CeateLessonAsync()
{
//Arrange
Theme theme = new Theme
{
Name = "ExampleName",
Id = 5
};
Mentor mentor = new Mentor
{
Id = 2
};
StudentGroup studentGroup = new StudentGroup
{
Id = 3
};
List <VisitDto> visitsDto = new List <VisitDto>()
{
};
List <Visit> visits = new List <Visit>()
{
};
var createdLesson = new LessonDto()
{
Id = 7,
ThemeName = "ExampleName",
MentorId = 2,
StudentGroupId = 3,
LessonDate = DateTime.Parse("2020-11-18T15:00:00.384Z"),
LessonVisits = visitsDto
};
var createLessonDto = new CreateLessonDto
{
ThemeName = "ExampleName",
MentorId = 2,
StudentGroupId = 3,
LessonDate = DateTime.Parse("2020-11-18T15:00:00.384Z"),
LessonVisits = visitsDto
};
var lessonRepositoryMock = new Mock <ILessonRepository>();
lessonRepositoryMock.Setup(x => x.Add(It.IsAny <Lesson>()))
.Callback <Lesson>(x => {
x.Id = 7;
x.LessonDate = DateTime.Parse("2020-11-18T15:00:00.384Z");
x.MentorId = 2;
x.StudentGroupId = 3;
x.ThemeId = 5;
x.Mentor = mentor;
x.StudentGroup = studentGroup;
x.Theme = theme;
x.Visits = visits;
});
var themeRepositoryMock = new Mock <IThemeRepository>();
themeRepositoryMock.Setup(x => x.Add(It.IsAny <Theme>()))
.Callback <Theme>(x =>
{
x.Id = 5;
x.Name = "ExampleName";
});
_unitOfWorkMock.Setup(x => x.LessonRepository).Returns(lessonRepositoryMock.Object);
_unitOfWorkMock.Setup(x => x.ThemeRepository).Returns(themeRepositoryMock.Object);
var lessonService = new LessonService(
_unitOfWorkMock.Object,
_mapper
);
//Act
var result = await lessonService.CreateLessonAsync(createLessonDto);
//Assert
Assert.NotNull(result);
Assert.Equal(createdLesson.Id, result.Id);
Assert.Equal(createdLesson.LessonDate, result.LessonDate);
Assert.Equal(createdLesson.LessonVisits.Count, result.LessonVisits.Count);
for (int i = 0; i < result.LessonVisits?.Count; i++)
{
Assert.Equal(createdLesson.LessonVisits[i]?.Comment, result.LessonVisits[i]?.Comment);
Assert.Equal(createdLesson.LessonVisits[i]?.Presence, result.LessonVisits[i]?.Presence);
Assert.Equal(createdLesson.LessonVisits[i]?.StudentId, result.LessonVisits[i]?.StudentId);
Assert.Equal(createdLesson.LessonVisits[i]?.StudentMark, result.LessonVisits[i]?.StudentMark);
}
Assert.Equal(createdLesson.MentorId, result.MentorId);
Assert.Equal(createdLesson.StudentGroupId, result.StudentGroupId);
Assert.Equal(createdLesson.ThemeName, result.ThemeName);
}
public Task <int> DeleteItemAsync(StudentGroup item)
{
return(database.DeleteAsync(item));
}
public GroupsInFaculty(StudentGroup group, Faculty faculty)
{
StudentGroup = group;
Faculty = faculty;
}
public async Task <Result <List <StudentGroupFile> > > ImportFileAsync(IFormFile uploadedFile)
{
string path = "";
List <StudentGroupFile> importedGroups = new List <StudentGroupFile>();
if (uploadedFile != null)
{
path = await CreateFile(uploadedFile);
var book = new XLWorkbook(path);
var groupsSheet = book.Worksheet("Groups");
Type studentGroupType = typeof(StudentGroupFile);
char charPointer = 'A';
int rowCounter = 2;
var properties = studentGroupType.GetProperties();
foreach (PropertyInfo property in properties)
{
if (property.Name != Convert.ToString(groupsSheet.Cell($"{charPointer}1").Value))
{
return(Result <List <StudentGroupFile> > .GetError(ErrorCode.ValidationError,
"The format of the downloaded file is not suitable."
+ "Check headers in the file."));
}
charPointer++;
}
while (!IsEndOfFile(rowCounter, groupsSheet))
{
try
{
StudentGroupFile fileLine = new StudentGroupFile
{
CourseId = groupsSheet.Cell($"B{rowCounter}").Value.ToString(),
Name = groupsSheet.Cell($"C{rowCounter}").Value.ToString(),
StartDate = Convert
.ToDateTime(groupsSheet.Cell($"D{rowCounter}").Value),
FinishDate = Convert
.ToDateTime(groupsSheet.Cell($"E{rowCounter}").Value)
};
await IsValueValid(fileLine, rowCounter);
StudentGroup group = new StudentGroup
{
CourseId = Convert.ToInt32(fileLine.CourseId),
Name = fileLine.Name,
StartDate = fileLine.StartDate,
FinishDate = fileLine.FinishDate,
};
importedGroups.Add(fileLine);
_unitOfWork.StudentGroupRepository.Add(group);
rowCounter++;
}
catch (FormatException ex)
{
_unitOfWork.Rollback();
return(Result <List <StudentGroupFile> > .GetError(ErrorCode.ValidationError,
"The format of the inputed data is incorrect.\n" + ex.Message));
}
catch (DbUpdateException ex)
{
_unitOfWork.Rollback();
return(Result <List <StudentGroupFile> >
.GetError(ErrorCode.ValidationError,
"Inputed data is incorrect.\n" + ex.Message));
}
}
}
await _unitOfWork.CommitAsync();
Array.ForEach(Directory.GetFiles(Path.Combine(Directory.GetCurrentDirectory(), "Upload\\files")), File.Delete);
return(Result <List <StudentGroupFile> >
.GetSuccess(_mapper.Map <List <StudentGroupFile> >(importedGroups)));
}
private University Convert()
{
var studentList = new HashSet <Student>(new CustomComparer());
var activeStudies = new HashSet <ActiveStudies>();
foreach (var row in ArrayPersonList)
{
Student student = null;
string wrongStudent = "";
if (row.Length == 9 && !row.Any(item => String.Equals(item, "")))
{
student = new Student(row[0], row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8]);
Boolean exists = false;
foreach (var activeStudy in activeStudies)
{
if (String.Equals(activeStudy.Name, row[2]))
{
exists = true;
activeStudy.NumberOfStudents++;
}
}
if (!exists)
{
activeStudies.Add(new ActiveStudies(row[2], 1));
}
if (!studentList.Add(student))
{
foreach (var item in row)
{
wrongStudent += $" {item}";
}
using (System.IO.StreamWriter file =
new System.IO.StreamWriter(this.LogFile, true)){
file.WriteLine($"ERR: Duplicate student: {wrongStudent}");
}
continue;
}
}
else
{
foreach (var item in row)
{
wrongStudent += $" {item}";
}
using (System.IO.StreamWriter file =
new System.IO.StreamWriter(this.LogFile, true)){
file.WriteLine($"ERR: There are missing values in: {wrongStudent}");
}
}
}
var activeStudiesGroup = new ActiveStudiesGroup(activeStudies);
var studentGroup = new StudentGroup(studentList);
Console.WriteLine($"Converted {studentList.Count()} students");
var university = new University(studentGroup, activeStudiesGroup);
return(university);
//open file writer and create the file
}
public async Task UpdateStudentGroup()
{
//Arrange
long notExistingGroupId = -10;
var updateStudentGroupDto = new UpdateStudentGroupDto()
{
Name = "new_test_name",
CourseId = 2,
StartDate = DateTime.Now,
FinishDate = DateTime.Now.AddMonths(3),
StudentIds = new List <long>(),
MentorIds = new List <long>()
};
var existingNameStudentGroupDto = new UpdateStudentGroupDto()
{
Name = "Test_name",
CourseId = 4,
StartDate = DateTime.Now,
FinishDate = DateTime.Now.AddMonths(3),
StudentIds = new List <long>(),
MentorIds = new List <long>()
};
var existingStudentGroup = new StudentGroup()
{
Id = 10,
Name = "Test_name",
CourseId = 3,
StartDate = DateTime.Now.AddMonths(3),
FinishDate = DateTime.Now.AddMonths(6),
StudentsOfStudentGroups = new List <StudentOfStudentGroup>(),
MentorsOfStudentGroups = new List <MentorOfStudentGroup>()
};
var existingCourse = new Course()
{
Id = 2,
Name = "AAA"
};
var studentGroupRepositoryMock = new Mock <IStudentGroupRepository>();
var studentsRepositoryMock = new Mock <IStudentRepository>();
var mentorsRepositoryMock = new Mock <IMentorRepository>();
var courseRepositoryMock = new Mock <ICourseRepository>();
studentGroupRepositoryMock.Setup(x => x.GetByIdAsync(existingStudentGroup.Id))
.ReturnsAsync(existingStudentGroup);
studentGroupRepositoryMock.Setup(x => x.GetByIdAsync(notExistingGroupId))
.ReturnsAsync((StudentGroup)null);
studentGroupRepositoryMock.Setup(x => x.IsGroupNameExistAsync(updateStudentGroupDto.Name))
.ReturnsAsync(false);
studentGroupRepositoryMock.Setup(x => x.IsGroupNameExistAsync(existingNameStudentGroupDto.Name))
.ReturnsAsync(true);
courseRepositoryMock.Setup(x => x.GetByIdAsync(updateStudentGroupDto.CourseId))
.ReturnsAsync(existingCourse);
studentGroupRepositoryMock.Setup(x => x.UpdateManyToMany(It.IsAny <IList <StudentOfStudentGroup> >(),
It.IsAny <IList <StudentOfStudentGroup> >()));
mentorsRepositoryMock.Setup(x => x.UpdateMentorGroups(It.IsAny <IList <MentorOfStudentGroup> >(),
It.IsAny <IList <MentorOfStudentGroup> >()));
_unitOfWorkMock.Setup(x => x.StudentGroupRepository).Returns(studentGroupRepositoryMock.Object);
_unitOfWorkMock.Setup(x => x.StudentRepository).Returns(studentsRepositoryMock.Object);
_unitOfWorkMock.Setup(x => x.MentorRepository).Returns(mentorsRepositoryMock.Object);
_unitOfWorkMock.Setup(x => x.CourseRepository).Returns(courseRepositoryMock.Object);
var studentGroupService = new StudentGroupService(
_unitOfWorkMock.Object,
_mapper,
_loggerMock.Object
);
//Act
var successResult = await studentGroupService.UpdateStudentGroupAsync(existingStudentGroup.Id, updateStudentGroupDto);
var groupNameExistResult = await studentGroupService.UpdateStudentGroupAsync(existingStudentGroup.Id, existingNameStudentGroupDto);
var groupNotExistResult = await studentGroupService.UpdateStudentGroupAsync(notExistingGroupId, updateStudentGroupDto);
var nullGroupResult = await studentGroupService.UpdateStudentGroupAsync(existingStudentGroup.Id, null);
//Assert
Assert.NotNull(successResult.Data);
Assert.Equal(successResult.Data.Name, successResult.Data.Name);
Assert.Equal(ErrorCode.UnprocessableEntity, groupNameExistResult.Error.Code);
Assert.Equal(ErrorCode.NotFound, groupNotExistResult.Error.Code);
Assert.Equal(ErrorCode.ValidationError, nullGroupResult.Error.Code);
}
public StudentsInGroups(Student student, StudentGroup studentGroup)
{
Student = student;
StudentGroup = studentGroup;
}
public ActionResult AddClass(int lessonId, int classId)
{
//1. Create new ClassLesson
var les = db.Lessons.Find(lessonId);
var cls = db.Classes.Find(classId);
if (les != null && cls != null)
{
var newClsLes = new ClassLesson
{
Class = cls,
Lesson = les
};
db.ClassLessons.Add(newClsLes);
var students = db.Students
.Where(s => s.Class.Id == classId)
.ToList();
//2. Create StudentLesson for all students in the class
foreach (var stu in students)
{
var newStuLes = new StudentLesson
{
Student = stu,
Lesson = les
};
db.StudentLessons.Add(newStuLes);
//3. Create StudentGroup for all students in the class
var groups = db.Groups
.Where(g => g.Lesson.Id == lessonId)
.ToList();
foreach (var grp in groups)
{
var newStuGrp = new StudentGroup
{
Student = stu,
Group = grp
};
db.StudentGroups.Add(newStuGrp);
//4. Create StudentVocabulary for all students in the class
var vocabularies = db.Vocabularies
.Where(v => v.Group.Id == grp.Id)
.ToList();
foreach (var voca in vocabularies)
{
var newStuVocabulary = new StudentVocabulary
{
Student = stu,
Vocabulary = voca,
UpdatedDate = DateTime.Now
};
db.StudentVocabularies.Add(newStuVocabulary);
}
}
}
db.SaveChanges();
}
return(RedirectToAction("Details", new { Id = lessonId }));
}
public StudentsInGroups(Student student, StudentGroup studentGroup)
{
Student = student;
StudentGroup = studentGroup;
}
public ComboboxGroupItem(string Text, StudentGroup Value)
{
this.Text = Text;
this.Value = Value;
}
public async Task UpdateLessonAsync()
{
//Arrange
Theme theme = new Theme
{
Name = "ExampleName",
Id = 5
};
Mentor mentor = new Mentor
{
Id = 2
};
StudentGroup studentGroup = new StudentGroup
{
Id = 3
};
List <VisitDto> visitsDto = new List <VisitDto>()
{
};
var foundLesson = new Lesson()
{
Id = 7,
MentorId = 2,
StudentGroupId = 3,
ThemeId = 5,
Mentor = mentor,
StudentGroup = studentGroup,
Theme = theme,
Visits = { }
};
var updateLessonDto = new UpdateLessonDto
{
ThemeName = null,
LessonDate = DateTime.Parse("2020-11-18T15:30:00.384Z"),
LessonVisits = null
};
var foundLessonDto = new LessonDto()
{
Id = 7,
ThemeName = "ExampleName",
MentorId = 2,
StudentGroupId = 3,
LessonDate = DateTime.Parse("2020-11-18T15:00:00.384Z"),
LessonVisits = null
};
var updatedLesson = new LessonDto()
{
Id = 7,
ThemeName = "ExampleName",
MentorId = 2,
StudentGroupId = 3,
LessonDate = DateTime.Parse("2020-11-18T15:30:00.384Z"),
LessonVisits = visitsDto
};
_unitOfWorkMock.Setup(x => x.LessonRepository.GetByIdAsync(7))
.ReturnsAsync(foundLesson);
var lessonService = new LessonService(
_unitOfWorkMock.Object,
_mapper
);
//Act
var result = await lessonService.UpdateLessonAsync(7, updateLessonDto);
//Assert
Assert.NotNull(result);
Assert.Equal(updatedLesson.Id, result.Id);
Assert.Equal(updatedLesson.LessonDate, result.LessonDate);
Assert.Equal(updatedLesson.LessonVisits, result.LessonVisits);
Assert.Equal(updatedLesson.MentorId, result.MentorId);
Assert.Equal(updatedLesson.StudentGroupId, result.StudentGroupId);
Assert.Equal(updatedLesson.ThemeName, result.ThemeName);
}
public StudentsInGroups(int studentsInGroups, Student student, StudentGroup studentGroup)
{
StudentsInGroupsId = studentsInGroups;
Student = student;
StudentGroup = studentGroup;
}
private void GroupSelected(StudentGroup group)
{
Subjects = group.Subjects.ToObservableCollection();
selectedGroup = group;
}
