[U] Release v0.2.3.315

This reverts commit d254706a21.

README.md

@@ -22,7 +22,7 @@ This is a website that generates visual representation of students' grade data o
 
 **Here's how it looks like right now:** *(Now all of you know my grades ;-;)*
 
-![](https://i.imgur.com/xl3Q4Nt.jpg)
+![](https://user-images.githubusercontent.com/22280294/65841599-155ead00-e2f2-11e9-9d9f-c2f23c45d9a4.png)
 
 <br>
 

src/components/app/app.ts

@@ -6,6 +6,8 @@ import Constants from '@/constants';
 import JsonUtils from '@/utils/json-utils';
 import pWaitFor from 'p-wait-for';
 import {HttpUtils} from '@/utils/http-utils';
+import {CourseUtils} from '@/utils/course-utils';
+import {GPAUtils} from '@/utils/gpa-utils';
 
 /**
  * Objects of this interface represent assignment grades.
@@ -40,6 +42,12 @@ export interface Course
     level: string,
     scaleUp: number,
 
+    grading:
+    {
+        method: string,
+        weightingMap: {[index: string]: number}
+    }
+
     assignments: Grade[]
 }
 
@@ -54,6 +62,9 @@ export default class App extends Vue
     // List of course that the student takes
     public courses: Course[] = [];
 
+    // List of course that should be displayed
+    public filteredCourses: Course[] = [];
+
     // Currently selected tab
     public selectedTab: string = 'overall';
 
@@ -122,8 +133,6 @@ export default class App extends Vue
 
     /**
      * Load the assignments of the courses
-     *
-     * @param courses Courses Json
      */
     public loadAssignments()
     {
@@ -152,8 +161,11 @@ export default class App extends Vue
         // Wait for assignments to be ready.
         pWaitFor(() => this.isAssignmentsReady()).then(() =>
         {
-            // When the assignments are ready
+            // Filter courses
-            this.assignmentsReady = true;
+            this.filteredCourses = CourseUtils.getGradedCourses(this.courses);
+
+            // Check grading algorithms
+            this.checkGradingAlgorithms();
         });
     }
 
@@ -172,6 +184,67 @@ export default class App extends Vue
         return true;
     }
 
+    /**
+     * Check the courses' grading algorithms. (Total-average or percent-type)
+     */
+    private checkGradingAlgorithms()
+    {
+        // Loop through all the courses
+        for (const course of this.filteredCourses)
+        {
+            // Check if total-average grade is the same with percent-type grade
+            if (course.numericGrade == GPAUtils.getTotalMeanAverage(course))
+            {
+                course.grading = {method: 'TOTAL_AVERAGE', weightingMap: {}};
+            }
+            else
+            {
+                // Request grading scheme for this course
+                this.http.post('/grading', {'assignment_id': course.assignmentsId}).then(response =>
+                {
+                    // Check success
+                    if (response.success)
+                    {
+                        // Add it to course
+                        course.grading = response.data;
+                    }
+                    else
+                    {
+                        // Show error message TODO: Show it properly
+                        alert(response.data)
+                    }
+                })
+                .catch(alert)
+            }
+        }
+
+        // Wait for done
+        pWaitFor(() => this.isGradingReady()).then(() =>
+        {
+            // When the assignments are ready
+            // TODO: Display loading
+            this.assignmentsReady = true;
+        })
+    }
+
+    /**
+     * Are grading algorithms ready or not.
+     *
+     * @returns boolean Ready or not
+     */
+    private isGradingReady(): boolean
+    {
+        for (const course of this.filteredCourses)
+        {
+            if (course.grading == undefined)
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
     /**
      * This is called when a navigation tab is clicked
      *

src/components/app/app.vue

@@ -1,13 +1,15 @@
 <template>
     <div id="app">
         <login v-if="showLogin" v-on:login:token="onLogin" :http="http"></login>
-        <navigation :courses="courses"
+        <navigation :courses="filteredCourses"
                     v-on:sign-out="signOut()"
                     v-on:navigation:select="onNavigate">
         </navigation>
 
         <div id="app-content">
-            <overall :courses="courses" v-if="selectedTab === 'overall' && assignmentsReady"></overall>
+            <overall :courses="filteredCourses"
+                     v-if="selectedTab === 'overall' && assignmentsReady">
+            </overall>
         </div>
     </div>
 </template>

src/constants.ts

@@ -13,5 +13,31 @@ export default class Constants
         '|    |.  ,    |---|,---.,---.|    ,   .,---,,---.,---.\n' +
         ' \\  /  ><     |   ||   |,---||    |   | .-\' |---\'|    \n' +
         '  `\'  \'  `    `   \'`   \'`---^`---\'`---|\'---\'`---\'`    \n' +
-        '      v0.1.2.236                  `---\'               '
+        '      v0.2.3.315                  `---\'               ';
+
+    // Graph Theme
+    public static THEME =
+    {
+        // Colors
+        colors:
+        [
+            '#18cea5',
+            '#4fa8ed',
+            '#f9627b',
+            '#ffb075',
+            '#005c9c',
+            '#bcabe0',
+            '#d36e75',
+            '#fc97af',
+            '#919e8b',
+            '#d7ab82',
+            '#6e7074',
+            '#61a0a8',
+            '#efa18d',
+            '#787464',
+            '#cc7e63',
+            '#724e58',
+            '#4b565b'
+        ]
+    }
 }

src/pages/overall/graph-average/graph-average.scss

@@ -0,0 +1,7 @@
+#graph-average
+{
+    .graph
+    {
+        margin-top: 50px;
+    }
+}

src/pages/overall/graph-average/graph-average.ts

@@ -0,0 +1,112 @@
+import {Component, Prop, Vue} from 'vue-property-decorator';
+import {Course} from '@/components/app/app';
+import {GPAUtils} from '@/utils/gpa-utils';
+import Constants from '@/constants';
+
+@Component({
+})
+export default class GraphAverage extends Vue
+{
+    // @ts-ignore
+    @Prop({required: true}) courses: Course[];
+
+    /**
+     * Generate settings
+     */
+    get chartSettings()
+    {
+        let settings =
+        {
+            // Title
+            title:
+            {
+                show: true,
+                textStyle:
+                {
+                    fontSize: 12
+                },
+                text: 'Course GPA',
+                subtext: 'Current GPA for every course',
+                x: 'center'
+            },
+
+            // X axis represents course names
+            xAxis:
+            {
+                type: 'category',
+                axisLabel: {
+                    interval: 0,
+                    inside: false,
+                    rotate: 90,
+
+                    // Truncate text length
+                    formatter: (value: string) => value.length <= 16 ? value : value.substr(0, 14) + '...'
+                },
+            },
+
+            // Y axis represents GPAs and MaxGPAs
+            yAxis:
+            {
+                type: 'value'
+            },
+
+            // Data
+            series:
+            [
+                {
+                    type: 'bar',
+                    barGap: '-100%',
+                    data: this.courses.map(course =>
+                    {
+                        return {value: [course.name, GPAUtils.getGP(course, 'A+')],
+                            itemStyle: {color: '#d8d8d8'}}
+                    }),
+                },
+                {
+                    type: 'bar',
+                    barGap: '-100%',
+                    data: this.generateGPData(),
+
+                    label:
+                    {
+                        show: true,
+                        rotate: 90
+                    }
+                }
+            ],
+
+            // Disable tooltip
+            tooltip:
+            {
+                show: false
+            }
+        };
+
+        // TODO: Remove this
+        console.log(settings);
+
+        return settings;
+    }
+
+    /**
+     * Generate GP data for each course
+     */
+    private generateGPData()
+    {
+        let data: any = [];
+
+        this.courses.forEach(course =>
+        {
+            data.push(
+            {
+                value: [course.name, GPAUtils.getGP(course, course.letterGrade)],
+                itemStyle:
+                {
+                    color: Constants.THEME.colors[data.length]
+                }
+            });
+        });
+
+        return data;
+    }
+}

src/pages/overall/graph-average/graph-average.vue

@@ -0,0 +1,9 @@
+<template>
+    <div id="graph-average">
+        <ve-bar height="450px" class="graph"
+                :extend="chartSettings"></ve-bar>
+    </div>
+</template>
+
+<script src="./graph-average.ts" lang="ts"></script>
+<style src="./graph-average.scss" lang="scss"></style>

src/pages/overall/graph-overall/graph-overall.ts

@@ -5,17 +5,177 @@ import {Course} from '@/components/app/app';
 })
 export default class GraphOverall extends Vue
 {
-    @Prop({required: true}) chart: any;
+    // @ts-ignore
+    @Prop({required: true}) courses: Course[];
 
     private settings =
     {
+        // Title
+        title:
+        {
+            show: true,
+            textStyle:
+            {
+                fontSize: 12
+            },
+            text: 'Average Grade',
+            subtext: 'Average score trend for every course',
+            x: 'center'
+        },
+        // Legend
+        legend:
+        {
+            show: false,
+            //left: 'auto',
+            //align: 'left',
+            //orient: 'vertical'
+            textStyle:
+            {
+                fontSize: 11
+            },
+            icon: 'circle'
+        },
+        // Zoom bar
+        dataZoom:
+        [
+            // TODO: Calculate real value for startValue
+            {
+                startValue: '9/13/2019'
+            },
+            {
+                type: 'inside'
+            }
+        ],
         series:
         {
-            smooth: false
+            smooth: true
+        },
+        xAxis:
+        {
+            //type: 'time'
         },
         yAxis:
         {
-            min: 70
+            min: (value: any) => value.min - 10
+        }
+    };
+
+    /**
+     * Convert assignments list to a graph dataset.
+     */
+    get convertChart()
+    {
+        let courses = this.courses;
+
+        // Compute the column names
+        let columns = courses.map(course => course.name);
+        columns.unshift('date');
+
+        // Find the min date
+        let minDates = courses.map(course => new Date(course.assignments[course.assignments.length - 1].date).getTime());
+        let minDate: Date = new Date(Math.min.apply(null, minDates));
+
+        // Find the dates in between
+        let now = new Date();
+        let dates = [];
+        for (let date = minDate; date <= now; date.setDate(date.getDate() + 1))
+        {
+            dates.push(new Date(date));
+        }
+
+        // Compute the rows data
+        let rows: {[index: string]: any}[] = [];
+        dates.forEach(date =>
+        {
+            // Define row object
+            let row: {[index: string]:any} = {'date': date.toLocaleDateString('en-US')};
+
+            // Loop through courses
+            courses.forEach(course =>
+            {
+                // Total Mean
+                if (course.grading.method == 'TOTAL_MEAN')
+                {
+                    let score = 0;
+                    let max = 0;
+
+                    // Loop through assignments
+                    course.assignments.forEach(assignment =>
+                    {
+                        // If assignment should be displayed
+                        if (assignment.complete != 'Complete') return;
+
+                        // Date is being looked at
+                        let assignmentDate = new Date(assignment.date);
+                        if (assignmentDate.getTime() < date.getTime())
+                        {
+                            // Record scores
+                            score += assignment.score;
+                            max += assignment.scoreMax;
+                        }
+                    });
+
+                    // Add average to the row
+                    row[course.name] = score / max * 100;
+                }
+                else if (course.grading.method == 'PERCENT_TYPE')
+                {
+                    let typeScores: {[index: string]: any} = {};
+                    let typeCounts: {[index: string]: any} = {};
+
+                    // Loop through assignments
+                    course.assignments.forEach(assignment =>
+                    {
+                        // If assignment should be displayed
+                        if (assignment.complete != 'Complete') return;
+
+                        // Date is being looked at
+                        let assignmentDate = new Date(assignment.date);
+                        if (assignmentDate.getTime() < date.getTime())
+                        {
+                            // Record scores
+                            if (typeScores[assignment.type] == undefined) typeScores[assignment.type] = 0;
+                            typeScores[assignment.type] += assignment.score / assignment.scoreMax;
+
+                            if (typeCounts[assignment.type] == undefined) typeCounts[assignment.type] = 0;
+                            typeCounts[assignment.type] ++;
+                        }
+                    });
+
+                    // Count total percentage (This is to avoid less than expected cases)
+                    // Eg. If HW = 25% and Quiz = 75%, I have 1 hw and 0 quiz
+                    // Without total percentage, the avg grade I get is 25%.
+                    let totalPercentage = 0;
+                    for (let type in course.grading.weightingMap)
+                    {
+                        if (typeScores[type] != undefined)
+                        {
+                            totalPercentage += course.grading.weightingMap[type];
+                        }
+                    }
+
+                    // Count
+                    let score = 0;
+                    for (let type in typeScores)
+                    {
+                        let typeFactor = course.grading.weightingMap[type] / totalPercentage;
+                        score += typeScores[type] * typeFactor / typeCounts[type];
+                    }
+
+                    // Add average to the row
+                    if (score != 0) row[course.name] = score * 100;
+                }
+            });
+
+            // Add it to the array
+            rows.push(row);
+        });
+
+        console.log(rows);
+
+        return {
+            columns: columns,
+            rows: rows
         }
     }
 }

src/pages/overall/graph-overall/graph-overall.vue

@@ -1,7 +1,6 @@
 <template>
     <div id="graph-overall">
-        <p>Your average score graph all time:</p>
+        <ve-line :data="convertChart" :extend="settings"></ve-line>
-        <ve-line :data="chart" :extend="settings"></ve-line>
     </div>
 </template>
 

src/pages/overall/overall.scss

@@ -46,3 +46,17 @@
 {
     font-size: 11px;
 }
+
+// Graph average
+.graph-average-card
+{
+    margin-right: 20px;
+    min-width: 170px;
+}
+
+// Fix padding
+.el-card__body
+{
+    padding-top: 0 !important;
+    padding-bottom: 0 !important;
+}

src/pages/overall/overall.ts

@@ -1,155 +1,23 @@
 import {Component, Prop, Vue} from 'vue-property-decorator';
 import GraphOverall from '@/pages/overall/graph-overall/graph-overall';
+import GraphAverage from '@/pages/overall/graph-average/graph-average';
 import {Course} from '@/components/app/app';
 import {GPAUtils} from '@/utils/gpa-utils';
 
 @Component({
-    components: {GraphOverall}
+    components: {GraphOverall, GraphAverage}
 })
 export default class Overall extends Vue
 {
     // @ts-ignore
     @Prop({required: true}) courses: Course[];
 
-    /**
-     * Convert assignments list to a graph dataset.
-     */
-    get convertCharts()
-    {
-        // Null case
-        if (this.courses == null) return [];
-
-        // Filter it
-        let courses: Course[] = this.filterCourses();
-
-        // Compute the column names
-        let columns = ['date'];
-        courses.forEach(course =>
-        {
-            columns.push(course.name);
-        });
-
-        // Find the min date
-        let minDate: Date = new Date();
-        courses.forEach(course =>
-        {
-            if (course.assignments.length == 0) return;
-            let date = new Date(course.assignments[course.assignments.length - 1].date);
-            if (date < minDate) minDate = date;
-        });
-
-        // Find the dates in between
-        let now = new Date();
-        let dates = [];
-        for (let date = minDate; date <= now; date.setDate(date.getDate() + 1))
-        {
-            dates.push(new Date(date));
-        }
-
-        // Initialize course specific variables
-        let courseScores: {[index: string]: any} = {};
-        let courseMaxScores: {[index: string]: any} = {};
-        let courseIndexes: {[index: string]: any} = {};
-        courses.forEach(course =>
-        {
-            courseScores[course.name] = 0;
-            courseMaxScores[course.name] = 0;
-            courseIndexes[course.name] = course.assignments.length - 1;
-        });
-
-        // Compute the rows data
-        let rows: {[index: string]: any}[] = [];
-        dates.forEach(date =>
-        {
-            // Define row object
-            let row: {[index: string]:any} = {'date': date.toLocaleDateString('en-US')};
-
-            // Loop through courses
-            courses.forEach(course =>
-            {
-                // Reversed loop through the assignments
-                for (let r = courseIndexes[course.name]; r >= 0; r--)
-                {
-                    let assignment = course.assignments[r];
-
-                    // If assignment should be displayed
-                    if (assignment.complete != 'Complete') continue;
-
-                    // Date is being looked at
-                    let assignmentDate = new Date(assignment.date);
-                    if (assignmentDate.getTime() == date.getTime())
-                    {
-                        // Record scores
-                        courseScores[course.name] += assignment.score;
-                        courseMaxScores[course.name] += assignment.scoreMax;
-                    }
-
-                    // Not now
-                    else if (assignmentDate > date)
-                    {
-                        courseIndexes[course.name] = r;
-                        break;
-                    }
-                }
-
-                // Add average to the row
-                row[course.name] = courseScores[course.name] / courseMaxScores[course.name] * 100;
-            });
-
-            // Add it to the array
-            rows.push(row);
-        });
-
-        console.log(rows);
-
-        return {
-            columns: columns,
-            rows: rows
-        }
-    }
-
-    /**
-     * Return a list of courses that are graphed
-     */
-    private filterCourses(): Course[]
-    {
-        // Define result
-        let result: Course[] = [];
-
-        // Filter through courses
-        this.courses.forEach(course =>
-        {
-            // Skip future or past courses
-            if (course.status != 'active') return;
-
-            // Skip courses without levels
-            if (course.level == 'None') return;
-
-            // Skip courses without assignments
-            if (course.assignments.length == 0) return;
-
-            // Add it to the list
-            result.push(course);
-        });
-
-        return result;
-    }
-
     /**
      * This function is called to get gpa since I can't import another
      * class in the Vue file.
      */
     public getGPA()
     {
-        let gpa = GPAUtils.getGPA(this.courses);
+        return GPAUtils.getGPA(this.courses);
-        // let result = '' + gpa.gpa;
-
-        /* Not accurate
-        if (!gpa.accurate)
-        {
-            result = `(${result})`;
-        }*/
-
-        return gpa;
     }
 }

src/pages/overall/overall.vue

@@ -13,9 +13,14 @@
                     </div>
                 </el-card>
             </el-col>
-            <el-col :span="20">
+            <el-col :span="14">
-                <el-card style="margin-right: 20px">
+                <el-card>
-                    <graph-overall :chart="convertCharts"></graph-overall>
+                    <graph-overall :courses="courses"></graph-overall>
+                </el-card>
+            </el-col>
+            <el-col :span="6">
+                <el-card class="graph-average-card">
+                    <graph-average :courses="courses"></graph-average>
                 </el-card>
             </el-col>
         </el-row>

src/utils/course-utils.ts

@@ -0,0 +1,37 @@
+import {Course} from '@/components/app/app';
+
+export class CourseUtils
+{
+    /**
+     * Return a list of courses that are graphed
+     *
+     * @param original Original course list
+     * @return Course[] Filtered course list
+     */
+    public static getGradedCourses(original: Course[]): Course[]
+    {
+        // Define result
+        let result: Course[] = [];
+
+        // Filter through courses
+        original.forEach(course =>
+        {
+            // Skip future or past courses
+            if (course.status != 'active') return;
+
+            // Skip courses without levels
+            if (course.level == 'None') return;
+
+            // Skip courses without assignments
+            if (course.assignments.length == 0) return;
+            
+            // Skip if there are no grading scale
+            // if (course.grading.method == 'NOT_GRADED') return;
+
+            // Add it to the list
+            result.push(course);
+        });
+
+        return result;
+    }
+}

src/utils/deprecated.txt

@@ -0,0 +1,100 @@
+        // Initialize course specific variables
+        let courseScores: {[index: string]: any} = {};
+        let courseMaxScores: {[index: string]: any} = {};
+        let courseIndexes: {[index: string]: any} = {};
+        courses.forEach(course =>
+        {
+            courseScores[course.name] = 0;
+            courseMaxScores[course.name] = 0;
+            courseIndexes[course.name] = course.assignments.length - 1;
+        });
+
+        // Compute the rows data
+        let rows: {[index: string]: any}[] = [];
+        dates.forEach(date =>
+        {
+            // Define row object
+            let row: {[index: string]:any} = {'date': date.toLocaleDateString('en-US')};
+
+            // Loop through courses
+            courses.forEach(course =>
+            {
+                // Reversed loop through the assignments
+                for (let r = courseIndexes[course.name]; r >= 0; r--)
+                {
+                    let assignment = course.assignments[r];
+
+                    // If assignment should be displayed
+                    if (assignment.complete != 'Complete') continue;
+
+                    // Date is being looked at
+                    let assignmentDate = new Date(assignment.date);
+                    if (assignmentDate.getTime() == date.getTime())
+                    {
+                        // Detect grading method and record scores
+                        if (course.grading.method == 'TOTAL_MEAN')
+                        {
+                            courseScores[course.name] += assignment.score;
+                            courseMaxScores[course.name] += assignment.scoreMax;
+                        }
+                        else if (course.grading.method == 'PERCENT_TYPE')
+                        {
+                            let scale = course.grading.weightingMap[assignment.type];
+                            courseScores[course.name] += assignment.score * scale;
+                            courseMaxScores[course.name] += assignment.scoreMax * scale;
+                        }
+                    }
+
+                    // Not now
+                    else if (assignmentDate > date)
+                    {
+                        courseIndexes[course.name] = r;
+                        break;
+                    }
+                }
+
+                // Add average to the row
+                row[course.name] = courseScores[course.name] / courseMaxScores[course.name] * 100;
+            });
+
+            // Add it to the array
+            rows.push(row);
+        });
+
+
+                else if (course.grading.method == 'PERCENT_TYPE')
+                {
+                    let typeScores: {[index: string]: any} = {};
+                    let typeCounts: {[index: string]: any} = {};
+
+                    // Loop through assignments
+                    course.assignments.forEach(assignment =>
+                    {
+                        // If assignment should be displayed
+                        if (assignment.complete != 'Complete') return;
+
+                        // Date is being looked at
+                        let assignmentDate = new Date(assignment.date);
+                        if (assignmentDate.getTime() < date.getTime())
+                        {
+                            // Record scores
+                            if (typeScores[assignment.type] == undefined) typeScores[assignment.type] = 0;
+                            typeScores[assignment.type] += assignment.score / assignment.scoreMax;
+
+                            if (typeCounts[assignment.type] == undefined) typeCounts[assignment.type] = 0;
+                            typeCounts[assignment.type] ++;
+                        }
+                    });
+
+                    let score = 0;
+
+                    // Count
+                    for (let type in typeScores)
+                    {
+                        score += typeScores[type] * course.grading.weightingMap[type] / typeCounts[type];
+                        console.log(type);
+                    }
+
+                    // Add average to the row
+                    row[course.name] = score * 100;
+                }

src/utils/gpa-utils.ts

@@ -102,4 +102,29 @@ export class GPAUtils
 
         return -1;
     }
+
+    /**
+     * Calculate the total-mean (total/max) average
+     *
+     * @param course Course
+     */
+    public static getTotalMeanAverage(course: Course)
+    {
+        let score = 0;
+        let max = 0;
+
+        // Loop through assignments
+        course.assignments.forEach(assignment =>
+        {
+            // If assignment should be displayed
+            if (assignment.complete != 'Complete') return;
+
+            // Record scores
+            score += assignment.score;
+            max += assignment.scoreMax;
+        });
+
+        // Return
+        return score / max * 100;
+    }
 }