@universis/accommodation 1.0.0

package/src/listeners/OnActionCompleteListener.js

@@ -0,0 +1,95 @@
+// eslint-disable-next-line no-unused-vars
+async function beforeSaveAsync(event) {
+    const context = event.model.context;
+}
+
+async function afterSaveAsync(event) {
+    // get context
+    // eslint-disable-next-line no-unused-vars
+    const context = event.model.context;
+    // get current status
+    const request = await event.model.where('id').equal(event.target.id)
+        .expand({
+            name: 'accommodationRequestEvent',
+            options: {
+                $expand: 'academicYear,academicPeriod',
+            }
+        }).getItem();
+    const actionStatus = request && request.actionStatus && request.actionStatus.alternateName ? request.actionStatus.alternateName : null;
+    if ((actionStatus || actionStatus.alternateName) === 'CompletedActionStatus') {
+        // set student accommodation card
+        const now = new Date();
+
+        //        const now = new Date();        
+        let academicYear = request && request.accommodationRequestEvent && request.accommodationRequestEvent.academicYear ? request.accommodationRequestEvent.academicYear : null;
+        let academicPeriod = request && request.accommodationRequestEvent && request.accommodationRequestEvent.academicPeriod ? request.accommodationRequestEvent.academicPeriod : null;
+        let validThrough = request && request.accommodationRequestEvent && request.accommodationRequestEvent.validThrough ? request.accommodationRequestEvent.validThrough : null;
+        // get original student
+        const student = await context.model('Student').where('id').equal(request.student.id || request.student)
+            .expand({
+                name: 'department',
+                options: {
+                    $expand: 'currentYear,currentPeriod',
+                }
+            }).getItem();
+        if (student == null) {
+            throw new Error(`Student with id ${request.student.id || request.student} not found.`);
+        }
+
+        if (academicYear == null) {
+            // get student current academic year
+
+            academicYear = student && student.department && student.department.currentYear ? student.department.currentYear : null;
+            // await event.model.where('id').equal(event.target.id).select('student/department/currentYear').value();
+        }
+        if (academicPeriod == null) {
+            // get student current academic period
+            academicPeriod = student && student.department && student.department.currentPeriod ? student.department.currentPeriod : null;
+        }
+        let cardActionStatus = {};
+        if (event.target.accommodation && (Object.keys(event.target.accommodation).length === 0 || event.target.accommodation === '')) {
+            // get accommodation valid through date
+            cardActionStatus = { alternateName: 'PotentialActionStatus' }
+
+        } else {
+            cardActionStatus = { alternateName: 'CompletedActionStatus' }
+        }
+
+        const StudentAccommodationCard = {
+            action: event.target.id,
+            student: student,
+            academicYear: academicYear,
+            academicPeriod: academicPeriod,
+            validFrom: now,
+            validThrough: validThrough,
+            cardStatus: cardActionStatus,
+            accommodationRoom: event.target.room || null
+        };
+        // save student accommodation card    
+        await context.model('StudentAccommodationCard').silent().save(StudentAccommodationCard);
+    }
+}
+
+/**
+ * @param {DataEventArgs} event
+ * @param {Function} callback
+ */
+export function beforeSave(event, callback) {
+    return beforeSaveAsync(event).then(() => {
+        return callback();
+    }).catch((err) => {
+        return callback(err);
+    });
+}
+
+/**
+ * @param {DataEventArgs} event
+ * @param {Function} callback
+ */
+export function afterSave(event, callback) {
+    return afterSaveAsync(event).then(() => {
+        return callback();
+    }).catch((err) => {
+        return callback(err);
+    });
+}

package/src/listeners/OnCancelAccommodationCardListener.js

@@ -0,0 +1,86 @@
+import { DataPermissionEventListener, PermissionMask } from "@themost/data";
+import { DataError } from '@themost/common';
+import { promisify } from "util";
+
+async function beforeSaveAsync(event) {
+    //
+    if (event.state !== 2) {
+        return;
+    }
+
+    const context = event.model.context;
+
+    const previous = event.previous;
+    if (previous == null) {
+        throw new DataError('E_PREVIOUS', 'The previous state of the object cannot be determined');
+    }
+
+    const target = event.target;
+
+    if (target.active === false && previous.active === true) {
+        // get validator listener
+        const validator = new DataPermissionEventListener();
+        // noinspection JSUnresolvedFunction
+        const validateAsync = promisify(validator.validate)
+            .bind(validator);
+        // validate StudentAccommodationCard/Cancel execute permission
+        const validateEvent = {
+            model: context.model('StudentAccommodationCard'),
+            privilege: 'StudentAccommodationCard/Cancel',
+            mask: PermissionMask.Execute,
+            target: event.target && event.target.id,
+            throwError: true
+        }
+        await validateAsync(validateEvent);
+
+    }
+}
+
+async function afterSaveAsync(event) {
+    if (event.state !== 2) {
+        return;
+    }
+
+    const context = event.model.context;
+
+    const previous = event.previous;
+    if (previous == null) {
+        throw new DataError('E_PREVIOUS', 'The previous state of the object cannot be determined');
+    }
+
+    const target = event.target;
+
+    if (target.active === false && previous.active === true) {
+        //save 
+        await context.model('CancelAccommodationCardAction').save({
+            accommodationCard: target.id,
+            actionStatus: {
+                alternateName: 'CompletedActionStatus'
+            }
+        })
+    }
+}
+
+/**
+ * @param {DataEventArgs} event
+ * @param {Function} callback
+ */
+export function beforeSave(event, callback) {
+    return beforeSaveAsync(event).then(() => {
+        return callback();
+    }).catch((err) => {
+        return callback(err);
+    });
+}
+
+/**
+ * @param {DataEventArgs} event
+ * @param {Function} callback
+ */
+export function afterSave(event, callback) {
+    return afterSaveAsync(event).then(() => {
+        return callback();
+    }).catch((err) => {
+        return callback(err);
+    });
+}

package/src/listeners/OnReactivateAccommodationCardListener.js

@@ -0,0 +1,86 @@
+import { DataPermissionEventListener, PermissionMask } from "@themost/data";
+import { DataError } from '@themost/common';
+import { promisify } from "util";
+
+async function beforeSaveAsync(event) {
+    //
+    if (event.state !== 2) {
+        return;
+    }
+
+    const context = event.model.context;
+
+    const previous = event.previous;
+    if (previous == null) {
+        throw new DataError('E_PREVIOUS', 'The previous state of the object cannot be determined');
+    }
+
+    const target = event.target;
+
+    if (target.active === false && previous.active === true) {
+        // get validator listener
+        const validator = new DataPermissionEventListener();
+        // noinspection JSUnresolvedFunction
+        const validateAsync = promisify(validator.validate)
+            .bind(validator);
+        // validate StudentAccommodationCard/Cancel execute permission
+        const validateEvent = {
+            model: context.model('StudentAccommodationCard'),
+            privilege: 'StudentAccommodationCard/Cancel',
+            mask: PermissionMask.Execute,
+            target: event.target && event.target.id,
+            throwError: true
+        }
+        await validateAsync(validateEvent);
+
+    }
+}
+
+async function afterSaveAsync(event) {
+    if (event.state !== 2) {
+        return;
+    }
+
+    const context = event.model.context;
+
+    const previous = event.previous;
+    if (previous == null) {
+        throw new DataError('E_PREVIOUS', 'The previous state of the object cannot be determined');
+    }
+
+    const target = event.target;
+
+    if (target.active === false && previous.active === true) {
+        //save 
+        await context.model('CancelAccommodationCardAction').save({
+            accommodationCard: target.id,
+            actionStatus: {
+                alternateName: 'CompletedActionStatus'
+            }
+        })
+    }
+}
+
+/**
+ * @param {DataEventArgs} event
+ * @param {Function} callback
+ */
+export function beforeSave(event, callback) {
+    return beforeSaveAsync(event).then(() => {
+        return callback();
+    }).catch((err) => {
+        return callback(err);
+    });
+}
+
+/**
+ * @param {DataEventArgs} event
+ * @param {Function} callback
+ */
+export function afterSave(event, callback) {
+    return afterSaveAsync(event).then(() => {
+        return callback();
+    }).catch((err) => {
+        return callback(err);
+    });
+}

package/src/listeners/SendEmailAfterActionStatusChangeListener.js

@@ -0,0 +1,97 @@
+import { getMailer } from '@themost/mailer';
+import { DataError } from '@themost/data';
+import { TraceUtils } from "@themost/common";
+/**
+ * @param {DataEventArgs} event
+ */
+async function afterSaveAsync(event) {
+    if (event.state === 2) {
+        const context = event.model.context;
+        /**
+         * @type {import('@themost/mailer').MailerHelper}
+         */
+        const mailer = getMailer(context);
+
+        const actionStatus = await context.model('AccommodationRequestAction')
+            .where('id').equal(event.target.id).select('actionStatus/alternateName').value();
+        let previousStatus = 'UnknownActionStatus';
+        if (event.previous) {
+            previousStatus = event.previous.actionStatus.alternateName;
+        } else {
+            throw new DataError('E_STATE', 'The previous state of an object cannot be determined', null, 'AccommodationRequestAction');
+        }
+        if (actionStatus === previousStatus) {
+            return;
+        }
+        // get mail template
+        const mailTemplate = await context.model('MailConfiguration').where('target').equal('AccommodationRequestActionStatusChange').silent().getItem();
+        if (mailTemplate == null) {
+            //
+            return;
+        }
+        // get parent action data
+        const item = await context.model('AccommodationRequestAction')
+            .where('id').equal(event.target.id)
+            .expand({
+                name: 'student',
+                options: {
+                    $expand: 'person'
+                }
+            }, 'owner')
+            .silent().getItem();
+
+        const application = await context.model('WebApplication')
+                .where('alternateName').equal('students')
+                .and('applicationSuite').equal('universis')
+                .silent().getItem();
+         const config = await context.model('StudentRequestConfiguration')
+             .where('additionalType').equal(event.model.name)
+             .and('inLanguage').equal(event.target.inLanguage || context.locale)
+             .silent().getItem();
+
+        if (item && application && config) {
+            
+            const email = item.student.person.email;
+            
+            if (email == null || typeof email !== 'string') {
+                TraceUtils.warn(`Cannot send email for ${item.student.person.familyName} ${item.student.person.givenName}. Student [${item.student.id}] email does not exist.`);
+                return;
+            }
+            await new Promise((resolve) => {
+                mailer.template(mailTemplate.template)
+                    .subject(mailTemplate.subject)
+                    .bcc(mailTemplate.bcc || '')
+                    .to(email)
+                    .send({
+                        model: item,
+                        application: application,
+                        configuration: config
+                    }, (err) => {
+                        if (err) {
+                            try {
+                                TraceUtils.error('An error occurred while trying to send an email notification after status change.');
+                                TraceUtils.error(`Student=${item.student.id}, template=${mailTemplate.template}`);
+                                TraceUtils.error(err);
+                            } catch (err1) {
+                                // do nothing
+                            }
+                            return resolve();
+                        }
+                        return resolve();
+                    })
+            });
+
+        }
+    }
+}
+/**
+ * @param {DataEventArgs} event
+ * @param {Function} callback
+ */
+export function afterSave(event, callback) {
+    return afterSaveAsync(event).then(() => {
+        return callback();
+    }).catch((err) => {
+        return callback(err);
+    });
+}

package/src/listeners/SendEmailAfterCardStatusChangeListener.js

@@ -0,0 +1,138 @@
+import { getMailer } from '@themost/mailer';
+import { DataError } from '@themost/data';
+import { TraceUtils } from "@themost/common";
+/**
+ * @param {DataEventArgs} event
+ */
+async function afterSaveAsync(event) {
+    if (event.state === 2) {
+        const context = event.model.context;
+        /**
+         * @type {import('@themost/mailer').MailerHelper}
+         */
+        const mailer = getMailer(context);
+
+        const currentCardStatus = await context
+            .model('StudentDiningCard')
+            .where('id')
+            .equal(event.target.id)
+            .select('active')
+            .value();
+        let previousCardStatus = 'UnknownStatus';
+        if (event.previous) {
+            previousCardStatus = event.previous.active;
+        } else {
+            throw new DataError('E_STATE', 'The previous state of an object cannot be determined', null, 'StudentDiningCard');
+        }
+        if (currentCardStatus === previousCardStatus) {
+            return;
+        }
+
+        // get mail template
+        const mailTemplate = await context
+            .model('MailConfigurations')
+            .where('target')
+            .equal('DiningCardActiveStatusChange')
+            .silent()
+            .getItem();
+        if (mailTemplate == null) {
+            //
+            return;
+        }
+
+        //get parent action data
+        let item;
+        if (typeof event.target.action === 'object' && typeof event.target.action.id === 'number' && Number.isInteger(event.target.action.id) && event.target.action.id > 0) {
+            item = await context
+                .model('DiningRequestAction')
+                .where('id')
+                .equal(event.target.action.id)
+                .expand({
+                    name: 'student',
+                    options: {
+                        $expand: 'person'
+                    }
+                })
+                .silent()
+                .getItem();
+
+        } else if (typeof event.target.action === 'number' && Number.isInteger(event.target.action) && event.target.action > 0) {
+            item = await context
+                .model('DiningRequestAction')
+                .where('id')
+                .equal(event.target.action)
+                .expand({
+                    name: 'student',
+                    options: {
+                        $expand: 'person'
+                    }
+                })
+                .silent()
+                .getItem();
+        }
+
+        const application = await context
+            .model('WebApplication')
+            .where('alternateName')
+            .equal('students')
+            .and('applicationSuite')
+            .equal('universis')
+            .silent()
+            .getItem();
+
+        const config = await context
+            .model('StudentRequestConfiguration')
+            .where('additionalType')
+            .equal('DiningRequestAction')
+            .and('inLanguage')
+            .equal(event.target.inLanguage || context.locale)
+            .silent()
+            .getItem();
+
+        if (item && application && config) {
+
+            const email = item.student.person.email;
+
+            if (email == null || typeof email !== 'string') {
+                TraceUtils.warn(`Cannot send email for ${item.student.person.familyName} ${item.student.person.givenName}. Student [${item.student.id}] email does not exist.`);
+                return;
+            }
+            await new Promise((resolve) => {
+                mailer.template(mailTemplate.template)
+                    .subject(mailTemplate.subject)
+                    .bcc(mailTemplate.bcc || '')
+                    .to(email)
+                    .send({
+                        model: item,
+                        application: application,
+                        configuration: config
+                    }, (err) => {
+                        if (err) {
+                            try {
+                                TraceUtils.error('An error occurred while trying to send an email notification after status change.');
+                                TraceUtils.error(`Student=${item.student.id}, template=${mailTemplate.template}`);
+                                TraceUtils.error(err);
+                            } catch (err1) {
+                                // do nothing
+                            }
+                            return resolve();
+                        }
+
+                        return resolve();
+                    })
+            });
+
+        }
+    }
+}
+/**
+ * @param {DataEventArgs} event
+ * @param {Function} callback
+ */
+export function afterSave(event, callback) {
+    return afterSaveAsync(event).then(() => {
+        return callback();
+    }).catch((err) => {
+        return callback(err);
+    });
+}

package/src/listeners/StudentAccommodationCardSaveListener.js

@@ -0,0 +1,89 @@
+/**
+ * @param {DataEventArgs} event
+ * @param {Function} callback
+ */
+import {DataError} from "@themost/common";
+
+export function beforeSave(event, callback) {
+    (async () => {
+
+        // validate student state (on insert or update)
+        if (event.state === 1 || event.state === 2) {
+            let context = event.model.context;
+            /**
+             * @type {Student|DataObject|*}
+             */
+            const student = context.model('Student').convert(event.target.student);
+            // const isActive = await student.silent().isActive();
+            const isActive = await student.is(':active');
+            if (!isActive) {
+                throw new DataError('ERR_STATUS',
+                    'Invalid student status. Student Accommodation Card may be published upon an active student only.'+student
+                    , null,
+                    'Student', 'studentStatus');
+            }
+            
+            const studentObject = await context.model('Student').where('id').equal(student.id).silent().flatten().getItem();
+            
+            const academicYear = context.model('AcademicYear').convert(event.target.academicYear).getId();
+            if (Number.isInteger(academicYear) === false) {
+                throw new DataError('E_VALUE', 'Invalid academic year. Expected number.', null, 'AcademicYear', 'id');
+            }
+
+            const academicYearObject =  await context.model('AcademicYear').where('id').equal(academicYear).getItem();
+            if (academicYearObject === undefined){
+                throw new DataError('E_VALUE', 'Invalid academic year.', null, 'AcademicYear', 'id');
+            }
+
+            if (event.target.academicPeriod != null){
+
+                const academicPeriod = context.model('AcademicPeriod').convert(event.target.academicPeriod).getId();
+                if (Number.isInteger(academicPeriod) === false) {
+                    throw new DataError('E_VALUE', 'Invalid academic period. Expected number.', null, 'AcademicPeriod', 'id');
+                }
+    
+                const academicPeriodObject =  await context.model('AcademicPeriod').where('id').equal(academicPeriod).getItem();
+                if (academicPeriodObject === undefined){
+                    throw new DataError('E_VALUE', 'Invalid academic period.', null, 'AcademicPeriod', 'id');
+                }
+                
+            }
+        }
+    })().then( () => {
+       return callback();
+    }).catch( err => {
+        return callback(err);
+    });
+}
+
+
+/**
+ * @param {DataEventArgs} event
+ * @param {Function} callback
+ */
+export function afterSave(event, callback) {
+    (async () => {
+        //
+        let context = event.model.context;
+        if (event.state === 1) {
+            if (event.target.accommodationRoom && Object.keys(event.target.accommodationRoom).length != 0) {
+                // get accommodation valid through date
+
+                const room = await context.model('AccommodationRoom').where('id').equal(event.target.accommodationRoom.id).getItem();
+                if (room === undefined) {
+                    throw new DataError('E_VALUE', 'Invalid accommodation room.', null, 'AccommodationRoom', 'id');
+                }
+                let newRoom = room;
+                newRoom.currentOccupancy = room.currentOccupancy+1;
+                //todo if i can increase occupancy
+                await context.model('AccommodationRoom').silent().save(newRoom);
+            }
+        }
+
+
+    })().then(() => {
+        return callback();
+    }).catch(err => {
+        return callback(err);
+    });
+}

package/src/listeners/UpdateStudentAccommodationCardListener.js

@@ -0,0 +1,69 @@
+import { DataError } from '@themost/common';
+
+async function afterSaveAsync(event) {
+    //
+    if (event.state !== 2) {
+        return;
+    }
+
+    const context = event.model.context;
+
+    const previous = event.previous;
+    if (previous == null) {
+        throw new DataError('E_PREVIOUS', 'The previous state of the object cannot be determined');
+    }
+
+
+    const previousStudentStatus = event.previous.studentStatus;
+    if (previousStudentStatus.alternateName === 'active' && event.target.studentStatus && event.target.studentStatus.alternateName != 'active') {
+        
+         // find StudentAccommodationCard 
+        const StudentAccommodationCard = await context.model('StudentAccommodationCards').where('student/id').equal(event.target.id).select('id', 'active', 'action', 'student', 'academicPeriod', 'academicYear')
+        .flatten().silent().getItem();
+
+        if (StudentAccommodationCard == null) {
+            return;
+        }
+
+        if (StudentAccommodationCard.active === false) {
+            return;
+        }
+
+        if (StudentAccommodationCard.active === true) {
+
+            StudentAccommodationCard.active = false
+            //save StudentAccommodationCard
+            await context.model('StudentAccommodationCard').save(StudentAccommodationCard);
+        }
+    }
+
+}
+
+// eslint-disable-next-line no-unused-vars
+async function beforeSaveAsync(event) {
+//
+}
+
+/**
+ * @param {DataEventArgs} event
+ * @param {Function} callback
+ */
+export function beforeSave(event, callback) {
+    return beforeSaveAsync(event).then(() => {
+        return callback();
+    }).catch((err) => {
+        return callback(err);
+    });
+}
+
+/**
+ * @param {DataEventArgs} event
+ * @param {Function} callback
+ */
+export function afterSave(event, callback) {
+    return afterSaveAsync(event).then(() => {
+        return callback();
+    }).catch((err) => {
+        return callback(err);
+    });
+}