@universis/evaluations/src/models/study-program-evaluation-event-model.js

Universis evaluations library

import {EdmMapping, EdmType} from '@themost/data';
import EvaluationEvent from "./evaluation-event-model";
import {DataError, TraceUtils, DataNotFoundError, LangUtils} from "@themost/common";
import moment from "moment";
/**
 * @class
 */
@EdmMapping.entityType('StudyProgramEvaluationEvent')
class StudyProgramEvaluationEvent  extends EvaluationEvent {
    /**
     * @constructor
     */
    constructor() {
        super();
    }

    @EdmMapping.func('Results', EdmType.CollectionOf('Object'))
    async getResults() {
        // check access to StudyProgramEvaluationEvent and get results silently
        const event = await this.context.model('StudyProgramEvaluationEvent').where('id').equal(this.getId());
        if (event) {
            const form = await this.getForm();
            return this.context.model(form.properties.name).where('evaluationEvent').equal(this.id).silent().prepare();
        }
    }

    @EdmMapping.action('GenerateEvaluationTokens', 'GenerateStudyProgramTokenAction')
    async generateEvaluationTokens() {
        const context = this.context;
        const action = {
            event: this.id,
            numberOfStudents: 0,
            total: 0,
            actionStatus: {alternateName: 'PotentialActionStatus'}
        };
        // get event
        const event = await context.model('StudyProgramEvaluationEvent').where('id').equal(this.id)
            .expand('studyProgram')
            .getItem();
        if (event) {
            //check if a GenerateTokenAction exists
            const prevAction = await context.model('GenerateStudyProgramTokenAction').where('event').equal(this.id)
                .and('actionStatus/alternateName').notEqual('FailedActionStatus')
                .silent().getItem();
            if (prevAction) {
                throw new Error(context.__('A previous action for generating evaluation tokens has been found.'));
            }
            const studyProgram = event.studyProgram;
            const studentStatuses = context.getConfiguration().getSourceAt('settings/universis/evaluations/studyProgramStudentStatuses') || ['graduated','declared'];
            let students;
            try {
                students = await this.getStudents(studyProgram, event.academicYear, event.academicPeriod, studentStatuses);
            }
            catch (err) {
                throw new DataError(err);
            }
            if (!(Array.isArray(students) && students.length)) {
                throw new DataError('E_STUDENTS_FOUND', context.__('No students available to evaluate this study program'));
            }
            action.numberOfStudents  = students.length;
            // save action and then generateTokens
            const generateAction = await context.model('GenerateStudyProgramTokenAction').save(action);
            const generateOptions =
                {
                    evaluationEvent: event.id,
                    n: action.numberOfStudents,
                    expires: event.endDate
                };
            try {
                // save number of students to event
                event.numberOfStudents = action.numberOfStudents;
                await context.model('StudyProgramEvaluationEvent').save(event);
                if (event.numberOfStudents > 0) {
                    await EvaluationEvent.generateTokens(context, generateOptions);
                }
                generateAction.total = action.numberOfStudents;
                generateAction.actionStatus = {alternateName: 'CompletedActionStatus'}
                return await context.model('GenerateStudyProgramTokenAction').save(generateAction);
            } catch (err) {
                TraceUtils.error(err);
                // update also action status
                generateAction.total = 0;
                generateAction.actionStatus = {alternateName: 'FailedActionStatus'}
                generateAction.description = err.message;
                return await context.model('GenerateStudyProgramTokenAction').save(generateAction);

            }


        }
    }

    async getStudents(studyProgram, academicYear, academicPeriod, studentStatuses) {
        try {
            const serviceProvider = await this.context.model('ServiceProvider')
                .where('alternateName').equal('universis')
                .silent().getTypedItem();
            if (serviceProvider == null) {
                TraceUtils.error(`Universis service provider not found.`);
                return new DataError(`Cannot get students for study program. Universis service provider not found.`);
            }
            let url = `Students?$select=id as student,person/email as email&$filter=studyProgram eq ${studyProgram.id}`
            if (Array.isArray(studentStatuses) && studentStatuses.length > 0) {
                const filters = [];
                // get active student for specific inscription year and period
                if (studentStatuses.includes('active')) {
                    filters.push(`(studentStatus/alternateName eq 'active' and inscriptionYear eq ${academicYear} and inscriptionPeriod eq ${academicPeriod}))`);
                }
                if (studentStatuses.includes('graduated')) {
                    filters.push(`(studentStatus/alternateName eq 'graduated' and graduationYear eq ${academicYear} and graduationPeriod eq ${academicPeriod})`);
                }
                if (studentStatuses.includes('declared')) {
                    filters.push(
                        `(studentStatus/alternateName eq 'declared' and declaration/declaredYear eq ${academicYear} and declaration/declaredPeriod eq ${academicPeriod})`
                    );
                }
                if (filters.length > 0) {
                    url += ` and (${filters.join(' or ')})`;
                }
            }
            const response = await serviceProvider.execute({
                "url": url,
                "method": 'GET'
            });
            return response && response.value;
        } catch (err) {
            TraceUtils.error(err);
            throw (err);
        }
    }

    @EdmMapping.func('TokenInfo', EdmType.CollectionOf('Object'))
    async getTokenStatistics() {
        const tokenInfo = {
            total: 0,
            used: 0,
            sent: 0
        };
        // get number of tokens
        const tokens = await this.context.model('EvaluationAccessToken').where('evaluationEvent').equal(this.getId())
            .select('count(evaluationEvent) as total', 'used', 'sent')
            .groupBy('used', 'sent', 'evaluationEvent')
            .silent().getItems();
        tokens.map(item => {
            tokenInfo.total += item.total;
            tokenInfo.used += item.used ? item.total : 0;
            tokenInfo.sent += item.sent ? item.total : 0;
        });
        return tokenInfo;
    }

    @EdmMapping.action('SendEvaluationTokens', 'SendStudyProgramTokenAction')
    async sendEvaluationTokens() {

        const context = this.context;
        let sendAction = {};
        let subject;
        // get event and check if event endDate has passed
        try {
            // get current date
            const currentDate = moment(new Date()).startOf('day').toDate(); // get only date format
            const event = await context.model('StudyProgramEvaluationEvent').where('id').equal(this.getId())
                .and('date(endDate)').greaterOrEqual(currentDate)
                .expand({
                        name: 'studyProgram',
                        options: {
                            '$expand': 'department'
                        }
                    },
                    {
                        name: 'actions',
                        options: {
                            '$expand': 'actionStatus'
                        }
                    })
                .getItem();
            // validate event
            if (event == null) {
                throw new DataNotFoundError('The event cannot be found or is inaccessible.');
            }
            // validate status
            if (!(event.eventStatus && event.eventStatus.alternateName === 'EventOpened')) {
                throw new DataError('E_INVALID_PERIOD', context.__('Send tokens action may only be executed for Open/Active events'));
            }
            // validate event actions
            if (!(event.actions && event.actions.length)) {
                throw new DataNotFoundError('E_NO_TOKENS', context.__('Token actions were not found for the specified event or they are inaccessible.'));
            }
            // find completed token generation action (can only be one)
            const successfulTokenAction = event.actions.find(generateTokenAction => generateTokenAction.actionStatus.alternateName === 'CompletedActionStatus');
            if (successfulTokenAction == null) {
                throw new DataError('E_NO_TOKENS', 'The specified event does not have a completed token generation action.');
            }
            // get tokenInfo for this event
            const tokenInfo = await this.getTokenStatistics();
            // validate sent-used separately for descriptive errors
            if (tokenInfo.sent) {
                throw new DataError('E_ALREADY_SENT', `${context.__('The bulk sending of the tokens could not be completed because some of them had already been sent')} (${tokenInfo.sent})`);
            }
            if (tokenInfo.used) {
                throw new DataError('E_ALREADY_USED', `${context.__('The bulk sending of the tokens could not be completed because some of them had already been used')} (${tokenInfo.used})`);
            }
            // start gathering students
            let students;
            const studyProgram = event.studyProgram;
            // get students
            const studentStatuses = ['graduated','declared','active']
            students = await this.getStudents(studyProgram,event.academicYear,event.academicPeriod,studentStatuses);

            if (!(Array.isArray(students) && students.length)) {
                throw new DataError('E_STUDENTS_FOUND', 'No recipients/students found.');
            }
            // check total of students
            if (students.length !== tokenInfo.total) {
                throw new DataError('E_TOTAL_STUDENTS',
                    `${this.context.__("The number of students in the study program differs from the generated tokens")}` +
                    `(${this.context.__("Students")}: ${students.length}, ${this.context.__("Number of tokens")}:${tokenInfo.total}.`);
            }
            // validate student emails, must all exist and have a valid format
            const mailRegex = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
            const invalidEmail = students.find(student => {
                return !(student.email && mailRegex.test(student.email));
            });
            if (invalidEmail) {
                throw new DataError('E_INVALID_EMAIL', `${context.__('At least one student\'s email is null or invalid')} (email:${invalidEmail.email || ' '} ${context.__('Student')}:${invalidEmail.student})`);
            }
            // get tokens
            let tokens = await this.context.model('EvaluationAccessToken').where('evaluationEvent').equal(this.getId())
                .silent()
                .getAllItems();

            // get mail template
            const mailTemplate = await context.model('MailConfiguration')
                .where('target').equal('SendStudyProgramTokenAction')
                .silent()
                .getItem();
            if (mailTemplate == null) {
                throw new DataError('E_MISSING_TEMPLATE', 'Cannot execute send tokens action because template is missing for SendStudyProgramTokenAction.');
            }
            // check if there is already an active sendTokensAction
            const alreadySendingTokens = await context.model('SendStudyProgramTokenAction')
                .where('event').equal(event.id)
                .and('actionStatus/alternateName').equal('ActiveActionStatus')
                .silent().count();
            if (alreadySendingTokens) {
                throw new DataError('E_ALREADY_SENDING', `${context.__('The bulk sending process of tokens is already in progress')}`);
            }
            // save SendInstructorTokenAction
            const sendTokenAction = {
                event: this.getId(),
                numberOfStudents: students.length,
                total: tokenInfo.total,
                sent: 0,
                failed: 0,
                actionStatus: {
                    alternateName: 'ActiveActionStatus'
                }
            }
            sendAction = await context.model('SendStudyProgramTokenAction').silent().save(sendTokenAction);
            // format mail subject expected params ${course}, ${instructor}
            const exp = new RegExp('\\$\\{\\w+\\}+', 'ig');
            subject = mailTemplate.subject;
            const params = subject.match(exp);
            if (params.length > 0) {
                // parse only custom parameters ${studyProgram}
                params.forEach(param => {
                    if (param === '${studyProgram}') {
                        // get studyProgram full name
                        subject = subject.replace(param, studyProgram ? `${studyProgram.name}` : '');
                    } else {
                        subject = subject.replace(param, '');
                    }
                });
            }
            EvaluationEvent.sendMessages(context, students, tokens, tokenInfo, mailTemplate, subject, sendAction, event);
        } catch (err) {
            TraceUtils.error(err);
            // create send tokens action
            const sendTokenAction = {
                event: this.getId(),
                numberOfStudents: 0,
                total: 0,
                sent: 0,
                failed: 0,
                actionStatus: {
                    alternateName: 'FailedActionStatus'
                },
                description: err.message
            }
            // and save
            if (sendAction && sendAction.id) {
                sendTokenAction.id = sendAction.id;
            }
            if (!subject) {
                // load courseClass
                const item = await context.model('StudyProgramEvaluationEvent').where('id').equal(this.getId())
                    .expand('studyProgram')
                    .getItem();
                const studyProgram = item && item.studyProgram
                subject = studyProgram ? `${studyProgram.name}` : '';
            }
            EvaluationEvent.sendSse(context.user, context, this.getId(), subject, err);
            return await context.model('SendStudyProgramTokenAction').silent().save(sendTokenAction);
        }
    }
}
module.exports = StudyProgramEvaluationEvent;