moodle-local_treestudyplan/amd/src/studyplan-report-components.js

/*eslint no-var: "error"*/
/*eslint no-console: "off"*/
/*eslint no-unused-vars: warn */
/*eslint max-len: ["error", { "code": 160 }] */
/*eslint-disable no-trailing-spaces */
/*eslint-env es6*/
// Put this file in path/to/plugin/amd/src

import {load_strings} from './util/string-helper';
import {call} from 'core/ajax';
import notification from 'core/notification';
import Debugger from './util/debugger';
import Config from 'core/config';
import TSComponents from './treestudyplan-components';
import FitTextVue from './util/fittext-vue';


const debug = new Debugger("treestudyplan-viewer");


// Make π available as a constant
const π = Math.PI;
// Gravity value for arrow lines - determines how much a line is pulled in the direction of the start/end before changing direction
const LINE_GRAVITY = 1.3;

/**
 * Retrieve condition headers
 * @param {Object} item
 */
function conditionHeaders(item) {
    const course = item.course;
    const list = [];
    if (course.competency) {
        for (const cmp of course.competency.competencies) {
            list.push({
                name: cmp.title,
            });
        }
    } else if(course.completion) {
        for (const cnd of course.completion.conditions) {
            for (const itm of cnd.items) {
                list.push({
                    name: itm.title,
                });
            }
        }
    } else if(course.grades) {
        for(const g of course.grades) {
            if (g.selected) {
                list.push({
                    name: g.name,
                });
            }
        }
    }
    return list;
}

/**
 * Retrieve conditions
 * @param {Object} item
 */
function conditions(item) {
    const course = item.course;
    const list = [];
    if (course.competency) {
        for (const cmp of course.competency.competencies) {
            list.push(cmp);
        }
    } else if(course.completion) {
        for (const cnd of course.completion.conditions) {
            for (const itm of cnd.items) {
                list.push(itm);
            }
        }
    } else if(course.grades) {
        for(const g of course.grades) {
            if (g.selected) {
                list.push(g);
            }
        }
    }
    return list;
}


export default {
    install(Vue/*,options*/){
        Vue.use(TSComponents);
        Vue.use(FitTextVue);

        let strings = load_strings({
            report: {
                loading: "loadinghelp@core",
                studyplan_past: "studyplan_past",
                studyplan_present: "studyplan_present",
                studyplan_future: "studyplan_future",
                back: "back",
            },
            
            invalid: {
                error: 'error',
            },
            header: {
                overall: 'overall',
                students: 'students@core'
            },
            studentresults: {
                completion_incomplete: "completion_incomplete",
                completion_failed: "completion_failed",
                completion_pending: "completion_pending",
                completion_progress: "completion_progress",
                completion_completed: "completion_completed",
                completion_good: "completion_good",
                completion_excellent: "completion_excellent",
                student_not_tracked: "student_not_tracked",
            }
        });

        /************************************
         *                                  *
         * Treestudyplan Viewer components  *
         *                                  *
         ************************************/

        Vue.component('q-studyplanreport', {
            props: {
                structure: {
                    type: Object,
                },
            },
            data() {
                return {
                    students: [],
                    studentresults: {},
                    expansioninfo: {
                        periods: {},
                        lines: {},
                        items: {},
                    },
                    groupinfo: {},

                    sorting: {
                        name: "asc",
                    }
                };
            },
            created() {
                this.loadStudents();
            },
            watch:{
                structure: {
                    immediate: true,
                    handler (structure) {
                        // (Re)build expansion info structure
                        let firstperiod = true;
                        for (const period of structure.periods) {
                            const pid = period.period.id;
                            if (!this.expansioninfo.periods[pid]) {
                                // Use this.$set to make sure the properties are reactive.
                                this.$set(
                                    this.expansioninfo.periods, 
                                    pid, 
                                    {
                                        expanded: (firstperiod?true:false),
                                    }
                                );
                                this.$set(
                                    this.expansioninfo.lines, 
                                    period.period.id, 
                                    {}
                                );
                            }
                            for (const line of period.lines) {
                                const lid = line.line.id;
                                if (!this.expansioninfo.lines[lid]) {
                                    // Use this.$set to make sure the properties are reactive.
                                    this.$set(
                                        this.expansioninfo.lines[pid],
                                        lid, 
                                        {
                                            expanded: true,
                                        }
                                    );
                                }
                                for (const item of line.items) {
                                    if (!this.expansioninfo.items[item.id]) {
                                        // Use this.$set to make sure the properties are reactive.
                                        this.$set(
                                            this.expansioninfo.items,
                                            item.id,
                                            {
                                            expanded: false,
                                            }
                                        );
                                    }
                                }
                            }
                            firstperiod = false;
                        }
                    }
                }
            },
            computed: {
                sortedstudents(){
                    return this.students;
                },
                resultColCount(){
                    let count = 0;
                    for (const period of this.structure.periods) {
                        const pid = period.period.id;
                        if (!this.expansioninfo.periods[pid].expanded) {
                            // This period is not expanded. Make it 3 units wide 
                            count += 3;
                        } else {
                            for (const line of period.lines) {
                                const lid = line.line.id;
                                if (!this.expansioninfo.lines[pid][lid].expanded) {
                                    count +=1;
                                } else { 
                                    for (const item of line.items) {
                                        if (!this.expansioninfo.items[item.id].expanded) {
                                            count += 1;
                                        } else {
                                            count += 1 + conditions(item).length;
                                        }
                                    }
                                }
                            }
                        }
                    }
                    return count;           
                }
            },
            methods: {
                loadStudents() {
                    const self = this;
                    call([{
                        methodname: 'local_treestudyplan_all_associated_grouped',
                        args: { studyplan_id: this.structure.studyplan.id}
                    }])[0].then(function(response){
                        self.students = response;
                        for(const group of self.students) {
                            self.$set(
                                self.groupinfo,
                                group.label,
                                {
                                  expand: true,
                                }
                            );

                            for(const student of group.users){
                                self.$set(
                                    self.studentresults,
                                    student.id, 
                                    {
                                        loading: true,
                                        results: [],
                                    }
                                );
                                call([{
                                    methodname: 'local_treestudyplan_get_report_data',
                                    args: { pageid: self.structure.page.id, 
                                            userid: student.id,
                                            firstperiod: self.structure.firstperiod,
                                            lastperiod: self.structure.lastperiod,
                                        }
                                }])[0].then(function(response){
                                    self.studentresults[student.id].loading = false;
                                    self.studentresults[student.id].results = response;
                                }).catch(notification.exception);
                            }
                        }
                    }).catch(notification.exception);
                },
                expansionChanged(parm, id, val) {
                    if(parm[0] == 'p') {
                        parm = 'periods';
                    } else if(parm[0] == 'l') {
                        parm = 'lines';
                    } else {
                        parm = 'items';
                    }
                    debug.info('Expansion Changed',parm,id,val);

                    if (parm == 'lines') {
                        this.expansioninfo[parm][id[0]][id[1]].expanded = val;
                    } else {
                        this.expansioninfo[parm][id].expanded = val;
                    }
                },

            },
            template: `
            <table class='q-studyplanreport'
                :style="'--resultColCount: '+resultColCount+';'">
                <q-header 
                    :sorting='sorting' 
                    :structure='structure'
                    :expansion='expansioninfo'
                    @expansion='expansionChanged'
                ></q-header>
                <template v-for="group in sortedstudents">
                    <q-groupheading v-if="group.users" :label="group.label" :groupinfo="groupinfo[group.label]"></q-groupheading>
                    <template v-if='group.users && groupinfo[group.label].expand'>
                        <q-studentresults v-for="student in group.users"
                            :student='student'
                            :structure='structure'
                            :results='studentresults[student.id].results'
                            :loading='studentresults[student.id].loading'
                            :expansion='expansioninfo'
                            ></q-studentresults>
                    </template>
                </template>
            </table>
            `,
        });

        Vue.component('q-header', {
            props: {
                structure: {
                    type: Object,
                },
                sorting: {
                    type: Object,
                },
                expansion: {
                    type: Object
                },
            },
            data() {
                return {
                    text: strings.header,
                };
            },
            computed: {
            },
            methods: {
                conditions(item) {
                    return conditionHeaders(item);
                },
                colspanPeriod(period) {
                    const pid = period.period.id;
                    if (this.expansion.periods[pid].expanded) {
                        let sum = 0;
                        for (const l of period.lines) {
                            sum += this.colspanLine(period,l);
                        }
                        return sum;
                    } else {
                        return 1;
                    }
                },
                colspanLine(period,line) {
                    const pid = period.period.id;
                    const lid = line.line.id;

                    if (this.expansion.lines[pid][lid].expanded) {
                        let sum = 0;
                        for (const i of line.items) {
                            sum += this.colspanItem(i);
                        }
                        return sum;
                    } else {
                        return 1;
                    }
                },
                colspanItem(item) {
                    if (this.expansion.items[item.id].expanded) {
                        const cs = this.conditions(item);
                        return 1+cs.length;
                    } else {
                        return 1;
                    }
                },
                togglePeriod(period,val) {
                    if ( val === undefined) {
                        val = !(this.expansion.periods[period.id].expanded);
                    }
                    this.$emit('expansion','periods',period.id,val);
                },
                toggleLine(period,line,val) {
                    if ( val === undefined) {
                        val = !(this.expansion.lines[period.id][line.id].expanded);
                    }
                    this.$emit('expansion','lines',[period.id,line.id],val);
                },
                toggleItem(item,val) {
                    if ( val === undefined) {
                        val = !(this.expansion.items[item.id].expanded);
                    }
                    debug.info("Toggle item",item,val);
                    this.$emit('expansion','items',item.id,val);
                },
            },
            mounted() {
                
            },
            updated() {
            },
            /* https://css-tricks.com/position-sticky-and-table-headers/ */
            /* TODO: Rework below to make use of tables. Use <Thead> as main element. Then create multiple <tr> as needed for the headers.
               This should create a much better view than using divs overal.
            */
            template: `
            <thead class='q-header'>
                <tr> <!-- period heading -->
                    <th rowspan='4' class='q-studentname'><span>{{text.students}}</span></th>
                    <th v-for="p in structure.periods" 
                        :class="'q-period-heading '+ ((expansion.periods[p.period.id].expanded)?'expanded':'collapsed')"
                        :colspan='colspanPeriod(p)'
                        :rowspan='(expansion.periods[p.period.id].expanded)?1:4'
                        ><span class="q-wrap"><a href='#' @click.prevent="togglePeriod(p.period)"
                            ><i v-if="expansion.periods[p.period.id].expanded" 
                                class='q-chevron fa fa-chevron-down'></i
                            ><i v-else class='q-chevron fa fa-chevron-right'></i
                        >&nbsp;{{ p.period.fullname}}</a></span
                    ></th>
                </tr>
                <tr> <!-- line heading -->
                    <template v-for="p in structure.periods">
                        <template v-if="expansion.periods[p.period.id].expanded">              
                            <th v-for="l in p.lines"
                                :class="'q-line-heading ' + ((expansion.lines[p.period.id][l.line.id].expanded)?'expanded':'collapsed')"
                                :colspan="colspanLine(p,l)"
                                :rowspan='(expansion.lines[p.period.id][l.line.id].expanded)?1:3'
                                ><span class="q-wrap"><fittext vertical maxsize="18pt"
                                    ><span  class='q-label'
                                            :title="l.line.shortname"
                                            v-html="l.line.shortname"
                                    ></span
                                ></fittext></span
                            ></th>
                        </template>
                    </template>
                </tr>
                <tr> <!-- item heading -->
                    <template v-for="p in structure.periods">      
                        <template v-if="expansion.periods[p.period.id].expanded">                 
                            <template v-for="l in p.lines">
                                <template v-if="expansion.lines[p.period.id][l.line.id].expanded">
                                    <th v-for="item in l.items"
                                        :class="'q-item-heading ' + ((expansion.items[item.id].expanded)?'expanded':'collapsed')"
                                        :colspan="colspanItem(item)"
                                        :rowspan='(expansion.items[item.id].expanded)?1:2'
                                        ><span class="q-wrap"><a href='#' 
                                            @click.prevent="toggleItem(item)"
                                            ><i v-if="expansion.items[item.id].expanded" 
                                                class='q-chevron fa fa-chevron-down'></i
                                            ><i v-else 
                                                class='q-chevron fa fa-chevron-right'></i
                                        ></a
                                        >&nbsp;<a style="display: inline-block;" href='#' 
                                            @click.prevent="toggleItem(item)"
                                            ><fittext vertical maxsize="18pt" singleline
                                            ><span class='q-label'
                                                    :title="item.course.displayname" 
                                                    v-html="item.course.displayname"
                                                ></span
                                            ></fittext
                                        ></a></span
                                    ></th>
                                </template>
                            </template>
                        </template>
                    </template>
                </tr>
                <tr> <!-- condition heading -->
                    <template v-for="p in structure.periods">
                        <template v-if="expansion.periods[p.period.id].expanded">     
                            <template v-for="l in p.lines">
                                <template v-if="expansion.lines[p.period.id][l.line.id].expanded">
                                    <template v-for="item in l.items">
                                        <template v-if="expansion.items[item.id].expanded">
                                            <th class='q-condition-heading overall'
                                                ><span class='q-wrap'>{{ text.overall }}</span></th>
                                            <th v-for="c in conditions(item)"
                                                class='q-condition-heading'
                                                ><span class="q-wrap"><fittext vertical maxsize="18pt"><span class='q-label'
                                                        :title="c.name"
                                                        v-html="c.name"></span
                                                ></span></fittext
                                            ></th>
                                        </template>
                                    </template>
                                </template>
                            </template>
                        </template>
                    </template>
                </tr>
            </thead>
            `,
        });

        Vue.component('q-groupheading', {
            props: {
                structure: {
                    type: Object,
                },
            },
            data() {
                return {

                };
            },
            computed: {
            },
            methods: {
            },
            template: `
            <tr class='q-groupheading'>

            </tr>
            `,
        });

        Vue.component('q-studentresults', {
            props: {
                student: {
                    type: Object,
                },
                structure: {
                    type: Object,
                },
                results: {
                    type: Array,
                },
                loading: {
                    type: Boolean,
                    default: false
                },
                expansion: {
                    type: Object,
                },
            },
            data() {
                return {
                    text: strings.studentresults,
                };
            },
            computed: {
            },
            methods: {
                useritems(line) {
                    const list = [];
                    for (const item of line.items) {
                        let newitm = item;
                        for (const itm of this.results) {
                            if (item.id == itm.id) {
                                newitm = itm;
                                break;
                            }
                        }
                        list.push(newitm);
                    }
                    return list;
                },
                conditions(item) {
                    return conditions(item);
                },
            },
            /* https://css-tricks.com/position-sticky-and-table-headers/ */
            /* TODO: Rework below to make use of tables. Use <Thead> as main element. Then create multiple <tr> as needed for the headers.
               This should create a much better view than using divs overal.
               */
            template: `
            <tr class='q-student-results'>
                <td class='q-studentname'><span>{{student.firstname}} {{student.lastname}}</span></td>
                <template v-for="p in structure.periods">
                    <template v-if="expansion.periods[p.period.id].expanded">     
                        <template v-for="l in p.lines">
                            <template v-if="expansion.lines[p.period.id][l.line.id].expanded">
                                <template v-for="item in useritems(l)">
                                    <td class='q-result overall'
                                        ><q-courseresult
                                            :item="item"
                                            :student="student"
                                            :loading="loading"
                                        ></q-courseresult
                                    ></td>
                                    <template v-if="expansion.items[item.id].expanded">
                                        <td v-for="(c,idx) in conditions(item)"
                                            class='q-result'
                                            ><q-conditionresult
                                                :item="item"
                                                :conditionidx="idx"
                                                :student="student"
                                                :loading="loading"
                                            ></q-conditionresult
                                        ></td>
                                    </template>
                                </template>
                            </template>
                            <td v-else class='q-result collapsed'>&nbsp;</td>
                        </template>
                    </template>
                    <td v-else class='q-result collapsed'>&nbsp;</td>
                </template>
            </tr>
            `,
        });

        Vue.component('q-courseresult', {
            props: {
                student: {
                    type: Object,
                },
                item: {
                    type: Object,
                },
                loading: {
                    type: Boolean,
                    default: false
                },
            },
            data() {
                return {
                    text: strings.studentresults,
                };
            },
            computed: {
                hasprogressinfo() {
                    const course = this.item.course;
                    if (!course.enrolled) {
                        return false;
                    } else {
                        return (course.completion || course.competency || course.grades);
                    }
                },
                completion_icon() {
                    const completion = this.item.completion;
                    switch(completion){
                        default: // case "incomplete"
                            return "circle-o";
                        case "pending":
                            return "question-circle";
                        case "failed":
                            return "times-circle";
                        case "progress":
                            return "exclamation-circle";
                        case "completed":
                            return "check-circle";
                        case "good":
                            return "check-circle";
                        case "excellent":
                            return "check-circle";
                    }
                },
            },
            methods: {
            },
            template: `
            <span class='q-courseresult'>
                <template v-if="loading">
                    <div class="spinner-border spinner-border-sm text-info" role="status"></div>
                </template>
                <template v-else-if='!item.course.enrolled'>
                    <i v-b-popover.top
                        class="fa fa-exclamation-triangle t-not-enrolled-alert"
                        :title="text.student_not_tracked"></i>
                </template>
                <template v-else>
                    <i v-b-popover.top
                        :class="'fa fa-'+completion_icon+
                                ' r-completion-'+item.completion"
                        :title="text['completion_'+item.completion]"></i>
                </template>
            </span>
            `,
        });

        Vue.component('q-conditionresult', {
            props: {
                student: {
                    type: Object,
                },
                item: {
                    type: Object,
                },
                loading: {
                    type: Boolean,
                    default: false
                },
                conditionidx: {
                    type: Number,
                }
            },
            data() {
                return {
                    text: strings.studentresults,
                };
            },
            computed: {
                conditions() {
                    return conditions(this.item);
                },
                condition() {
                    if (this.conditionidx >= 0 && this.conditionidx < this.conditions.length) {
                        return this.conditions[this.conditionidx];
                    } else {
                        return null;
                    }
                },
                hasprogressinfo() {
                    const course = this.item.course;
                    if (!course.enrolled) {
                        return false;
                    } else {
                        return (course.completion || course.competency || course.grades);
                    }
                },
                completion_icon() {
                    const completion = this.condition_completion();
                    switch(completion){
                        default: // case "incomplete"
                            return "circle-o";
                        case "pending":
                            return "question-circle";
                        case "failed":
                            return "times-circle";
                        case "progress":
                            return "exclamation-circle";
                        case "completed":
                            return "check-circle";
                        case "good":
                            return "check-circle";
                        case "excellent":
                            return "check-circle";
                    }
                },
                condition_value() {
                    const course = this.item.course;
                    if (course.competency) {
                        if (this.condition.grade) {
                            // Return grade if possible.
                            return this.condition.grade;
                        } 
                    } else if(course.completion) {
                        if (this.condition.grade) {
                            // Return grade if possible.
                            return this.condition.grade;
                        } 
                    } else if(course.grades) {
                        return this.condition.grade;
                    }
                    // Fallback to completion icon.
                    const icon = this.completion_icon();
                    return `<i class='fa fa-${icon}'></i>`;
                },
                condition_completion() {
                    // Unify completion information
                    const course = this.item.course;
                    if (course.competency) {
                        const competency = this.condition;
                        if (competency.proficient && competency.courseproficient) {
                            return "completed";
                        } else if (competency.proficient) {
                            return "completed";
                        } else if (competency.proficient === false) {
                            return "failed";
                        } else if (competency.progress) {
                            return "progress";
                        } else {
                            return "incomplete";
                        }
                    } else if(course.completion) {
                        return this.condition.status;
                    } else if(course.grades) {
                        return this.condition.completion;
                    }
                }

            },
            methods: {
            },
            // TODO: Show actual grades when relevant at all (don;t forget the grade point completion requirement)
            template: `
            <span class='q-conditionresult'>
                <fittext maxsize="10pt" singleline dynamic>
                    <template v-if="loading">
                        <div class="spinner-border spinner-border-sm text-info" role="status"></div>
                    </template>
                    <template v-else-if='!item.course.enrolled'>
                        <i  class="fa fa-ellipsis-h"
                            :title="text.student_not_tracked"></i>
                    </template>
                    <template v-else>
                        <span 
                            :class="'r-completion-'+condition_completion"
                            :title="text['completion_'+condition_completion]"
                            >{{condition_value}}</span
                        >
                    </template>
                </fittext>
            </span>
            `,
        });



    },
};