Exemple #1
0
        protected void Page_Load(object sender, EventArgs e)
        {
            Stopwatch stopwatch = new Stopwatch();

            stopwatch.Start();

            string selectedStudentID      = "106757957";
            int    selectedReportPeriodID = 479;

            using (SqlConnection connection = new SqlConnection(LSKYCommon.dbConnectionString_SchoolLogic))
            {
                Student selectedStudent = Student.loadThisStudent(connection, selectedStudentID);
                displayString("<B>Selected Student: </B>" + selectedStudent);

                // Derive the term to get classes from
                Term selectedTerm = Term.loadTermFromReportPeriod(connection, selectedReportPeriodID);
                displayString("<B>Term:</B> " + selectedTerm);

                // Track is already loaded from the student load function
                displayString("<B>Student Track: </B>" + selectedStudent.track);


                // Load student timetable entries
                selectedStudent.TimeTable = TimeTableEntry.loadStudentTimeTable(connection, selectedStudent, selectedTerm);

                // Load absences from the last month (for testing)
                selectedStudent.absences = Absence.loadAbsencesForThisStudentAndTimePeriod(connection, selectedStudent, DateTime.Now.AddDays(-30), DateTime.Now);

                // Display absences
                displayList("Absences", selectedStudent.absences);
            }



            displayString("<BR><BR>");
            stopwatch.Stop();
            displayString("Elapsed time: " + stopwatch.Elapsed);
        }
Exemple #2
0
        /// <summary>
        /// Loads mark data for a student for report cards. Loads terms, report periods, enrolled classes, class marks, outcomes, outcome marks, and attendance
        /// </summary>
        /// <param name="connection">Database connection</param>
        /// <param name="thisStudent">The student to load data for</param>
        /// <param name="theseReportPeriods">Report periods to load data for</param>
        /// <returns>Student object loaded with terms, report periods, enrolled classes, class marks, outcomes, outcome marks, and attendance</returns>
        public static Student loadStudentMarkData(SqlConnection connection, Student thisStudent, List <ReportPeriod> theseReportPeriods)
        {
            Student returnedStudent = thisStudent;

            // **************************************************************
            // * Report Period Comments
            // **************************************************************

            // Load report period comments for the selected report periods
            List <ReportPeriodComment> allRPComments      = ReportPeriodComment.loadRPCommentsForStudent(connection, thisStudent.getStudentID());
            List <ReportPeriodComment> filteredRPComments = ReportPeriodComment.getCommentsForTheseReportPeriods(allRPComments, theseReportPeriods);

            returnedStudent.ReportPeriodComments = filteredRPComments;

            // **************************************************************
            // * Report Periods
            // **************************************************************
            // Find the earliest report period and the last report period, for attendance dates
            DateTime earliestDate = DateTime.MaxValue;
            DateTime lastDate     = DateTime.MinValue;

            List <int>          detectedTermIDs         = new List <int>();
            List <int>          selectedReportPeriodIDs = new List <int>();
            List <ReportPeriod> reportPeriods           = new List <ReportPeriod>();

            // Validate report periods so we aren't working with nulls
            foreach (ReportPeriod rp in theseReportPeriods)
            {
                if (rp != null)
                {
                    reportPeriods.Add(rp);
                }
            }

            foreach (ReportPeriod rp in reportPeriods)
            {
                // Create a list of loaded report period IDs for later use
                if (!selectedReportPeriodIDs.Contains(rp.ID))
                {
                    selectedReportPeriodIDs.Add(rp.ID);
                }

                // Find the earliest report period and the last report period, for attendance dates
                if (rp.startDate < earliestDate)
                {
                    earliestDate = rp.startDate;
                }

                if (rp.endDate > lastDate)
                {
                    lastDate = rp.endDate;
                }

                // Derive some terms from the given report periods while we are cycling through them
                if (!detectedTermIDs.Contains(rp.termID))
                {
                    detectedTermIDs.Add(rp.termID);
                }
            }

            // **************************************************************
            // * Terms
            // **************************************************************
            // Derive some terms from the given report periods while we are cycling through them
            List <Term> detectedTerms = new List <Term>();

            foreach (int termid in detectedTermIDs)
            {
                detectedTerms.Add(Term.loadThisTerm(connection, termid));
            }


            foreach (Term term in detectedTerms)
            {
                foreach (ReportPeriod rp in reportPeriods)
                {
                    // Put report periods into their respective terms
                    if (rp.termID == term.ID)
                    {
                        term.ReportPeriods.Add(rp);
                    }

                    // Determine the final report period in a term, and assign it appropriately if it was loaded
                    if (
                        (rp.endDate.Year == term.endDate.Year) &&
                        (rp.endDate.Month == term.endDate.Month) &&
                        (rp.endDate.Day == term.endDate.Day)
                        )
                    {
                        term.FinalReportPeriod = rp;
                    }
                }
            }


            if (returnedStudent != null)
            {
                // **************************************************************
                // * Load student data
                // **************************************************************

                // Load all outcome marks (which will also load the outcomes themselves). We will filter this list by class later
                List <OutcomeMark> studentOutcomeMarks_All = OutcomeMark.loadOutcomeMarksForThisStudent(connection, reportPeriods, returnedStudent);

                returnedStudent.school      = School.loadThisSchool(connection, thisStudent.getSchoolIDAsInt());
                returnedStudent.track       = Track.loadThisTrack(connection, returnedStudent.getTrackID());
                returnedStudent.track.terms = detectedTerms;

                // Marks
                List <Mark> studentMarks_All = Mark.loadMarksFromTheseReportPeriods(connection, reportPeriods, returnedStudent);

                // **************************************************************
                // * Attendance
                // **************************************************************
                // Load this student's attendance
                returnedStudent.absences = Absence.loadAbsencesForThisStudentAndTimePeriod(connection, thisStudent, earliestDate, lastDate);

                foreach (Term thisTerm in returnedStudent.track.terms)
                {
                    // **************************************************************
                    // * Enrolled Classes
                    // **************************************************************
                    // Load classes this student is enrolled in
                    thisTerm.Courses = SchoolClass.loadStudentEnrolledClassesForThisTerm(connection, returnedStudent, thisTerm);

                    foreach (SchoolClass thisClass in thisTerm.Courses)
                    {
                        thisClass.term = thisTerm;

                        // Put list of report periods into each class so we can easily reference it later
                        thisClass.ReportPeriods = reportPeriods;

                        // **************************************************************
                        // * Outcomes and Life Skills (or SLBs / Successful Learner Behaviors)
                        // **************************************************************
                        string lifeSkillsCategoryName = "Successful Learner Behaviours";

                        // From the main list of this student's outcome marks, select just the ones for this course
                        //List<OutcomeMark> classOutcomeMarks_All = OutcomeMark.loadOutcomeMarksForThisCourse(connection, thisTerm, returnedStudent, thisClass);

                        List <OutcomeMark> classOutcomeMarks_All = new List <OutcomeMark>();
                        foreach (OutcomeMark om in studentOutcomeMarks_All)
                        {
                            if (om.courseID == thisClass.courseid)
                            {
                                classOutcomeMarks_All.Add(om);
                            }
                        }

                        // Split marks into life skills and not life skills
                        List <Outcome> classNormalOutcomes = new List <Outcome>();
                        List <Outcome> classLifeSkills     = new List <Outcome>();

                        List <OutcomeMark> classMarks_LifeSkills = new List <OutcomeMark>();
                        List <OutcomeMark> classMarks_Outcomes   = new List <OutcomeMark>();

                        foreach (OutcomeMark om in classOutcomeMarks_All)
                        {
                            // Associate some of the loaded report period objects with the outcome marks
                            foreach (ReportPeriod rp in reportPeriods)
                            {
                                if (rp.ID == om.reportPeriodID)
                                {
                                    om.reportPeriod = rp;
                                }
                            }

                            // Split marks into life skills and not life skills lists
                            if (om.outcome.category == lifeSkillsCategoryName)
                            {
                                classMarks_LifeSkills.Add(om);

                                classLifeSkills.Add(om.outcome);
                            }
                            else
                            {
                                classMarks_Outcomes.Add(om);

                                // While we are iterating through the list, derive a list of outcomes from the outcome marks, since we didn't load one earlier

                                // Check to see if this outcome exists already
                                bool outcomeExists = false;
                                foreach (Outcome o in classNormalOutcomes)
                                {
                                    if (o.id == om.outcome.id)
                                    {
                                        outcomeExists = true;
                                        o.marks.Add(om);
                                    }
                                }
                                if (!outcomeExists)
                                {
                                    classNormalOutcomes.Add(om.outcome);
                                }
                            }
                        }


                        // Put the outcomes and outcome marks into the course object
                        thisClass.Outcomes       = classNormalOutcomes;
                        thisClass.LifeSkills     = classLifeSkills;
                        thisClass.OutcomeMarks   = classMarks_Outcomes;
                        thisClass.LifeSkillMarks = classMarks_LifeSkills;
                    }

                    // **************************************************************
                    // * Class marks and comments
                    // **************************************************************

                    foreach (Mark m in studentMarks_All)
                    {
                        foreach (SchoolClass c in thisTerm.Courses)
                        {
                            if (m.classID == c.classid)
                            {
                                c.Marks.Add(m);
                            }
                        }
                    }
                }
            }

            return(returnedStudent);
        }
        public static List <Absence> loadAbsencesForThisDate(SqlConnection connection, DateTime date)
        {
            List <Absence> returnMe = new List <Absence>();

            SqlCommand sqlCommand = new SqlCommand();

            sqlCommand.Connection  = connection;
            sqlCommand.CommandType = CommandType.Text;

            StringBuilder SQL = new StringBuilder();

            /* Load all attendance blocks, so we can reference them */
            List <AttendanceBlock> blocks = AttendanceBlock.loadAllAttendanceBlocks(connection);



            SQL.Append("SELECT * FROM LSKY_Attendance WHERE dDate='" + date.Year + "-" + date.Month + "-" + date.Day + " 00:00:00' ORDER BY dDate ASC, block ASC;");

            sqlCommand.CommandText = SQL.ToString();
            sqlCommand.Connection.Open();
            SqlDataReader dataReader = sqlCommand.ExecuteReader();

            if (dataReader.HasRows)
            {
                while (dataReader.Read())
                {
                    Absence newAbsence = new Absence(
                        DateTime.Parse(dataReader["dDate"].ToString()),
                        int.Parse(dataReader["iTrackID"].ToString().Trim()),
                        dataReader["StudentNumber"].ToString().Trim(),
                        dataReader["ClassName"].ToString().Trim(),
                        dataReader["ClassID"].ToString().Trim(),
                        dataReader["Status"].ToString().Trim(),
                        dataReader["Reason"].ToString().Trim(),
                        dataReader["Comment"].ToString().Trim(),
                        int.Parse(dataReader["Block"].ToString()),
                        int.Parse(dataReader["Minutes"].ToString()),
                        parseExcused(dataReader["lExcusable"].ToString())
                        );

                    newAbsence.period = newAbsence.getBlock().ToString();

                    foreach (AttendanceBlock atBlock in blocks)
                    {
                        if (atBlock.block == newAbsence.block)
                        {
                            if (atBlock.track == newAbsence.track)
                            {
                                newAbsence.period          = atBlock.name;
                                newAbsence.attendanceBlock = atBlock;
                            }
                        }
                    }

                    returnMe.Add(newAbsence);
                }
            }
            sqlCommand.Connection.Close();

            foreach (Absence abs in returnMe)
            {
            }

            return(returnMe);
        }
Exemple #4
0
 public void addAbsence(Absence thisAbs)
 {
     this.absences.Add(thisAbs);
 }