public void CreateReportCard(string outFilename, MarkingPeriod period)
        {
            var currentSubjects = _student.Grades.GroupBy(g => g.Subject)
                                  .Where(subject => subject.Any(subGrade => subGrade.IsCurrentForPeriod(period.Key)))
                                  .OrderBy(subject => Maintenance.GetSubjectIndex(subject.Key));
            var gradeReportFields = currentSubjects.Select((subject, i) =>
            {
                var thisYearsGrades = subject.Where(subGrade => subGrade.ShouldShowOnReportCard(period))
                                      .Select(subGrade => subGrade.GetGradeReportFields(period.Key, i + 1));
                return(thisYearsGrades.SelectMany(x => x));
            }).SelectMany(x => x);
            var outputProperties = gradeReportFields.Concat(GetPDFFields(this))
                                   .Concat(GetReportLevelFields(period.Key))
                                   .Concat(GetSelfDevFields(period.Key));

            if (outFilename == null)
            {
                var tempDir = Path.GetTempPath();
                Directory.CreateDirectory(tempDir);
                string tempFileName = Path.Combine(tempDir, GetDefaultReportCardFilename(period.Key) + "-" + DateTime.Now.ToString("yyyyMMddHHmmss") + ".pdf");
                PDFWriter.WritePDF(tempFileName, outputProperties.ToDictionary(p => p.Key, p => p.Value));
                Process.Start(tempFileName);
            }
            else
            {
                PDFWriter.WritePDF(outFilename, outputProperties.ToDictionary(p => p.Key, p => p.Value));
            }
        }
Пример #2
0
        public ActionResult <MarkingPeriod> GetMarkingPeriod(MarkingPeriod markingPeriod)
        {
            MarkingPeriod markingPeriodModel = new MarkingPeriod();

            try
            {
                if (markingPeriod.SchoolId > 0)
                {
                    markingPeriodModel = _markingPeriodService.GetMarkingPeriod(markingPeriod);
                }
                else
                {
                    markingPeriodModel.TenantId    = markingPeriod.TenantId;
                    markingPeriodModel._token      = markingPeriod._token;
                    markingPeriodModel._tenantName = markingPeriod._tenantName;
                    markingPeriodModel._failure    = true;
                    markingPeriodModel._message    = "Please enter valid school id";
                }
            }
            catch (Exception es)
            {
                markingPeriodModel._failure = true;
                markingPeriodModel._message = es.Message;
            }
            return(markingPeriodModel);
        }
Пример #3
0
        private void FillStudents(string target, MarkingPeriod mp, string gradeLevel, CourseViewModel course)
        {
            var students = Gradebook.Students;

            students = students.OrderBy(s => s.Name);
            if (chkMyStudents.IsChecked == true)
            {
                students = students.Where(s => s.HasTeacher(UserViewModel.CurrentUser));
            }
            if (course != null)
            {
                students = students.Where(s => s.HasCourse(course, mp));
            }

            if (gradeLevel != "All")
            {
                students = students.Where(s => s.GradeLevel == gradeLevel);
            }

            if (mp != null)
            {
                students = students.Where(s => s.AttendedDuring(mp));
            }

            if (!string.IsNullOrWhiteSpace(target))
            {
                target   = target.ToUpper();
                students = students.Where(s => s.Name.ToUpper().Contains(target) || s.GradeLevel.ToUpper().Contains(target));
            }

            lst.ItemsSource  = students;
            staCount.Content = "Students: " + students.Count();
        }
Пример #4
0
        private District PrepareCommonViewDataForSchoolPerson(StartupData startupData)
        {
            //TODO: render data for demo school
            var district = PrepareCommonViewData();

            ViewData[ViewConstants.UNSHOWN_NOTIFICATIONS_COUNT] = startupData.UnshownNotificationsCount;
            var           mps           = startupData.MarkingPeriods;
            MarkingPeriod markingPeriod = mps.Where(x => x.StartDate <= Context.NowSchoolYearTime).OrderBy(x => x.StartDate).LastOrDefault();

            if (markingPeriod != null && SchoolLocator.Context.SchoolLocalId.HasValue)
            {
                PrepareJsonData(MarkingPeriodViewData.Create(markingPeriod), ViewConstants.MARKING_PERIOD);
                var gradingPeriod = startupData.GradingPeriod;
                if (gradingPeriod != null)
                {
                    PrepareJsonData(ShortGradingPeriodViewData.Create(gradingPeriod), ViewConstants.GRADING_PERIOD);
                }
            }
            PrepareJsonData(AlphaGradeViewData.Create(startupData.AlphaGrades), ViewConstants.ALPHA_GRADES);
            PrepareJsonData(AlternateScoreViewData.Create(startupData.AlternateScores), ViewConstants.ALTERNATE_SCORES);
            PrepareJsonData(GradingPeriodViewData.Create(startupData.GradingPeriods), ViewConstants.GRADING_PERIODS);

            PrepareJsonData(MarkingPeriodViewData.Create(mps), ViewConstants.MARKING_PERIODS);
            var sy = SchoolLocator.SchoolYearService.GetCurrentSchoolYear();

            PrepareJsonData(SchoolYearViewData.Create(sy), ViewConstants.SCHOOL_YEAR);
            PrepareJsonData(SchoolLocator.SchoolYearService.GetYears(), ViewConstants.YEARS);

            return(district);
        }
Пример #5
0
            internal bool HasCourse(CourseRow courseRow, MarkingPeriod mp)
            {
                if (courseRow == null)
                {
                    return(true);
                }

                return(GetGradeRows().Any(c => c.CourseRow.CourseKey == courseRow.CourseKey));
            }
        //public static GradingStudentClassSummaryViewData Create(StudentClassGradeStats gradingStatsPerDate
        //    , MarkingPeriod currentMp, IList<GradingClassSummaryViewData> gradingPerMp)
        //{
        //    return new GradingStudentClassSummaryViewData
        //        {
        //            CurrentMarkingPeriod = MarkingPeriodViewData.Create(currentMp),
        //            AvgPerDate = GradingStatsByDateViewData.Create(gradingStatsPerDate.GradeAvgPerDates),
        //            GradingPerMp = gradingPerMp
        //        };
        //}

        public static GradingStudentClassSummaryViewData Create(MarkingPeriod currentMp, IList <AnnouncementViewData> announcementsView
                                                                , ClassGradingBoxesViewData gradingPeriodBoxes)
        {
            return(new GradingStudentClassSummaryViewData
            {
                CurrentMarkingPeriod = MarkingPeriodViewData.Create(currentMp),
                Announcements = announcementsView,
                GradingPeriodBoxes = gradingPeriodBoxes
            });
        }
Пример #7
0
            internal bool AttendedDuring(MarkingPeriod mp)
            {
                DateTime enrolled  = DateEnrolled;
                DateTime?withdrawn = null;

                if (!IsDateWithdrawnNull())
                {
                    withdrawn = DateWithdrawn;
                }
                return(enrolled < mp.EndDate && (withdrawn == null || withdrawn > mp.EndDate));
            }
Пример #8
0
        public Notification BuildEndMarkingPeriodNotification(DateTime created, MarkingPeriod markingPeriod, Person recipient, int endDays,
                                                              bool nextMarkingPeriodExist, bool nextMpNotAssignedToClass)
        {
            var otherModel = new
            {
                EndDays = endDays,
                NextMarkingPeriodNotExist = nextMarkingPeriodExist,
                NotAssignedToClass        = nextMpNotAssignedToClass
            };

            return(BuildNotificationFromTemplate(NotificationTemplateProvider.END_MARKINGPERIOD_NOTIFICATION_TO_ADMIN,
                                                 NotificationType.MarkingPeriodEnding, recipient, null, null, markingPeriod, null, null, otherModel));
        }
Пример #9
0
        public static MarkingPeriodViewData Create(MarkingPeriod markingPeriod)
        {
            var res = new MarkingPeriodViewData
            {
                Id          = markingPeriod.Id,
                Name        = markingPeriod.Name,
                StartDate   = markingPeriod.StartDate,
                EndDate     = markingPeriod.EndDate,
                Description = markingPeriod.Description,
                WeekDays    = markingPeriod.WeekDays
            };

            return(res);
        }
Пример #10
0
        public MarkingPeriod GetMarkingPeriod(MarkingPeriod markingPeriod)
        {
            MarkingPeriod markingPeriodModel = new MarkingPeriod();

            try
            {
                var MarkingperiodViews = this.context?.SchoolYears.Where(x => x.SchoolId == markingPeriod.SchoolId && x.TenantId == markingPeriod.TenantId && x.AcademicYear == markingPeriod.AcademicYear).Select(x => new SchoolYearView()
                {
                    SchoolId        = x.SchoolId,
                    MarkingPeriodId = x.MarkingPeriodId,
                    ShortName       = x.ShortName,
                    Title           = x.Title,
                    TenantId        = x.TenantId,
                    IsParent        = true,
                    DoesComments    = x.DoesComments,
                    DoesExam        = x.DoesExam,
                    DoesGrades      = x.DoesGrades,
                    EndDate         = x.EndDate,
                    PostStartDate   = x.PostStartDate,
                    PostEndDate     = x.PostEndDate,
                    StartDate       = x.StartDate,
                    Children        = this.context.Semesters.Where(y => y.YearId == x.MarkingPeriodId && y.AcademicYear == markingPeriod.AcademicYear).Select(y => new SchoolSemesterView()
                    {
                        TenantId = y.TenantId, DoesComments = y.DoesComments, DoesExam = y.DoesExam, DoesGrades = y.DoesGrades, StartDate = y.StartDate, EndDate = y.EndDate, PostStartDate = y.PostStartDate, PostEndDate = y.PostEndDate, Title = y.Title, SchoolId = y.SchoolId, YearId = (int)y.YearId, MarkingPeriodId = y.MarkingPeriodId, IsParent = false, ShortName = y.ShortName,
                        Children = this.context.Quarters.Where(z => z.SemesterId == y.MarkingPeriodId && z.AcademicYear == markingPeriod.AcademicYear).Select(z => new SchoolQuarterView()
                        {
                            MarkingPeriodId = z.MarkingPeriodId, SemesterId = (int)z.SemesterId, IsParent = false, SchoolId = z.SchoolId,
                            Title           = z.Title, ShortName = z.ShortName, TenantId = z.TenantId, DoesComments = z.DoesComments, DoesExam = z.DoesExam, DoesGrades = z.DoesGrades, StartDate = z.StartDate, EndDate = z.EndDate, PostStartDate = z.PostStartDate, PostEndDate = z.PostEndDate,
                            Children        = this.context.ProgressPeriods.Where(a => a.QuarterId == z.MarkingPeriodId && a.AcademicYear == markingPeriod.AcademicYear).Select(a => new SchoolProgressPeriodView()
                            {
                                IsParent  = false, MarkingPeriodId = a.MarkingPeriodId, SchoolId = a.SchoolId,
                                QuarterId = a.QuarterId, ShortName = a.ShortName, TenantId = a.TenantId, Title = a.Title, DoesComments = a.DoesComments, DoesExam = a.DoesExam, DoesGrades = a.DoesGrades, StartDate = a.StartDate, EndDate = a.EndDate, PostStartDate = a.PostStartDate, PostEndDate = a.PostEndDate
                            }).ToList()
                        }).ToList()
                    }).ToList()
                }).ToList();
                markingPeriodModel.schoolYearsView = MarkingperiodViews;
                markingPeriodModel._tenantName     = markingPeriod._tenantName;
                markingPeriodModel._token          = markingPeriod._token;
                markingPeriodModel._failure        = false;
                markingPeriodModel.TenantId        = markingPeriod.TenantId;
                markingPeriodModel.SchoolId        = markingPeriod.SchoolId;
            }
            catch (Exception es)
            {
                markingPeriodModel._failure = true;
                markingPeriodModel._message = es.Message;
            }
            return(markingPeriodModel);
        }
        internal static MarkingPeriods DemoMarkingPeriod()
        {
            var rv = new MarkingPeriods();

            for (int year = 2011; year <= 2013; year++)
            {
                for (int quarter = 1; quarter <= 4; quarter++)
                {
                    var key = new MarkingPeriodKey(quarter, year);
                    var mp  = new MarkingPeriod(key, ApproximateStartDate(key), ApproximateEndDate(key), 45);
                    rv.Add(mp);
                }
            }
            return(rv);
        }
        public IEnumerable <KeyValuePair <string, string> > GetGradeReportFields(MarkingPeriodKey period, int rowIndex)
        {
            yield return(new KeyValuePair <string, string>(
                             string.Format(MarkingPeriodKey.Parse(MarkingPeriod.ToString()).Quarter + "Row{0}", rowIndex),
                             LetterGrade + (!string.IsNullOrEmpty(SpecialGrade) ? "\n" + SpecialGrade : "")));

            if (IsCurrentForPeriod(period))
            {
                yield return(new KeyValuePair <string, string>(
                                 "SubjectRow" + rowIndex,
                                 Subject));

                yield return(new KeyValuePair <string, string>(
                                 "CommentRow" + rowIndex,
                                 Comment));

                yield return(new KeyValuePair <string, string>(
                                 "TeacherRow" + rowIndex,
                                 Teacher));
            }
        }
        private void OnGenerateReportCard(object sender, RoutedEventArgs e)
        {
            if (!UserViewModel.CurrentUser.CanExportReportCards)
            {
                MessageBox.Show("You do not have permission to export a report card!");
                return;
            }
            var           report = (StudentReport)grdStudentReport.SelectedItem;
            MarkingPeriod mp     = MarkingPeriod.Current;

            if (report != null)
            {
                mp = MarkingPeriods.Singleton.Find(MarkingPeriodKey.Parse(report.Quarter));
            }
            try
            {
                var reportCard = new ReportCard(_student);
                reportCard.CreateReportCard(null, mp);
            }
            catch (System.IO.IOException)
            {
                MessageBox.Show("Error writing the report card! Check to ensure you have permission to write to this folder and that the file is not currently in use.");
            }
        }
Пример #14
0
        public MarkingPeriod GetMarkingPeriod(MarkingPeriod markingPeriod)
        {
            MarkingPeriod markingPeriodModel = new MarkingPeriod();

            try
            {
                if (TokenManager.CheckToken(markingPeriod._tenantName + markingPeriod._userName, markingPeriod._token))
                {
                    markingPeriodModel = this.markingperiodRepository.GetMarkingPeriod(markingPeriod);
                }
                else
                {
                    markingPeriodModel._failure = true;
                    markingPeriodModel._message = TOKENINVALID;
                }
            }
            catch (Exception es)
            {
                markingPeriodModel._failure = true;
                markingPeriodModel._message = es.Message;
            }

            return(markingPeriodModel);
        }
 internal bool AttendedDuring(MarkingPeriod mp)
 {
     return _studentRow.AttendedDuring(mp);
 }
Пример #16
0
        private Notification BuildNotificationFromTemplate(string templateName, NotificationType type, Person recipient, Announcement announcement = null
                                                           , Guid?applicationId = null, MarkingPeriod markingPeriod = null, PrivateMessage privateMessage = null, Person asker = null, object other = null, string baseUrl = null)
        {
            var parameters = new List <string> {
                GetBaseUrlByRole(recipient, baseUrl)
            };
            var notification = new NotificationDetails
            {
                PersonRef = recipient.Id,
                Person    = recipient,
                RoleRef   = recipient.RoleRef,
                Shown     = false,
                Type      = type,
                Created   = serviceLocator.Context.NowSchoolTime
            };

            if (announcement != null)
            {
                notification.AnnouncementRef = announcement.Id;
                notification.Announcement    = announcement;
            }
            if (applicationId.HasValue)
            {
                //notification.Application = application;
                notification.ApplicationRef = applicationId;
            }
            if (markingPeriod != null)
            {
                notification.MarkingPeriod    = markingPeriod;
                notification.MarkingPeriodRef = markingPeriod.Id;
            }
            if (privateMessage != null)
            {
                notification.PrivateMessage    = privateMessage;
                notification.PrivateMessageRef = privateMessage.Id;
            }
            if (asker != null)
            {
                notification.QuestionPerson    = asker;
                notification.QuestionPersonRef = asker.Id;
                parameters.Add(GetRelativeUrlByRole(asker));
            }

            var    model   = new { Notification = notification, Other = other };
            string message = RenderService.Render(templateName, model, parameters);

            notification.Message = message;
            return(notification);
        }
        private void FillStudents(string target, MarkingPeriod mp, string gradeLevel, CourseViewModel course)
        {
            var students = Gradebook.Students;
            students = students.OrderBy(s => s.Name);
            if (chkMyStudents.IsChecked == true)
                students = students.Where(s => s.HasTeacher(UserViewModel.CurrentUser));
            if (course != null)
                students = students.Where(s => s.HasCourse(course, mp));

            if (gradeLevel != "All")
                students = students.Where(s => s.GradeLevel == gradeLevel);

            if (mp != null)
                students = students.Where(s => s.AttendedDuring(mp));

            if (!string.IsNullOrWhiteSpace(target))
            {
                target = target.ToUpper();
                students = students.Where(s => s.Name.ToUpper().Contains(target) || s.GradeLevel.ToUpper().Contains(target));
            }

            lst.ItemsSource = students;
            staCount.Content = "Students: " + students.Count();
        }
 internal static MarkingPeriods DemoMarkingPeriod()
 {
     var rv = new MarkingPeriods();
     for (int year = 2011; year <= 2013; year++)
     {
         for (int quarter = 1; quarter <= 4; quarter++)
         {
             var key = new MarkingPeriodKey(quarter, year);
             var mp = new MarkingPeriod(key, ApproximateStartDate(key), ApproximateEndDate(key), 45);
             rv.Add(mp);
         }
     }
     return rv;
 }
 public bool ShouldShowOnReportCard(MarkingPeriod period)
 {
     return MarkingPeriod.Key.EndingSchoolYear == period.Key.EndingSchoolYear &&
         MarkingPeriod.EndDate <= period.EndDate;
 }
Пример #20
0
        public MarkingPeriod GetMarkingPeriod(MarkingPeriod markingPeriod)
        {
            MarkingPeriod markingPeriodModel = new MarkingPeriod();

            try
            {
                var MarkingperiodData = this.context?.SchoolYears.Include(x => x.Semesters).ThenInclude(p => p.Quarters).ThenInclude(a => a.ProgressPeriods).Where(x => x.SchoolId == markingPeriod.SchoolId && x.TenantId == markingPeriod.TenantId && x.AcademicYear == markingPeriod.AcademicYear).ToList();
                if (MarkingperiodData.Count > 0)
                {
                    foreach (var year in MarkingperiodData)
                    {
                        SchoolYearView schoolYearView = new SchoolYearView();
                        schoolYearView.TenantId        = year.TenantId;
                        schoolYearView.SchoolId        = year.SchoolId;
                        schoolYearView.MarkingPeriodId = year.MarkingPeriodId;
                        schoolYearView.Title           = year.Title;
                        schoolYearView.ShortName       = year.ShortName;
                        schoolYearView.DoesComments    = year.DoesComments;
                        schoolYearView.DoesExam        = year.DoesExam;
                        schoolYearView.DoesGrades      = year.DoesGrades;
                        schoolYearView.StartDate       = year.StartDate;
                        schoolYearView.EndDate         = year.EndDate;
                        schoolYearView.PostEndDate     = year.PostEndDate;
                        schoolYearView.PostStartDate   = year.PostStartDate;
                        schoolYearView.IsParent        = true;
                        var semesterList = year.Semesters.ToList();
                        foreach (var semester in semesterList)
                        {
                            SchoolSemesterView schoolSemesterView = new SchoolSemesterView();
                            schoolSemesterView.TenantId        = semester.TenantId;
                            schoolSemesterView.SchoolId        = semester.SchoolId;
                            schoolSemesterView.MarkingPeriodId = semester.MarkingPeriodId;
                            schoolSemesterView.Title           = semester.Title;
                            schoolSemesterView.YearId          = (int)semester.YearId;
                            schoolSemesterView.ShortName       = semester.ShortName;
                            schoolSemesterView.DoesComments    = semester.DoesComments;
                            schoolSemesterView.DoesExam        = semester.DoesExam;
                            schoolSemesterView.DoesGrades      = semester.DoesGrades;
                            schoolSemesterView.StartDate       = semester.StartDate;
                            schoolSemesterView.EndDate         = semester.EndDate;
                            schoolSemesterView.PostEndDate     = semester.PostEndDate;
                            schoolSemesterView.PostStartDate   = semester.PostStartDate;
                            schoolSemesterView.IsParent        = false;
                            schoolYearView.Children.Add(schoolSemesterView);
                            var quaterList = semester.Quarters.ToList();
                            foreach (var quarter in quaterList)
                            {
                                SchoolQuarterView schoolQuarterView = new SchoolQuarterView();
                                schoolQuarterView.TenantId        = quarter.TenantId;
                                schoolQuarterView.SchoolId        = quarter.SchoolId;
                                schoolQuarterView.MarkingPeriodId = quarter.MarkingPeriodId;
                                schoolQuarterView.Title           = quarter.Title;
                                schoolQuarterView.SemesterId      = (int)quarter.SemesterId;
                                schoolQuarterView.ShortName       = quarter.ShortName;
                                schoolQuarterView.DoesComments    = quarter.DoesComments;
                                schoolQuarterView.DoesExam        = quarter.DoesExam;
                                schoolQuarterView.DoesGrades      = quarter.DoesGrades;
                                schoolQuarterView.StartDate       = quarter.StartDate;
                                schoolQuarterView.EndDate         = quarter.EndDate;
                                schoolQuarterView.PostEndDate     = quarter.PostEndDate;
                                schoolQuarterView.PostStartDate   = quarter.PostStartDate;
                                schoolQuarterView.IsParent        = false;
                                schoolSemesterView.Children.Add(schoolQuarterView);
                                var ProgressPeriodList = quarter.ProgressPeriods.ToList();
                                foreach (var progressPeriod in ProgressPeriodList)
                                {
                                    SchoolProgressPeriodView schoolProgressPeriodView = new SchoolProgressPeriodView();
                                    schoolProgressPeriodView.TenantId        = progressPeriod.TenantId;
                                    schoolProgressPeriodView.SchoolId        = progressPeriod.SchoolId;
                                    schoolProgressPeriodView.MarkingPeriodId = progressPeriod.MarkingPeriodId;
                                    schoolProgressPeriodView.Title           = progressPeriod.Title;
                                    schoolProgressPeriodView.QuarterId       = (int)progressPeriod.QuarterId;
                                    schoolProgressPeriodView.ShortName       = progressPeriod.ShortName;
                                    schoolProgressPeriodView.DoesComments    = progressPeriod.DoesComments;
                                    schoolProgressPeriodView.DoesExam        = progressPeriod.DoesExam;
                                    schoolProgressPeriodView.DoesGrades      = progressPeriod.DoesGrades;
                                    schoolProgressPeriodView.StartDate       = progressPeriod.StartDate;
                                    schoolProgressPeriodView.EndDate         = progressPeriod.EndDate;
                                    schoolProgressPeriodView.PostEndDate     = progressPeriod.PostEndDate;
                                    schoolProgressPeriodView.PostStartDate   = progressPeriod.PostStartDate;
                                    schoolProgressPeriodView.IsParent        = false;
                                    schoolQuarterView.Children.Add(schoolProgressPeriodView);
                                }
                            }
                        }
                        markingPeriodModel.schoolYearsView.Add(schoolYearView);
                    }
                }
                if (markingPeriodModel.schoolYearsView.Count > 0)
                {
                    markingPeriodModel._tenantName = markingPeriod._tenantName;
                    markingPeriodModel._token      = markingPeriod._token;
                    markingPeriodModel._failure    = false;
                    markingPeriodModel.TenantId    = markingPeriod.TenantId;
                    markingPeriodModel.SchoolId    = markingPeriod.SchoolId;
                }
                else
                {
                    markingPeriodModel._tenantName = markingPeriod._tenantName;
                    markingPeriodModel._token      = markingPeriod._token;
                    markingPeriodModel._failure    = true;
                    markingPeriodModel.TenantId    = markingPeriod.TenantId;
                    markingPeriodModel.SchoolId    = markingPeriod.SchoolId;
                    markingPeriodModel._message    = NORECORDFOUND;
                }
            }
            catch (Exception es)
            {
                markingPeriodModel.schoolYearsView = null;
                markingPeriodModel._failure        = true;
                markingPeriodModel._message        = es.Message;
            }
            return(markingPeriodModel);
        }
 internal bool AttendedDuring(MarkingPeriod mp)
 {
     DateTime enrolled = DateEnrolled;
     DateTime? withdrawn = null;
     if (!IsDateWithdrawnNull())
         withdrawn = DateWithdrawn;
     return (enrolled < mp.EndDate && (withdrawn == null || withdrawn > mp.EndDate));
 }
            internal bool HasCourse(CourseRow courseRow, MarkingPeriod mp)
            {
                if (courseRow == null)
                    return true;

                return GetGradeRows().Any(c => c.CourseRow.CourseKey == courseRow.CourseKey);
            }
Пример #23
0
 internal bool AttendedDuring(MarkingPeriod mp)
 {
     return(_studentRow.AttendedDuring(mp));
 }
 public bool ShouldShowOnReportCard(MarkingPeriod period)
 {
     return(MarkingPeriod.Key.EndingSchoolYear == period.Key.EndingSchoolYear &&
            MarkingPeriod.EndDate <= period.EndDate);
 }