private ChalkableGradeBook BuildGradeBook(Gradebook stiGradeBook, GradingPeriod gradingPeriod,
IList <AnnouncementComplex> anns, IList <Student> students)
{
var gradeBook = new ChalkableGradeBook
{
GradingPeriod = gradingPeriod,
Options = ChalkableClassOptions.Create(stiGradeBook.Options),
Averages = stiGradeBook.StudentAverages.Select(ChalkableStudentAverage.Create).ToList(),
Students = students,
Announcements = PrepareAnnouncementDetailsForGradeBook(stiGradeBook, gradingPeriod, anns, students)
};
if (!stiGradeBook.Options.IncludeWithdrawnStudents)
{
gradeBook.Students = new List <Student>();
foreach (var student in students)
{
var score = stiGradeBook.Scores.FirstOrDefault(x => x.StudentId == student.Id);
if (score != null && !score.Withdrawn)
{
gradeBook.Students.Add(student);
}
}
}
return(gradeBook);
}
/// <summary>
/// Updates or creates a resource based on the resource identifier. The PUT operation is used to update or create a resource by identifier. If the resource doesn't exist, the resource will be created using that identifier. Additionally, natural key values cannot be changed using this operation, and will not be modified in the database. If the resource "id" is provided in the JSON body, it will be ignored as well.
/// </summary>
/// <param name="id">A resource identifier specifying the resource to be updated.</param>
/// <param name="IfMatch">The ETag header value used to prevent the PUT from updating a resource modified by another consumer.</param>
/// <param name="body">The JSON representation of the "gradingPeriod" resource to be updated.</param>
/// <returns>A RestSharp <see cref="IRestResponse"/> instance containing the API response details.</returns>
public IRestResponse PutGradingPeriod(string id, string IfMatch, GradingPeriod body)
{
var request = new RestRequest("/gradingPeriods/{id}", Method.PUT);
request.RequestFormat = DataFormat.Json;
request.AddUrlSegment("id", id);
// verify required params are set
if (id == null || body == null)
{
throw new ArgumentException("API method call is missing required parameters");
}
request.AddHeader("If-Match", IfMatch);
request.AddBody(body);
request.Parameters.First(param => param.Type == ParameterType.RequestBody).Name = "application/json";
var response = client.Execute(request);
var location = response.Headers.FirstOrDefault(x => x.Name == "Location");
if (location != null && !string.IsNullOrWhiteSpace(location.Value.ToString()))
{
body.id = location.Value.ToString().Split('/').Last();
}
return(response);
}
protected ShortGradingPeriodViewData(GradingPeriod gradingPeriod)
{
Id = gradingPeriod.Id;
Name = gradingPeriod.Name;
Code = gradingPeriod.Code;
Description = gradingPeriod.Description;
MarkingPeriodId = gradingPeriod.MarkingPeriodRef;
SchoolYearId = gradingPeriod.SchoolYearRef;
StartDate = gradingPeriod.StartDate;
EndDate = gradingPeriod.EndDate;
EndTime = gradingPeriod.EndTime;
}
public async Task <TeacherClassGrading> GetClassGradingSummary(int classId, GradingPeriod gradingPeriod)
{
var gradeBook = await ServiceLocator.GradingStatisticService.GetGradeBook(classId, gradingPeriod);
var gradedCAnnTypes = ServiceLocator.ClassAnnouncementTypeService.CalculateAnnouncementTypeAvg(classId, gradeBook.Announcements);
return(new TeacherClassGrading
{
Announcements = gradeBook.Announcements,
AnnouncementTypes = gradedCAnnTypes,
GradingPeriod = gradeBook.GradingPeriod,
Avg = CalculateAvgByAnnTypes(gradedCAnnTypes)
});
}
private GradingPeriodViewData(GradingPeriod gradingPeriod) : base(gradingPeriod)
{
Id = gradingPeriod.Id;
Name = gradingPeriod.Name;
Code = gradingPeriod.Code;
Description = gradingPeriod.Description;
MarkingPeriodId = gradingPeriod.MarkingPeriodRef;
SchoolYearId = gradingPeriod.SchoolYearRef;
StartDate = gradingPeriod.StartDate;
EndDate = gradingPeriod.EndDate;
EndTime = gradingPeriod.EndTime;
SchoolAnnouncement = gradingPeriod.SchoolAnnouncement;
AllowGradePosting = gradingPeriod.AllowGradePosting;
}
private ChalkableGradeBook GetGradeBooks(int classId, GradingPeriod gradingPeriod, Gradebook gradebook)
{
var students = ServiceLocator.StudentService.GetClassStudents(classId, gradingPeriod.MarkingPeriodRef);
var annQuery = new ClassAnnouncementsQuery
{
ClassId = classId,
FromDate = gradingPeriod.StartDate,
ToDate = gradingPeriod.EndDate
};
//TODO : rewrite this
throw new NotImplementedException();
//var anns = ServiceLocator.ClassAnnouncementService.GetAnnouncementsComplex(annQuery, null, gradebook.Activities.ToList());
//return BuildGradeBook(gradebook, gradingPeriod, anns, students);
}
public async Task <AttendanceSummary> GetAttendanceSummary(int teacherId, GradingPeriod gradingPeriod)
{
var classes = ServiceLocator.ClassService.GetTeacherClasses(gradingPeriod.SchoolYearRef, teacherId, gradingPeriod.MarkingPeriodRef);
if (classes.Count == 0)
{
return(new AttendanceSummary
{
ClassesDaysStat = new List <ClassDailyAttendanceSummary>(),
Students = new List <StudentAttendanceSummary>()
});
}
var classesIds = classes.Select(x => x.Id).ToList();
var attSummarytask = ConnectorLocator.AttendanceConnector.GetSectionAttendanceSummary(classesIds, gradingPeriod.StartDate, gradingPeriod.EndDate);
var students = ServiceLocator.StudentService.GetTeacherStudents(teacherId, gradingPeriod.SchoolYearRef);
var sectionsAttendanceSummary = await attSummarytask;
var res = new AttendanceSummary();
var dailySectionAttendances = new List <DailySectionAbsenceSummary>();
var studentAtts = new List <StudentSectionAbsenceSummary>();
var sectionStSet = new HashSet <Pair <int, int> >();
var sectionDaySet = new HashSet <Pair <int, DateTime> >();
foreach (var sectionAttendanceSummary in sectionsAttendanceSummary)
{
foreach (var dailySectionAtt in sectionAttendanceSummary.Days)
{
var pair = new Pair <int, DateTime>(dailySectionAtt.SectionId, dailySectionAtt.Date);
if (!sectionDaySet.Contains(pair))
{
sectionDaySet.Add(pair);
dailySectionAttendances.Add(dailySectionAtt);
}
}
foreach (var student in sectionAttendanceSummary.Students)
{
var pair = new Pair <int, int>(student.SectionId, student.StudentId);
if (!sectionStSet.Contains(pair))
{
sectionStSet.Add(pair);
studentAtts.Add(student);
}
}
}
studentAtts = studentAtts.Where(x => classesIds.Contains(x.SectionId)).ToList();
res.ClassesDaysStat = ClassDailyAttendanceSummary.Create(dailySectionAttendances, classes);
res.Students = StudentAttendanceSummary.Create(studentAtts, students, classes);
return(res);
}
public async Task <ChalkableGradeBook> GetGradeBook(int classId, GradingPeriod gradingPeriod, int?standardId = null, int?classAnnouncementType = null, bool needsReCalculate = true)
{
Task <Gradebook> stiGradeBook;
var isTeacherClass = DoRead(u => new ClassTeacherDataAccess(u).Exists(classId, Context.PersonId));
if (needsReCalculate && GradebookSecurity.CanReCalculateGradebook(Context, isTeacherClass))
{
stiGradeBook = ConnectorLocator.GradebookConnector.Calculate(classId, gradingPeriod.Id);
}
else
{
stiGradeBook = ConnectorLocator.GradebookConnector.GetBySectionAndGradingPeriod(classId, classAnnouncementType, gradingPeriod.Id, standardId);
}
Trace.WriteLine("GetGradeBooks" + DateTime.Now.Ticks * 1.0 / TimeSpan.TicksPerSecond);
return(GetGradeBooks(classId, gradingPeriod, await stiGradeBook));
}
public async Task <FinalGradeInfo> GetFinalGrade(int classId, GradingPeriod gradingPeriod)
{
var gradeBook = await GetGradeBook(classId, gradingPeriod, null, null, false);
var averageDashBoard = GetAveragesDashboard(gradeBook, classId);
var infractions = ServiceLocator.InfractionService.GetInfractions();
return(new FinalGradeInfo
{
Attendances = FinalStudentAttendance.Create(averageDashBoard.AttendanceSummary),
Disciplines = FinalStudentDiscipline.Create(averageDashBoard.DisciplineSummary, infractions),
GradeBook = gradeBook,
Averages = gradeBook.Averages.GroupBy(x => x.AverageId)
.Select(x => ChalkableAverage.Create(x.Key, x.First().AverageName))
.ToList()
});
}
public static StandardGradingGridViewData Create(GradingPeriod gradingPeriod, IList <GradingStandardInfo> gradingStandardInfos, IList <Student> students)
{
var res = new StandardGradingGridViewData
{
GradingPeriod = GradingPeriodViewData.Create(gradingPeriod),
Students = students.Select(x => GradeStudentViewData.Create(x, x.IsWithdrawn)).ToList()
};
gradingStandardInfos = gradingStandardInfos.Where(x => students.Any(y => y.Id == x.StudentId) &&
gradingPeriod.Id == x.GradingPeriodId).ToList();
res.GradingItems = StandardGradingViewData.Create(gradingStandardInfos, res.Students.Select(x => x.StudentInfo.Id).ToList());
if (res.GradingItems.Count > 0)
{
res.Avg = (int?)res.GradingItems.Average(x => x.NumericAvg);
}
return(res);
}
private ChalkableGradeBook GetGradeBooks(int classId, GradingPeriod gradingPeriod, Gradebook gradebook)
{
int mpId = gradingPeriod.MarkingPeriodRef;
var classRoomOptions = gradebook.Options;
var students = ServiceLocator.StudentService.GetClassStudents(classId, mpId, classRoomOptions == null || classRoomOptions.IncludeWithdrawnStudents ? (bool?)null : true);
var activities = gradebook.Activities
.Where(x => x.SectionId == classId)
.Where(x => x.Date >= gradingPeriod.StartDate)
.Where(x => x.Date <= gradingPeriod.EndDate).ToList();
var activitiesIds = activities.Select(x => x.Id).ToList();
var anns = ServiceLocator.ClassAnnouncementService.GetByActivitiesIds(activitiesIds);
DoUpdate(u => anns = ClassAnnouncementService.MergeAnnouncementsWithActivities(ServiceLocator, u, anns, activities));
return(BuildGradeBook(gradebook, gradingPeriod, anns, students));
}
public static GradingClassSummaryViewData Create(IList <AnnouncementDetails> announcements,
GradingPeriod gradingPeriod, IList <GradedClassAnnouncementType> announcementTypes, double?avg, IList <ClaimInfo> claims)
{
var res = new GradingClassSummaryViewData
{
GradingPeriod = GradingPeriodViewData.Create(gradingPeriod),
Avg = (decimal?)avg,
ByAnnouncementTypes = new List <GradingClassSummaryItemViewData>()
};
if (announcements != null && announcementTypes != null)
{
foreach (var gradedClassAnnouncementType in announcementTypes)
{
var anns = announcements.Where(x => x.ClassAnnouncementData.ClassAnnouncementTypeRef == gradedClassAnnouncementType.Id).ToList();
res.ByAnnouncementTypes.Add(GradingClassSummaryItemViewData.Create(anns, gradedClassAnnouncementType, claims));
}
}
return(res);
}
public static StudentDisciplineSummaryViewData Create(Student student, IList <InfractionSummaryInfo> infractionsSummary
, GradingPeriod currentGradingPeriod, IList <GradingPeriod> gradingPeriods, IList <StudentCustomAlertDetail> customAlerts
, IList <StudentHealthCondition> healthConditions, IList <StudentHealthFormInfo> healthForms)
{
string summary = $"{student.FirstName} is doing great. No discipline issues.";
if (infractionsSummary.Sum(x => x.Occurrences) > 0)
{
summary = $"{student.FirstName} is having disciplinary issues";
}
var disciplineBoxes = infractionsSummary.Select(StudentDisciplineBoxViewData.Create).ToList();
var res = new StudentDisciplineSummaryViewData(student, customAlerts, healthConditions, healthForms)
{
CurrentGradingPeriod = GradingPeriodViewData.Create(currentGradingPeriod),
Summary = summary,
DisciplineBoxes = disciplineBoxes,
Gradingperiods = GradingPeriodViewData.Create(gradingPeriods)
};
return(res);
}
public async Task <AttendanceSummary> GetAttendanceSummary(int teacherId, GradingPeriod gradingPeriod)
{
Trace.Assert(Context.SchoolYearId.HasValue);
var classes = ServiceLocator.ClassService.GetTeacherClasses(gradingPeriod.SchoolYearRef, teacherId, gradingPeriod.MarkingPeriodRef);
var classesIds = classes.Select(x => x.Id).ToList();
var students = ServiceLocator.StudentService.GetTeacherStudents(teacherId, Context.SchoolYearId.Value);
var sectionsAttendanceSummary = GetSectionAttendanceSummary(classesIds, gradingPeriod.StartDate, gradingPeriod.EndDate);
var res = new AttendanceSummary();
var dailySectionAttendances = new List <DailySectionAbsenceSummary>();
var studentAtts = new List <StudentSectionAbsenceSummary>();
foreach (var sectionAttendanceSummary in sectionsAttendanceSummary)
{
dailySectionAttendances.AddRange(sectionAttendanceSummary.Days);
studentAtts.AddRange(sectionAttendanceSummary.Students);
}
res.ClassesDaysStat = ClassDailyAttendanceSummary.Create(dailySectionAttendances, classes);
studentAtts = studentAtts.Where(x => classesIds.Contains(x.SectionId)).ToList();
res.Students = StudentAttendanceSummary.Create(studentAtts, students, classes);
return(res);
}
/// <summary>
/// Creates or updates resources based on the natural key values of the supplied resource. The POST operation can be used to create or update resources. In database terms, this is often referred to as an "upsert" operation (insert + update). Clients should NOT include the resource "id" in the JSON body because it will result in an error (you must use a PUT operation to update a resource by "id"). The web service will identify whether the resource already exists based on the natural key values provided, and update or create the resource appropriately.
/// </summary>
/// <param name="body">The JSON representation of the "gradingPeriod" resource to be created or updated.</param>
/// <returns>A RestSharp <see cref="IRestResponse"/> instance containing the API response details.</returns>
public IRestResponse PostGradingPeriods(GradingPeriod body)
{
var request = new RestRequest("/gradingPeriods", Method.POST);
request.RequestFormat = DataFormat.Json;
// verify required params are set
if (body == null)
{
throw new ArgumentException("API method call is missing required parameters");
}
request.AddBody(body);
var response = client.Execute(request);
var location = response.Headers.FirstOrDefault(x => x.Name == "Location");
if (location != null && !string.IsNullOrWhiteSpace(location.Value.ToString()))
{
body.id = location.Value.ToString().Split('/').Last();
}
return(response);
}
private ChalkableGradeBook BuildGradeBook(Gradebook stiGradeBook, GradingPeriod gradingPeriod, IList <AnnouncementComplex> anns, IList <Student> students)
{
var gradeBook = new ChalkableGradeBook
{
GradingPeriod = gradingPeriod,
Averages = stiGradeBook.StudentAverages.Select(ChalkableStudentAverage.Create).ToList(),
Students = students,
Options = stiGradeBook.Options != null?ChalkableClassOptions.Create(stiGradeBook.Options) : null
};
var includeWithdrawnStudents = gradeBook.Options != null && gradeBook.Options.IncludeWithdrawnStudents;
//Preapred List Of Announcement Info
Trace.WriteLine("PrepareAnnounceemntDetailsForGradeBook " + DateTime.Now.Ticks * 1.0 / TimeSpan.TicksPerSecond);
gradeBook.Announcements = PrepareAnnounceemntDetailsForGradeBook(stiGradeBook, gradingPeriod, anns, students, includeWithdrawnStudents);
//prepare students score
var stiScores = stiGradeBook.Scores;
if (!includeWithdrawnStudents)
{
stiScores = stiScores.Where(x => !x.Withdrawn).ToList();
}
if (stiScores.Any())
{
gradeBook.Students = gradeBook.Students.Where(s => stiScores.Any(score => score.StudentId == s.Id)).ToList();
}
gradeBook.Students = gradeBook.Students
.OrderBy(x => x.LastName, StringComparer.OrdinalIgnoreCase)
.ThenBy(x => x.FirstName, StringComparer.OrdinalIgnoreCase).ToList();
if (stiGradeBook.StudentTotalPoints != null)
{
var totalPoints = stiGradeBook.StudentTotalPoints.Where(x => x.GradingPeriodId == gradingPeriod.Id).ToList();
gradeBook.StudentTotalPoints = StudentTotalPoint.Create(totalPoints);
}
return(gradeBook);
}
public static StudentReportCardsExportModel Create(GradingPeriod gradingPeriod, Student studentData, ReportCardAddressData recipient, bool onlyGradedStandard, bool includeNote)
{
return(new StudentReportCardsExportModel
{
Name = studentData.Name,
AltStudentNumber = studentData.AltStudentNumber,
GradeLevel = studentData.GradeLevel,
StudentId = studentData.StudentId,
Demerits = studentData.Demerits,
Merits = studentData.Merits,
Recipient = RecipientsReportCardsExportModel.Create(recipient),
Classes = ClassReportCardsExportModel.Create(studentData.Sections, onlyGradedStandard, includeNote),
Attendances = AttendanceSummaryExportModel.Create(studentData.Attendance),
GradingPeriod = new GradingPeriodExportModel
{
Announcement = gradingPeriod.Announcement,
StartDate = gradingPeriod.StartDate,
EndDate = gradingPeriod.EndDate,
Name = gradingPeriod.Name
},
HomeRoomTeacher = studentData.HomeroomTeacher,
Promoted = studentData.Promoted
});
}
public GradingPeriodViewModel(GradingPeriod gradingPeriod)
{
this.Id = gradingPeriod.Id;
this.Name = gradingPeriod.Name;
this.isComplete = gradingPeriod.isComplete;
this.Students = new SortableBindingList <StudentViewModel>();
if (gradingPeriod.Students != null)
{
foreach (Student student in gradingPeriod.Students)
{
this.Students.Add(new StudentViewModel(student));
}
}
this.Courses = new SortableBindingList <CourseViewModel>();
if (gradingPeriod.Courses != null)
{
foreach (Course course in gradingPeriod.Courses)
{
this.Courses.Add(new CourseViewModel(course));
}
}
}
public static GradingStandardClassSummaryViewData Create(GradingPeriod gradingPeriod
, IList <GradingStandardInfo> gradingStandards, IList <ClassAnnouncement> announcements
, IList <AnnouncementStandard> announcementStandards, IList <ClaimInfo> claims)
{
var res = new GradingStandardClassSummaryViewData
{
GradingPeriod = GradingPeriodViewData.Create(gradingPeriod),
Items = new List <GradingStandardClassItemViewData>()
};
var gsDic = gradingStandards.GroupBy(x => x.Standard.Id).ToDictionary(x => x.Key, x => x.ToList());
foreach (var kv in gsDic)
{
var annIds = announcementStandards.Where(x => x.StandardRef == kv.Key).Select(x => x.AnnouncementRef).ToList();
var anns = announcements.Where(x => annIds.Contains(x.Id)).ToList();
res.Items.Add(GradingStandardClassItemViewData.Create(anns, kv.Value.Average(x => x.NumericGrade)
, kv.Value.First().Standard, claims));
}
if (res.Items.Count > 0)
{
res.Avg = res.Items.Average(x => x.Avg);
}
return(res);
}
public static StudentAttendanceSummaryViewData Create(StudentAttendanceSummary attendanceSummary, GradingPeriod currentGradingPeriod, IList <GradingPeriod> gradingPeriods
, IList <StudentCustomAlertDetail> customAlerts, IList <StudentHealthCondition> healthConditions, IList <StudentHealthFormInfo> healthForms)
{
var res = new StudentAttendanceSummaryViewData(attendanceSummary.Student, customAlerts, healthConditions, healthForms)
{
GradingPeriods = GradingPeriodViewData.Create(gradingPeriods)
};
if (currentGradingPeriod != null)
{
res.CurrentGradingPeriod = GradingPeriodViewData.Create(currentGradingPeriod);
}
decimal posibleDailyAttendanceCount = 0, dailyLates = 0, dailyAbsents = 0, dailyPresents = 0;
if (attendanceSummary.DailyAttendanceSummary != null)
{
posibleDailyAttendanceCount = attendanceSummary.DailyAttendanceSummary.PosibleAttendanceCount;
dailyLates = attendanceSummary.DailyAttendanceSummary.Tardies ?? 0;
dailyAbsents = attendanceSummary.DailyAttendanceSummary.Absences ?? 0;
dailyPresents = attendanceSummary.DailyAttendanceSummary.Presents ?? 0;
}
res.Absences = PrepareAttendanceBox(dailyAbsents, posibleDailyAttendanceCount, attendanceSummary.ClassAttendanceSummaries, x => x.Absences, 5);
res.Lates = PrepareAttendanceBox(dailyLates, posibleDailyAttendanceCount, attendanceSummary.ClassAttendanceSummaries, x => x.Tardies, 10);
res.Presents = PrepareAttendanceBox(dailyPresents, posibleDailyAttendanceCount, attendanceSummary.ClassAttendanceSummaries, x => x.Presents, 0, true);
return(res);
}
public static StudentProfileGradingSummaryViewData Create(Student student, IList <ChalkableStudentAverage> studentAverages, GradingPeriod currentGradingPeriod
, IList <GradingPeriod> gradingPeriods, IList <Class> classes, IEnumerable <int> enrolledClassIds
, IList <StudentCustomAlertDetail> customAlerts, IList <StudentHealthCondition> healthConditions
, IList <StudentHealthFormInfo> healthForms)
{
var avgs = studentAverages.Where(x => enrolledClassIds.Contains(x.ClassId)).ToList();
var gradings = new List <StudentGradingsViewData>();
foreach (var gp in gradingPeriods)
{
var gpAvgs = avgs.Where(x => x.GradingPeriodId == gp.Id).ToList();
var classAvgs = gpAvgs.GroupBy(x => x.ClassId)
.Select(x => StudentClassAvgViewData.Create(classes.First(y => y.Id == x.Key), x));
gradings.Add(new StudentGradingsViewData
{
GradingPeriod = GradingPeriodViewData.Create(gp),
ClassAvgs = classAvgs.ToList()
});
}
return(new StudentProfileGradingSummaryViewData
{
Student = StudentProfileViewData.Create(student, customAlerts, healthConditions, healthForms),
CurrentGradingPeriod = GradingPeriodViewData.Create(currentGradingPeriod),
GradesByGradingPeriod = gradings.ToList()
});;
}
public new static GradingPeriodViewData Create(GradingPeriod gradingPeriod)
{
return(new GradingPeriodViewData(gradingPeriod));
}
private async Task <GradingPeriodFinalGradeViewData> GetGradingPeriodFinalGrade(int classId, GradingPeriod gradingPeriod, int?averageId)
{
if (!Context.SchoolLocalId.HasValue)
{
throw new UnassignedUserException();
}
var finalGrade = await SchoolLocator.GradingStatisticService.GetFinalGrade(classId, gradingPeriod);
var average = finalGrade.Averages.FirstOrDefault(x => !averageId.HasValue || x.AverageId == averageId);
return(GradingPeriodFinalGradeViewData.Create(finalGrade, average, Context.Claims));
}
private IList <AnnouncementDetails> PrepareAnnounceemntDetailsForGradeBook(Gradebook stiGradeBook, GradingPeriod gradingPeriod
, IList <AnnouncementComplex> anns, IList <Student> students, bool inludeWithdrawnStudent)
{
var activities = stiGradeBook.Activities.Where(x => x.Date >= gradingPeriod.StartDate &&
x.Date <= gradingPeriod.EndDate && x.IsScored).ToList();
var annsDetails = new List <AnnouncementDetails>();
var classTeachers = ServiceLocator.ClassService.GetClassTeachers(stiGradeBook.SectionId, null);
var alternateScores = ServiceLocator.AlternateScoreService.GetAlternateScores();
foreach (var activity in activities)
{
var ann = anns.FirstOrDefault(x => x.ClassAnnouncementData.SisActivityId == activity.Id);
if (ann == null)
{
throw new ChalkableException(string.Format("No announcements with sis activity id = {0}", activity.Id));
}
var annDetails = new AnnouncementDetails
{
Id = ann.Id,
AnnouncementData = ann.ClassAnnouncementData,
Title = ann.Title,
StudentAnnouncements = new List <StudentAnnouncementDetails>(),
IsOwner = classTeachers.Any(x => x.PersonRef == Context.PersonId)
};
MapperFactory.GetMapper <AnnouncementDetails, Activity>().Map(annDetails, activity);
var scores = stiGradeBook.Scores.Where(x => x.ActivityId == activity.Id).ToList();
if (!inludeWithdrawnStudent)
{
scores = scores.Where(x => !x.Withdrawn).ToList();
}
foreach (var score in scores)
{
var student = students.FirstOrDefault(x => x.Id == score.StudentId);
if (student == null)
{
continue;
}
var stAnn = new StudentAnnouncementDetails
{
AnnouncementId = ann.Id,
ClassId = ann.ClassAnnouncementData.ClassRef,
Student = student,
};
MapperFactory.GetMapper <StudentAnnouncementDetails, Score>().Map(stAnn, score);
if (stAnn.AlternateScoreId.HasValue)
{
stAnn.AlternateScore = alternateScores.FirstOrDefault(x => x.Id == stAnn.AlternateScoreId.Value);
}
annDetails.StudentAnnouncements.Add(stAnn);
}
annDetails.StudentAnnouncements = annDetails.StudentAnnouncements.OrderBy(x => x.Student.LastName).ThenBy(x => x.Student.FirstName).ToList();
annsDetails.Add(annDetails);
}
return(annsDetails);
}
public async Task <IList <ShortClassGradesSummary> > GetClassesGradesSummary(int teacherId, GradingPeriod gradingPeriod)
{
Trace.Assert(Context.SchoolYearId.HasValue);
var classesDetails = ServiceLocator.ClassService.GetTeacherClasses(gradingPeriod.SchoolYearRef, teacherId, gradingPeriod.MarkingPeriodRef);
var classesIds = classesDetails.Select(x => x.Id).ToList();
var stiSectionsGrades = GetSectionGradesSummary(classesIds, gradingPeriod.Id);
var students = ServiceLocator.StudentService.GetTeacherStudents(teacherId, Context.SchoolYearId.Value);
var res = new List <ShortClassGradesSummary>();
foreach (var sectionGrade in stiSectionsGrades)
{
var classesDetail = classesDetails.FirstOrDefault(x => x.Id == sectionGrade.SectionId);
res.Add(ShortClassGradesSummary.Create(sectionGrade, classesDetail, students));
}
return(res);
}
public async Task <ChalkableGradeBook> GetGradeBook(int classId, GradingPeriod gradingPeriod, int?standardId = null, int?classAnnouncementType = null, bool needsReCalculate = true)
{
var stiGradeBook = GetBySectionAndGradingPeriod(classId, classAnnouncementType, gradingPeriod.Id, standardId);
return(GetGradeBooks(classId, gradingPeriod, stiGradeBook));
}
public async Task <IList <ShortClassGradesSummary> > GetClassesGradesSummary(int teacherId, GradingPeriod gradingPeriod)
{
var classesDetails = ServiceLocator.ClassService.GetTeacherClasses(gradingPeriod.SchoolYearRef, teacherId, gradingPeriod.MarkingPeriodRef);
if (classesDetails.Count == 0)
{
return(new List <ShortClassGradesSummary>());
}
var classesIds = classesDetails.Select(x => x.Id).ToList();
var stiSectionsGradesTask = ConnectorLocator.GradebookConnector.GetSectionGradesSummary(classesIds, gradingPeriod.Id);
var students = ServiceLocator.StudentService.GetTeacherStudents(teacherId, gradingPeriod.SchoolYearRef);
var res = new List <ShortClassGradesSummary>();
var stiSectionsGrades = await stiSectionsGradesTask;
foreach (var sectionGrades in stiSectionsGrades)
{
var classesDetail = classesDetails.FirstOrDefault(x => x.Id == sectionGrades.SectionId);
res.Add(ShortClassGradesSummary.Create(sectionGrades, classesDetail, students));
}
return(res);
}
private IList <AnnouncementDetails> PrepareAnnouncementDetailsForGradeBook(Gradebook stiGradeBook, GradingPeriod gradingPeriod
, IList <AnnouncementComplex> anns, IList <Student> students)
{
var activities = stiGradeBook.Activities.Where(x => x.Date >= gradingPeriod.StartDate &&
x.Date <= gradingPeriod.EndDate && x.IsScored).ToList();
var annsDetails = new List <AnnouncementDetails>();
var classTeachers = ServiceLocator.ClassService.GetClassTeachers(stiGradeBook.SectionId, null);
foreach (var activity in activities)
{
var ann = anns.FirstOrDefault(x => x.ClassAnnouncementData.SisActivityId == activity.Id);
var annDetails = new AnnouncementDetails
{
Id = ann.Id,
Title = ann.Title,
AnnouncementData = ann.ClassAnnouncementData,
StudentAnnouncements = new List <StudentAnnouncementDetails>(),
IsOwner = classTeachers.Any(x => x.PersonRef == Context.PersonId)
};
MapperFactory.GetMapper <AnnouncementDetails, Activity>().Map(annDetails, activity);
var scores = stiGradeBook.Scores.Where(x => x.ActivityId == activity.Id).ToList();
if (!stiGradeBook.Options.IncludeWithdrawnStudents)
{
scores = scores.Where(x => !x.Withdrawn).ToList();
}
foreach (var score in scores)
{
var student = students.FirstOrDefault(x => x.Id == score.StudentId);
if (student == null)
{
continue;
}
var stAnn = new StudentAnnouncementDetails
{
AnnouncementId = ann.Id,
ClassId = ann.ClassAnnouncementData.ClassRef,
Student = student,
};
MapperFactory.GetMapper <StudentAnnouncementDetails, Score>().Map(stAnn, score);
annDetails.StudentAnnouncements.Add(stAnn);
}
annsDetails.Add(annDetails);
}
return(annsDetails);
}
protected GradingGridSummaryViewData(GradingPeriod gradingPeriod, int?avg)
{
Avg = avg;
GradingPeriod = GradingPeriodViewData.Create(gradingPeriod);
}
public static GradingGridSummaryViewData Create(GradingPeriod gradingPeriod, int?avg)
{
return(new GradingGridSummaryViewData(gradingPeriod, avg));
}
