public IDictionary <Period, PeriodData> GetPeriodData(string schoolkey, int periodLength)
{
string cacheKey = "PeriodLength:" + periodLength + ":PeriodData:" + schoolkey;
IDictionary <Period, PeriodData> periodData;
if (_memoryCache.TryGetValue(cacheKey, out periodData))
{
return(periodData);
}
var schoolCalendarDays = StudentDataRepository.GetSchoolCalendarDays(schoolkey);
IReadOnlyCollection <Period> Periods = Enum.GetValues(typeof(Period))
.Cast <Period>()
.ToArray();
periodData = new SortedList <Period, PeriodData>();
foreach (var period in Periods)
{
periodData[period] = new PeriodData();
}
schoolCalendarDays.ForEach((Action <SchoolCalendarDim>)(schoolCalendarDay =>
{
var periodIndex = schoolCalendarDay.GetPeriodIndex(periodLength);
if (periodIndex > 2)
{
return;
}
var period = (Period)periodIndex;
var periodDatum = periodData[period];
periodDatum.CalendarDates.Add(schoolCalendarDay.Date);
}));
int i = 0;
foreach (var periodDatum in periodData.Values)
{
if (periodDatum.CalendarDates.Count < periodLength)
{
periodDatum.CalendarDates.Clear();
}
i++;
}
var cacheEntryOptions = new MemoryCacheEntryOptions()
.SetSize(200)//Size amount
.SetPriority(CacheItemPriority.High)
.SetSlidingExpiration(TimeSpan.FromMinutes(15))
.SetAbsoluteExpiration(TimeSpan.FromMinutes(60));
_memoryCache.Set(cacheKey, periodData, cacheEntryOptions);
return(periodData);
}
public override IDictionary <string, List <StudentMetric> > GetAllStudentMetricsForSchool(string schoolKey)
{
string cacheKey = "schoolKey:" + schoolKey + " MetricId:" + GetMetricId();
IDictionary <string, List <StudentMetric> > returnMap;
if (_memoryCache.TryGetValue(cacheKey, out returnMap))
{
return(returnMap);
}
returnMap = new Dictionary <string, List <StudentMetric> >();
IDictionary <string, List <StudentAttendanceEvent> > studentAttendanceEventDictionary = getStudentAttendanceEvents(schoolKey);
IDictionary <string, List <StudentSchoolDim> > studentSchoolAssociationsDictionary = StudentDataRepository.GetStudentSchoolAssociationsDictionary(schoolKey);
IDictionary <string, List <StudentSectionDim> > studentSectionAssociationsDictionary = getStudentSectionAssociationsDictionary(schoolKey);
foreach (string studentKey in studentAttendanceEventDictionary.Keys)
{
List <StudentAttendanceEvent> studentAttendanceEvents = studentAttendanceEventDictionary[studentKey];
List <StudentSchoolDim> studentSchoolAssociations = studentSchoolAssociationsDictionary.ContainsKey(studentKey) ? studentSchoolAssociationsDictionary[studentKey] : new List <StudentSchoolDim>();
List <StudentSectionDim> studentSectionAssociations = studentSectionAssociationsDictionary.ContainsKey(studentKey) ? studentSectionAssociationsDictionary[studentKey] : new List <StudentSectionDim>();
int metricCount = GetMetricCount(studentAttendanceEvents);
HashSet <DateTime> schoolCalendarDaysAsSet = new HashSet <DateTime>();
StudentDataRepository.GetSchoolCalendarDays(schoolKey).ForEach(s => schoolCalendarDaysAsSet.Add(s.Date));
var daysStudentWasEnrolled = GetDaysStudentWasEnrolled(true, schoolCalendarDaysAsSet, studentSchoolAssociations, studentSectionAssociations).Count;
decimal ytdClassPeriodAttendanceRate = GetYtdAttendanceRate(metricCount, daysStudentWasEnrolled);
var metricStateType = _metricInfo.GetMetricStateType(ytdClassPeriodAttendanceRate, null);
var metricState = MetricUtility.GetMetricState(metricStateType.Value);
if (!returnMap.ContainsKey(studentKey))
{
returnMap[studentKey] = new List <StudentMetric>();
}
returnMap[studentKey].Add(new StudentMetric
{
Id = _metricInfo.Id,
Name = _metricInfo.DisplayName,
Value = ytdClassPeriodAttendanceRate.Display().DisplayValue(DISPLAY_FORMAT_ATTENDANCE_RATE),
State = metricState,
TrendDirection = null,
});
}
_memoryCache.Set(cacheKey, returnMap, _cacheEntryOptions);
return(returnMap);
}
public void ResizeImage(String indexNo)
{
StudentDataRepository sdr = new StudentDataRepository();
Student student = sdr.GetStudent(indexNo);
if (student == null)
{
Trace.TraceInformation(String.Format("Student sa brojem indeksa {0} ne postoji!", indexNo), "Information");
return;
}
BlobHelper blobHelper = new BlobHelper();
string uniqueBlobName = string.Format("image_{0}", student.RowKey);
Image image = blobHelper.DownloadImage("vezba", uniqueBlobName);
image = ImageConvertes.ConvertImage(image);
string thumbnailUrl = blobHelper.UploadImage(image, "vezba", uniqueBlobName +
"thumb");
student.ThumbnailUrl = thumbnailUrl;
sdr.AddOrReplaceStudent(student);
}
public IDictionary <DateTime, Period> GetSchoolDaysPeriod(string schoolkey, int?periodLength)
{
string cacheKey = "SchoolDaysPeriod:" + schoolkey + ":PeriodLength" + (ReportingPeriodLength.HasValue ? ReportingPeriodLength.Value : 99999);
IDictionary <DateTime, Period> schoolDaysPeriod;
if (_memoryCache.TryGetValue(cacheKey, out schoolDaysPeriod))
{
return(schoolDaysPeriod);
}
schoolDaysPeriod = new Dictionary <DateTime, Period>();
var schoolCalendarDays = StudentDataRepository.GetSchoolCalendarDays(schoolkey);
IReadOnlyCollection <Period> Periods = Enum.GetValues(typeof(Period)).Cast <Period>().ToArray();
schoolCalendarDays.ForEach(schoolCalendarDay =>
{
var periodIndex = (periodLength == null) ? (int)Period.First : schoolCalendarDay.GetPeriodIndex(periodLength.Value);
if (periodIndex > Periods.Count)
{
return;
}
var period = (Period)periodIndex;
schoolDaysPeriod[schoolCalendarDay.Date] = period;
});
var cacheEntryOptions = new MemoryCacheEntryOptions()
.SetSize(200)//Size amount
.SetPriority(CacheItemPriority.High)
.SetSlidingExpiration(TimeSpan.FromMinutes(15))
.SetAbsoluteExpiration(TimeSpan.FromMinutes(60));
_memoryCache.Set(cacheKey, schoolDaysPeriod, cacheEntryOptions);
return(schoolDaysPeriod);
}
public override IDictionary <string, List <StudentMetric> > GetAllStudentMetricsForSchool(string schoolKey)
{
string cacheKey = "schoolKey:" + schoolKey + " MetricId:" + GetMetricId();
IDictionary <string, List <StudentMetric> > returnMap;
if (_memoryCache.TryGetValue(cacheKey, out returnMap))
{
return(returnMap);
}
int periodLength = GetPeriodLength();
returnMap = new Dictionary <string, List <StudentMetric> >();
IDictionary <Period, PeriodData> periodDataDictionary = GetPeriodData(schoolKey, periodLength);
PeriodData firstPeriodData = periodDataDictionary[Period.First];
PeriodData secondPeriodData = periodDataDictionary[Period.Second];
IDictionary <string, List <StudentAttendanceEvent> > studentAttendanceEventDictionary = getStudentAttendanceEvents(schoolKey);
IDictionary <string, List <StudentSchoolDim> > studentSchoolAssociationsDictionary = StudentDataRepository.GetStudentSchoolAssociationsDictionary(schoolKey);
IDictionary <string, List <StudentSectionDim> > studentSectionAssociationsDictionary = getStudentSectionAssociationsDictionary(schoolKey);
foreach (string studentKey in studentAttendanceEventDictionary.Keys)
{
List <StudentAttendanceEvent> studentAttendanceEvents = studentAttendanceEventDictionary[studentKey];
List <StudentSchoolDim> studentSchoolAssociations = studentSchoolAssociationsDictionary.ContainsKey(studentKey) ? studentSchoolAssociationsDictionary[studentKey] : new List <StudentSchoolDim>();
List <StudentSectionDim> studentSectionAssociations = studentSectionAssociationsDictionary.ContainsKey(studentKey) ? studentSectionAssociationsDictionary[studentKey] : new List <StudentSectionDim>();
//var firstPeriodAttendanceEvents = studentAttendanceEvents.Where(studentAttendanceEvent => firstPeriodData.CalendarDates.Any()
// && studentAttendanceEvent.EventDate.IsBetween(firstPeriodData.CalendarDates.Min(), firstPeriodData.CalendarDates.Max()));
List <StudentAttendanceEvent> firstPeriodMetricAttendanceEvents = GetMetricAttendanceEvents(studentAttendanceEvents, firstPeriodData);
//var firstPeriodDailyAttendanceRateAttendanceEvents = firstPeriodAttendanceEvents.Where(studentAttendanceEvent => studentAttendanceEvent.IsForDailyAttendance()
// && (studentAttendanceEvent.AttendanceEventCategoryDescriptor.Equals(AttendanceEventCategoryDescriptor.ExcusedAbsence)
// || studentAttendanceEvent.AttendanceEventCategoryDescriptor.Equals(AttendanceEventCategoryDescriptor.UnexcusedAbsence)))
// .DistinctBy(studentAttendanceEvent => studentAttendanceEvent.EventDate)
// .ToList();
List <StudentAttendanceEvent> secondPeriodMetricAttendanceEvents = GetMetricAttendanceEvents(studentAttendanceEvents, secondPeriodData);
var firstPeriodDenominator = GetDaysStudentWasEnrolled(IsClassPeriodAbsenceRateMetric(), firstPeriodData.CalendarDates, studentSchoolAssociations, studentSectionAssociations).Count;
if (firstPeriodDenominator >= periodLength)
{
var secondPeriodDenominator = GetDaysStudentWasEnrolled(IsClassPeriodAbsenceRateMetric(), secondPeriodData.CalendarDates, studentSchoolAssociations, studentSectionAssociations).Count;
var firstPeriodNumerator = GetPeriodNumerator(firstPeriodMetricAttendanceEvents, firstPeriodDenominator);
var firstPeriodRatio = ((decimal)firstPeriodNumerator / firstPeriodDenominator).RoundTo(3);
var secondPeriodNumerator = GetPeriodNumerator(secondPeriodMetricAttendanceEvents, secondPeriodDenominator);
int? trend;
bool flag;
GetTrendByAttendance(firstPeriodDenominator, secondPeriodDenominator, firstPeriodNumerator, secondPeriodNumerator, _metricInfo.RateDirection, out trend, out flag);
var metricStateType = _metricInfo.GetMetricStateType(firstPeriodRatio, null);
var metricState = MetricUtility.GetMetricState(metricStateType.Value);
if (!returnMap.ContainsKey(studentKey))
{
returnMap[studentKey] = new List <StudentMetric>();
}
returnMap[studentKey].Add(new StudentMetric
{
Id = _metricInfo.Id,
Name = string.Format(_metricInfo.DisplayName, periodLength),
Value = firstPeriodRatio.Display().DisplayValue(DISPLAY_FORMAT_ATTENDANCE_RATE),
TrendDirection = trend ?? null,
State = metricState
});
}
}
_memoryCache.Set(cacheKey, returnMap, _cacheEntryOptions);
return(returnMap);
}
protected override IDictionary <string, StudentAssessmentDim> GetStudentAssessments(string schoolKey)
{
IDictionary <string, StudentAssessmentDim> studentAssessmentsDictionary;
string cacheKey = "StudentSchoolAssessments" + schoolKey + "MetricId:" + GetMetricId();
if (_memoryCache.TryGetValue(cacheKey, out studentAssessmentsDictionary))
{
return(studentAssessmentsDictionary);
}
studentAssessmentsDictionary = new Dictionary <string, StudentAssessmentDim>();
var schoolDays = StudentDataRepository.GetSchoolCalendarDays(schoolKey).Select(calendarDay => calendarDay.Date).ToList();
var schoolMinMaxDateDim = _context.SchoolMinMaxDateDims.Where(s => s.SchoolKey.Equals(schoolKey.ToString())).FirstOrDefault();
if (schoolMinMaxDateDim == null)
{
return(studentAssessmentsDictionary);
}
var studentAssessmentsDbRecords = GetStudentAssessmentsDbRecords(schoolKey);
foreach (var studentAssessmentDbRecord in studentAssessmentsDbRecords)
{
if (studentAssessmentDbRecord.Value.Assessments.Any())
{
List <StudentAssessmentDim> studentAssessmentDims = new List <StudentAssessmentDim>();
foreach (var assessmentDim in studentAssessmentDbRecord.Value.Assessments)
{
if (assessmentDim.AdministrationDate > schoolMinMaxDateDim.MaxDate)
{
continue;
}
if (!(AcademicSubjects.Contains(assessmentDim.AcademicSubject) && AssessmentCategories.Contains(assessmentDim.AssessmentCategory)))
{
continue;
}
if (!studentAssessmentDbRecord.Value.ScoreResults.Any())
{
continue;
}
var scoreResults = studentAssessmentDbRecord.Value.ScoreResults.Where(sr => sr.StudentAssessmentIdentifier.Equals(assessmentDim.StudentAssessmentIdentifier, StringComparison.Ordinal) &&
sr.AssessmentIdentifier.Equals(assessmentDim.AssessmentIdentifier, StringComparison.Ordinal) &&
sr.Namespace.Equals(assessmentDim.Namespace, StringComparison.Ordinal) &&
sr.ReportingMethod.Equals(AssessmentReportingMethodType, StringComparison.Ordinal))
.ToList();
if (!scoreResults.Any())
{
continue;
}
assessmentDim.ScoreResults = scoreResults;
studentAssessmentDims.Add(assessmentDim);
}
if (studentAssessmentDims.Any())
{
var mostRecentAssessment = studentAssessmentDims.Where(assessment => string.IsNullOrEmpty(assessment.ReasonNotTested))
.OrderByDescending(assessment => assessment.AdministrationDate).FirstOrDefault();
if (mostRecentAssessment != null)
{
var numerator = mostRecentAssessment.ScoreResults.Single(x => x.ReportingMethod.Equals(AssessmentReportingMethodType)).Result.ToNullableDecimal();
var assessmentRatio = numerator.DivideBySafeAndRound(mostRecentAssessment.MaxScoreResult);
if (assessmentRatio == null)
{
continue;
}
mostRecentAssessment.BenchmarkAssessmentRatio = assessmentRatio;
studentAssessmentsDictionary[mostRecentAssessment.StudentKey] = mostRecentAssessment;
}
}
else
{
studentAssessmentsDictionary[studentAssessmentDbRecord.Key] = null;
}
}
}
var cacheEntryOptions = new MemoryCacheEntryOptions()
.SetSize(200)//Size amount
.SetPriority(CacheItemPriority.High)
.SetSlidingExpiration(TimeSpan.FromMinutes(15))
.SetAbsoluteExpiration(TimeSpan.FromMinutes(60));
_memoryCache.Set(cacheKey, studentAssessmentsDictionary, cacheEntryOptions);
return(studentAssessmentsDictionary);
}
protected override IDictionary <string, StudentAssessmentDim> GetStudentAssessments(string schoolKey)
{
IDictionary <string, StudentAssessmentDim> studentAssessmentsDictionary;
string cacheKey = "StudentSchoolAssessments" + schoolKey + "MetricId:" + GetMetricId();
if (_memoryCache.TryGetValue(cacheKey, out studentAssessmentsDictionary))
{
return(studentAssessmentsDictionary);
}
studentAssessmentsDictionary = new Dictionary <string, StudentAssessmentDim>();
var schoolDays = StudentDataRepository.GetSchoolCalendarDays(schoolKey).Select(calendarDay => calendarDay.Date).ToList();
var schoolMinMaxDateDim = _context.SchoolMinMaxDateDims.Where(s => s.SchoolKey.Equals(schoolKey.ToString())).FirstOrDefault();
if (schoolMinMaxDateDim == null)
{
return(studentAssessmentsDictionary);
}
var studentAssessmentsDbRecords = GetStudentAssessmentsDbRecords(schoolKey);
foreach (var studentAssessmentDbRecord in studentAssessmentsDbRecords)
{
if (studentAssessmentDbRecord.Value.Assessments.Any())
{
StudentAssessmentDim studentAssessment = new StudentAssessmentDim {
AssessmentCorrectItems = 0, AssessmentTotalItems = 0
};
foreach (var assessmentDim in studentAssessmentDbRecord.Value.Assessments)
{
if (assessmentDim.AdministrationDate > schoolMinMaxDateDim.MaxDate)
{
continue;
}
if (!schoolDays.Contains(assessmentDim.AdministrationDate))
{
continue;
}
if (!(AcademicSubjects.Contains(assessmentDim.AcademicSubject) && AssessmentCategories.Contains(assessmentDim.AssessmentCategory)))
{
continue;
}
if (!studentAssessmentDbRecord.Value.ScoreResults.Any())
{
continue;
}
if (!studentAssessmentDbRecord.Value.AssessmentItems.Any())
{
continue;
}
var assessmentItems = studentAssessmentDbRecord.Value.AssessmentItems.Where(sr => sr.StudentAssessmentIdentifier.Equals(assessmentDim.StudentAssessmentIdentifier, StringComparison.Ordinal) &&
sr.AssessmentIdentifier.Equals(assessmentDim.AssessmentIdentifier, StringComparison.Ordinal) &&
sr.Namespace.Equals(assessmentDim.Namespace, StringComparison.Ordinal))
.ToList();
if (!assessmentItems.Any())
{
continue;
}
studentAssessment.AssessmentTotalItems += assessmentItems.Count();
studentAssessment.AssessmentCorrectItems += assessmentItems.Where(ai => AssessmentItemResults.Contains(ai.AssessmentItemResult)).Count();
}
studentAssessmentsDictionary[studentAssessmentDbRecord.Key] = studentAssessment;
}
}
var cacheEntryOptions = new MemoryCacheEntryOptions()
.SetSize(200)//Size amount
.SetPriority(CacheItemPriority.High)
.SetSlidingExpiration(TimeSpan.FromMinutes(15))
.SetAbsoluteExpiration(TimeSpan.FromMinutes(60));
_memoryCache.Set(cacheKey, studentAssessmentsDictionary, cacheEntryOptions);
return(studentAssessmentsDictionary);
}
protected IDictionary <string, StudentAssessment> GetStudentAssessmentsDbRecords(string schoolKey)
{
IDictionary <string, StudentAssessment> studentAssessmentDictionary;
string cacheKey = "StudentAssessmentsDbRecords" + schoolKey;
if (_memoryCache.TryGetValue(cacheKey, out studentAssessmentDictionary))
{
return(studentAssessmentDictionary);
}
studentAssessmentDictionary = new Dictionary <string, StudentAssessment>();
IDictionary <string, List <StudentSchoolDim> > studentSchoolAssociationsDictionary = StudentDataRepository.GetStudentSchoolAssociationsDictionary(schoolKey);
List <string> studentUniqueIds = studentSchoolAssociationsDictionary.Select(d => d.Key).ToList();
var studentAssessmentDbRecords = (from studentAssessment in _context.StudentAssessmentDims.AsNoTracking()
where studentAssessment.SchoolKey.Equals(schoolKey) && studentUniqueIds.Contains(studentAssessment.StudentKey)
select studentAssessment)
.ToList()
.OrderBy(a => a.StudentKey);
var studentAssessmentDbRecordsDictionary = studentAssessmentDbRecords
.GroupBy(x => x.StudentKey)
.ToDictionary(x => x.Key, x => x.ToList()
.OrderBy(a => a.AdministrationDate));
var studentAssessmentScoreResultsDbRecords = (from sasrd in _context.StudentAssessmentScoreResultDims.AsNoTracking()
where sasrd.SchoolKey.Equals(schoolKey) && studentUniqueIds.Contains(sasrd.StudentKey)
select sasrd)
.ToList()
.OrderBy(a => a.StudentKey);
var studentAssessmentScoreResultsDbRecordsDictionary = studentAssessmentScoreResultsDbRecords
.GroupBy(x => x.StudentKey)
.ToDictionary(x => x.Key, x => x.ToList()
.OrderBy(a => a.AdministrationDate));
var studentAssessmentItemsDbRecords = (from sasrd in _context.StudentAssessmentItemDims.AsNoTracking()
where sasrd.SchoolKey.Equals(schoolKey) && studentUniqueIds.Contains(sasrd.StudentKey)
select sasrd)
.ToList()
.OrderBy(a => a.StudentKey);
var studentAssessmentItemsDbRecordsDictionary = studentAssessmentItemsDbRecords
.GroupBy(x => x.StudentKey)
.ToDictionary(x => x.Key, x => x.ToList()
.OrderBy(a => a.AdministrationDate));
foreach (var studentUniqueId in studentUniqueIds)
{
var studentAssessment = new StudentAssessment {
StudentKey = studentUniqueId
};
if (studentAssessmentDbRecordsDictionary.ContainsKey(studentUniqueId))
{
studentAssessment.Assessments = studentAssessmentDbRecordsDictionary[studentUniqueId].ToList();
}
if (studentAssessmentScoreResultsDbRecordsDictionary.ContainsKey(studentUniqueId))
{
studentAssessment.ScoreResults = studentAssessmentScoreResultsDbRecordsDictionary[studentUniqueId].ToList();
}
if (studentAssessmentItemsDbRecordsDictionary.ContainsKey(studentUniqueId))
{
studentAssessment.AssessmentItems = studentAssessmentItemsDbRecordsDictionary[studentUniqueId].ToList();
}
studentAssessmentDictionary[studentUniqueId] = studentAssessment;
}
var cacheEntryOptions = new MemoryCacheEntryOptions()
.SetSize(1000)//Size amount
.SetPriority(CacheItemPriority.High)
.SetSlidingExpiration(TimeSpan.FromMinutes(15))
.SetAbsoluteExpiration(TimeSpan.FromMinutes(60));
_memoryCache.Set(cacheKey, studentAssessmentDictionary, cacheEntryOptions);
return(studentAssessmentDictionary);
}
protected IDictionary <string, SortedList <GradingPeriodDim, StudentCourseGradingPeriodCalculation> > GetStudentGradingPeriods(string schoolKey)
{
IDictionary <string, SortedList <GradingPeriodDim, StudentCourseGradingPeriodCalculation> > studentGradingPeriodsDictionary;
string cacheKey = "StudentSchoolAssessments" + schoolKey + "MetricId:" + GetMetricId();
if (_memoryCache.TryGetValue(cacheKey, out studentGradingPeriodsDictionary))
{
return(studentGradingPeriodsDictionary);
}
studentGradingPeriodsDictionary = new Dictionary <string, SortedList <GradingPeriodDim, StudentCourseGradingPeriodCalculation> >();
var schoolMinMaxDateDim = _context.SchoolMinMaxDateDims.Where(s => s.SchoolKey.Equals(schoolKey)).FirstOrDefault();
if (schoolMinMaxDateDim == null || !schoolMinMaxDateDim.MaxDate.HasValue)
{
return(studentGradingPeriodsDictionary);
}
DateTime currentSchoolDay = schoolMinMaxDateDim.MaxDate.Value;
List <GradingPeriodDim> gradingPeriodDims = StudentDataRepository.GetSchoolGradingPeriods(schoolKey);
if (!gradingPeriodDims.Any())
{
return(studentGradingPeriodsDictionary);
}
IDictionary <string, List <StudentSectionDim> > studentSectionAssociationsDictionary = StudentDataRepository.GetStudentSectionAssociationsDictionary(schoolKey);
IDictionary <string, List <StudentSchoolDim> > studentSchoolAssociationsDictionary = StudentDataRepository.GetStudentSchoolAssociationsDictionary(schoolKey);
IDictionary <string, List <StudentGradeDim> > studentGradeDbRecords = GetStudentGradeDbRecords(schoolKey);
IDictionary <string, List <StudentGrade> > studentGrades = new Dictionary <string, List <StudentGrade> >();
foreach (var studentGradeDbRecord in studentGradeDbRecords)
{
if (!studentGradeDbRecord.Value.Any())
{
continue;
}
SortedList <GradingPeriodDim, StudentCourseGradingPeriodCalculation> studentCourseGradingPeriodCalculations = new SortedList <GradingPeriodDim, StudentCourseGradingPeriodCalculation>(new GradingPeriodComparer());
foreach (var gradingPeriod in gradingPeriodDims)
{
if (!gradingPeriod.ShouldBeIgnored(currentSchoolDay))
{
studentCourseGradingPeriodCalculations.Add(gradingPeriod, new StudentCourseGradingPeriodCalculation(CourseGradeGranularMetric, gradingPeriod, studentGradeDbRecord.Key));
}
}
StudentGrade studentGrade = new StudentGrade {
StudentKey = studentGradeDbRecord.Key
};
StudentGradeDim previousStudentGrade = null;
foreach (var _studentGradeDbRecord in studentGradeDbRecord.Value)
{
studentGrade.GradingPeriod = gradingPeriodDims.Where(sgp => _studentGradeDbRecord.GradingPeriodDescription.Equals(sgp.GradingPeriodDescription) &&
_studentGradeDbRecord.GradingPeriodBeginDate.Equals(sgp.BeginDate))
.FirstOrDefault();
if (studentGrade.GradingPeriod == null)
{
continue;
}
if (studentSectionAssociationsDictionary.ContainsKey(studentGrade.StudentKey))
{
var studentSectionAssociations = studentSectionAssociationsDictionary[studentGrade.StudentKey];
studentGrade.StudentSection = studentSectionAssociations.Where(ssa => ssa.SectionIdentifier.Equals(_studentGradeDbRecord.SectionIdentifier) &&
ssa.LocalCourseCode.Equals(_studentGradeDbRecord.LocalCourseCode) &&
ssa.SessionName.Equals(_studentGradeDbRecord.SessionName) &&
ssa.SchoolYear.Equals(_studentGradeDbRecord.SchoolYear.ToString()) &&
ssa.SchoolKey.Equals(_studentGradeDbRecord.SchoolKey))
.FirstOrDefault();
if (studentGrade.StudentSection == null || !studentGrade.StudentSection.OverlapsWith(studentGrade.GradingPeriod))
{
continue;
}
}
if (previousStudentGrade != null &&
SectionComparer.Instance.Equals(previousStudentGrade, _studentGradeDbRecord) &&
previousStudentGrade.GradingPeriodBeginDate.Equals(_studentGradeDbRecord.GradingPeriodBeginDate) &&
!previousStudentGrade.GradeType.Equals(_studentGradeDbRecord.GradeType) &&
previousStudentGrade.SchoolYear == _studentGradeDbRecord.SchoolYear &&
previousStudentGrade.GradingPeriodSequence == _studentGradeDbRecord.GradingPeriodSequence)
{
continue;
}
previousStudentGrade = _studentGradeDbRecord;
if (studentGrade.GradingPeriod.BeginDate > currentSchoolDay)
{
continue;
}
var studentSchoolAssociation = studentSchoolAssociationsDictionary[studentGrade.StudentKey].FirstOrDefault(ssa => ssa.OverlapsWith(studentGrade.GradingPeriod));
if (studentSchoolAssociation == null)
{
continue;
}
var gradingScales = GradingScaleRepository.GetGradingScales(studentSchoolAssociation.LocalEducationAgencyKey.ToString());
if (!gradingScales.Any())
{
continue;
}
var gradingScale = gradingScales.Where(gradingScale => gradingScale.GradingScaleGradeLevelDims.Any() &&
gradingScale.GradingScaleGradeLevelDims.Exists(gradingScaleGradeLevelDim => gradingScaleGradeLevelDim.GradeLevelDescription.Equals(studentSchoolAssociation.GradeLevel)))
.FirstOrDefault();
if (gradingScale == null)
{
continue;
}
var gradeScaleGradeRank = GradingScaleRepository.GetGradingScaleGrade(gradingScale, _studentGradeDbRecord);
if (gradeScaleGradeRank == null)
{
continue;
}
studentGrade.GradeRank = gradeScaleGradeRank.Rank;
studentGrade.GradingScale = gradingScale;
studentGrade.StudentSchoolAssociation = studentSchoolAssociation;
if (!AcademicSubjects.Contains(studentGrade.StudentSection.Subject))
{
continue;
}
if (!currentSchoolDay.IsInRange(studentGrade.StudentSchoolAssociation) &&
!studentGrade.GradingScale.GradingScaleMetricThresholdDims.ContainsKey(_metricInfo.Id))
{
continue;
}
if (!studentGrade.GradingScale.GradingScaleMetricThresholdDims.ContainsKey(CourseGradeContainerMetric.Id))
{
continue;
}
studentGrade.GradingScaleMetricThreshold = studentGrade.GradingScale.GradingScaleMetricThresholdDims[CourseGradeContainerMetric.Id];
if (studentGrade.GradingPeriod.ShouldBeIgnored(currentSchoolDay))
{
continue;
}
var index = studentCourseGradingPeriodCalculations.IndexOfKey(studentGrade.GradingPeriod);
if (index < 0)
{
continue;
}
var gradingPeriodData = studentCourseGradingPeriodCalculations.Values[index];
var previousGradingPeriodData = (index == 0) ? null : studentCourseGradingPeriodCalculations.Values[index - 1];
var studentGradeContainer = gradingPeriodData.AddStudentGrade(studentGrade);
var failing = IsFailing(studentGrade, studentGrade.GradingScaleMetricThreshold);
if (failing)
{
gradingPeriodData.NumberOfGradesAtOrBelowThreshold++;
}
var metricStateType = CourseGradeGranularMetric.GetMetricStateTypeForStudentCourseGrades(gradingPeriodData.NumberOfGradesAtOrBelowThreshold);
gradingPeriodData.MetricStateType = metricStateType;
CalculateMetricComponentTrend(studentGradeContainer, previousGradingPeriodData);
if (index == studentCourseGradingPeriodCalculations.Count - 1)
{
gradingPeriodData.LastCompletedGradingPeriod = true;
}
}
studentGradingPeriodsDictionary[studentGradeDbRecord.Key] = studentCourseGradingPeriodCalculations;
}
var cacheEntryOptions = new MemoryCacheEntryOptions()
.SetSize(200)//Size amount
.SetPriority(CacheItemPriority.High)
.SetSlidingExpiration(TimeSpan.FromMinutes(15))
.SetAbsoluteExpiration(TimeSpan.FromMinutes(60));
_memoryCache.Set(cacheKey, studentGradingPeriodsDictionary, cacheEntryOptions);
return(studentGradingPeriodsDictionary);
}
public override IDictionary <string, List <StudentMetric> > GetAllStudentMetricsForSchool(string schoolKey)
{
string cacheKey = "schoolKey:" + schoolKey + " MetricId:" + GetMetricId();
IDictionary <string, List <StudentMetric> > returnMap;
if (_memoryCache.TryGetValue(cacheKey, out returnMap))
{
return(returnMap);
}
returnMap = new Dictionary <string, List <StudentMetric> >();
var schoolMinMaxDateDim = _context.SchoolMinMaxDateDims.Where(s => s.SchoolKey.Equals(schoolKey.ToString())).FirstOrDefault();
if (schoolMinMaxDateDim == null)
{
//"No entry found in analytics.SchoolMinMaxDateDim
return(returnMap);
}
var ytdGradingPeriod = new GradingPeriodDim
{
BeginDate = schoolMinMaxDateDim.MinDate.Value,
EndDate = schoolMinMaxDateDim.MaxDate.Value,
GradingPeriodDescription = string.Empty,
IsYearToDate = true
};
int temp;
int schoolKeyInt = int.TryParse(schoolKey, out temp) ? temp : 0;
var schoolCalendarDays = _context.SchoolCalendarDims.Where(s => s.SchoolKey == schoolKeyInt).ToList();
HashSet <DateTime> _schoolCalendarDays = new HashSet <DateTime>();
schoolCalendarDays.ForEach(s => _schoolCalendarDays.Add(s.Date));
IDictionary <string, List <StudentSchoolDim> > studentSchoolAssociationsDictionary = StudentDataRepository.GetStudentSchoolAssociationsDictionary(schoolKey);
IDictionary <string, List <StudentSectionDim> > studentSectionAssociationsDictionary = getStudentSectionAssociationsDictionary(schoolKey);
IDictionary <string, List <StudentAttendanceEvent> > studentAttendanceEventDictionary = getStudentAttendanceEvents(schoolKey);
foreach (var studentId in studentAttendanceEventDictionary.Keys)
{
DateTime? _lastAttendanceDateForStudent = null;
HashSet <DateTime> _excusedAbsences = new HashSet <DateTime>();
HashSet <DateTime> _unexcusedAbsences = new HashSet <DateTime>();
int ytdTotalDaysAbsences = 0;
int ytdUnexcusedAbsences = 0;
foreach (var studentAttendanceEvent in studentAttendanceEventDictionary[studentId])
{
if (_lastAttendanceDateForStudent == studentAttendanceEvent.EventDate)
{
continue;
}
if (studentAttendanceEvent.AttendanceEventCategoryDescriptor.Equals(AttendanceEventCategoryDescriptor.ExcusedAbsence) && studentAttendanceEvent.IsForDailyAttendance())
{
_excusedAbsences.Add(studentAttendanceEvent.EventDate);
_lastAttendanceDateForStudent = studentAttendanceEvent.EventDate;
}
else if (studentAttendanceEvent.AttendanceEventCategoryDescriptor.Equals(AttendanceEventCategoryDescriptor.UnexcusedAbsence) && studentAttendanceEvent.IsForDailyAttendance())
{
_unexcusedAbsences.Add(studentAttendanceEvent.EventDate);
_lastAttendanceDateForStudent = studentAttendanceEvent.EventDate;
}
}
var daysStudentWasEnrolled = _schoolCalendarDays
.DaysInRange(studentSchoolAssociationsDictionary.ContainsKey(studentId) ? studentSchoolAssociationsDictionary[studentId] : new List <StudentSchoolDim>())
.DaysInRange(studentSectionAssociationsDictionary.ContainsKey(studentId) ? studentSectionAssociationsDictionary[studentId] : new List <StudentSectionDim>())
.ToArray();
if (!daysStudentWasEnrolled.Any())
{
// Do no calculations for students that were not enrolled for any instructional days
continue;
}
_unexcusedAbsences.RemoveWhere(x => _excusedAbsences.Contains(x));
var excusedAbsences = _excusedAbsences.CountDaysInRange(ytdGradingPeriod);
var unExcusedAbsences = _unexcusedAbsences.CountDaysInRange(ytdGradingPeriod);
ytdTotalDaysAbsences = excusedAbsences + unExcusedAbsences;
ytdUnexcusedAbsences = unExcusedAbsences;
if (!returnMap.ContainsKey(studentId))
{
returnMap[studentId] = new List <StudentMetric>();
}
int metricValue = GetAbsences(excusedAbsences, unExcusedAbsences);
var metricStateType = _metricInfo.GetMetricStateType(metricValue, null);
returnMap[studentId].Add(new Models.StudentMetric
{
StudentUsi = int.TryParse(studentId, out temp) ? temp : 0,
Name = _metricInfo.DisplayName,
Id = _metricInfo.Id,
Value = metricValue.ToString(),
State = MetricUtility.GetMetricState(metricStateType.Value)
});;
}
_memoryCache.Set(cacheKey, returnMap, _cacheEntryOptions);
return(returnMap);
}
protected IDictionary <string, StudentDiscipline> GetStudentDisciplines(string schoolKey)
{
IDictionary <string, StudentDiscipline> studentDisciplineDictionary;
string cacheKey = "StudentDisciplineEvents" + schoolKey + ":IsStateOffense:" + IsStateOffense.ToString() + ":PeriodLength" + (ReportingPeriodLength.HasValue ? ReportingPeriodLength.Value : 99999);
if (_memoryCache.TryGetValue(cacheKey, out studentDisciplineDictionary))
{
return(studentDisciplineDictionary);
}
var currentSchoolYearDim = _context.CurrentSchoolYearDims.FirstOrDefault();
studentDisciplineDictionary = new Dictionary <string, StudentDiscipline>();
if (currentSchoolYearDim == null)
{
return(studentDisciplineDictionary);
}
IDictionary <string, List <StudentSchoolDim> > studentSchoolAssociationsDictionary = StudentDataRepository.GetStudentSchoolAssociationsDictionary(schoolKey);
List <string> studentUniqueIds = studentSchoolAssociationsDictionary.Select(d => d.Key).ToList();
var studentSchoolDisciplineDbRecords = GetStudentDisciplineDbRecords(schoolKey);
studentSchoolDisciplineDbRecords = FilterDisciplineRecordsByBehaviorDescription(studentSchoolDisciplineDbRecords);
var studentSchoolDisciplineDbRecordsDictionary = studentSchoolDisciplineDbRecords
.GroupBy(x => x.StudentKey)
.ToDictionary(x => x.Key, x => x.ToList().OrderBy(a => a.IncidentDate));
var schoolDaysPeriod = GetSchoolDaysPeriod(schoolKey, ReportingPeriodLength);
foreach (var studentUniqueId in studentUniqueIds)
{
string _previousIncidentIdentifier = string.Empty;
var studentSchoolAssociations = studentSchoolAssociationsDictionary.ContainsKey(studentUniqueId) ? studentSchoolAssociationsDictionary[studentUniqueId] : new List <StudentSchoolDim>();
var studentDiscipline = new StudentDiscipline {
PeriodLength = ReportingPeriodLength
};
if (studentSchoolDisciplineDbRecordsDictionary != null && studentSchoolDisciplineDbRecordsDictionary.ContainsKey(studentUniqueId))
{
foreach (var studentSchoolDisciplineDbRecord in studentSchoolDisciplineDbRecordsDictionary[studentUniqueId])
{
if (studentSchoolAssociations.ContainsDate(studentSchoolDisciplineDbRecord.IncidentDate) &&
!string.Equals(studentSchoolDisciplineDbRecord.IncidentIdentifier, _previousIncidentIdentifier, StringComparison.Ordinal))
{
Period period;
if (schoolDaysPeriod.TryGetValue(studentSchoolDisciplineDbRecord.IncidentDate, out period))
{
studentDiscipline.DisciplineIncidentsByPeriod.Increment(period);
_previousIncidentIdentifier = studentSchoolDisciplineDbRecord.IncidentIdentifier;
}
}
}
}
else
{
studentDiscipline.DisciplineIncidentsByPeriod.Add(Period.First, 0);
studentDiscipline.DisciplineIncidentsByPeriod.Add(Period.Second, 0);
}
studentDisciplineDictionary[studentUniqueId] = studentDiscipline;
}
var cacheEntryOptions = new MemoryCacheEntryOptions()
.SetSize(200)//Size amount
.SetPriority(CacheItemPriority.High)
.SetSlidingExpiration(TimeSpan.FromMinutes(15))
.SetAbsoluteExpiration(TimeSpan.FromMinutes(60));
_memoryCache.Set(cacheKey, studentDisciplineDictionary, cacheEntryOptions);
return(studentDisciplineDictionary);
}
