@universis/accommodation 1.0.0

package/src/listeners/ValidateActionListener.js

@@ -0,0 +1,347 @@
+import {DataError} from "@themost/common";
+import { HttpForbiddenError } from '@themost/common/errors';
+import { DataObjectState, DataModel } from "@themost/data";
+// eslint-disable-next-line no-unused-vars
+async function beforeSaveAsync(event) {
+
+    let runAllRules = false;
+    const user = event.model.context.user;
+    const target = event.model.convert(event.target);
+    const context = event.model.context;
+
+    let studentId = target.student;
+    let action;
+    let eventHasConsent;
+
+    if (!Object.prototype.hasOwnProperty.call(target,'student')) {
+        const actionID = event.target || event.target.id;
+        action = await context.model('AccommodationRequestAction')
+            .where('id')
+            .equal(actionID)
+            .select('student','accommodationRequestEvent/hasConsent as hasConsent','studentConsent')
+            .getItem();
+        studentId = action.student;
+    }
+    if (!studentId) {
+        throw new DataError('E_STUDENT', 'The student cannot be empty at this context.');
+    }
+
+    const student = event.model.context.model('Student').convert(studentId);
+ 
+    const isMe = await student.is(':me');
+    if (isMe) {
+        const isActive = await student.is(':active');
+        if (!isActive) {
+            throw new HttpForbiddenError();
+        }
+
+        const accommodationRequestEvent = target.accommodationRequestEvent || target.accommodationRequestEvent.id;
+        eventHasConsent = await context.model('AccommodationRequestEvent')
+        .where('id')
+        .equal(accommodationRequestEvent)
+        .select('hasConsent')
+        .silent()
+        .value();
+    }
+
+    if (event.state === 2) {
+        if (isMe === true) {
+            //check studentConsent
+            if (event.target && eventHasConsent === true && Object.prototype.hasOwnProperty.call(target, 'studentConsent') === false) {
+                const translateService = context.application.getStrategy(function TranslateService() { });
+                throw new DataError('E_STUDENT_CONSENT', translateService.translate('The application cannot be saved without consent about personal data.'), null, 'AccommodationRequestAction', 'studentConsent');
+            } else if (event.target && eventHasConsent === true && Object.prototype.hasOwnProperty.call(target, 'studentConsent') === true && target.studentConsent === false) {
+                const translateService = context.application.getStrategy(function TranslateService() { });
+                throw new DataError('E_STUDENT_CONSENT', translateService.translate('The application cannot be saved without consent about personal data.'), null, 'AccommodationRequestAction', 'studentConsent');
+            }
+            //check category
+            if (target && (Object.prototype.hasOwnProperty.call(target, 'category') && (target.category == null))) {
+                throw new HttpForbiddenError(
+                    context.__(
+                        'The accommodation request creation failed because no request category has been set.'
+                    )
+                );
+            }
+
+        }
+
+        //UPDATE
+        //Load current status
+        const actionStatus = await event.model.where('id').equal(event.target.id).select('actionStatus/alternateName').value();
+       
+        //Action is not submitted yet. Run again all rules
+        if (actionStatus === 'PotentialActionStatus') {
+            runAllRules = true;
+        }
+        else if (actionStatus === 'ActiveActionStatus' || actionStatus === 'CompletedActionStatus'){
+            //accommodation request already submitted. Do not allow to update any property            
+            removeAllInformationExceptStatus(event.target);
+        }
+        else if (actionStatus === 'CancelledActionStatus' && event.target.actionStatus && event.target.actionStatus.alternateName !== actionStatus && event.target.actionStatus.alternateName != 'ActiveActionStatus') {
+            //accommodation request already cancelled. 
+            throw new DataError('E_VALUE', 'Cannot update cancelled action.', null, 'AccommodationRequestAction', 'actionStatus');
+        }
+        // allow agent to change request's status when target request status = 'ActiveActionStatus' example: to reconsider a cancelled request
+        else if (actionStatus === 'CancelledActionStatus' && event.target.actionStatus && event.target.actionStatus.alternateName !== actionStatus && event.target.actionStatus.alternateName === 'ActiveActionStatus') {
+            let model = event.target;
+            // set loggedIn user as request's agent
+            if (event.previous.agent != user.id) {
+             model.agent = user.id;
+            }
+         }
+    }
+
+    else  if (event.state === 1) {
+        // check studentConsent
+        if (isMe === true && eventHasConsent === true) {
+            if (Object.prototype.hasOwnProperty.call(target, 'studentConsent') === false) {
+                const translateService = context.application.getStrategy(function TranslateService() { });
+                throw new DataError('E_STUDENT_CONSENT', translateService.translate('The application cannot be saved without consent about personal data.'), null, 'AccommodationRequestAction', 'studentConsent');
+            } else if (eventHasConsent === true && target.studentConsent === false) {
+                const translateService = context.application.getStrategy(function TranslateService() { });
+                throw new DataError('E_STUDENT_CONSENT', translateService.translate('The application cannot be saved without consent about personal data.'), null, 'AccommodationRequestAction', 'studentConsent');
+            }
+        }
+
+        if (target && (Object.prototype.hasOwnProperty.call(target, 'category') === false || (target.category == null))) {
+            throw new HttpForbiddenError(
+                context.__(
+                    'The accommodation request creation failed because no request category has been set.'
+                )
+            );
+        }
+
+        runAllRules = true;
+    }
+    
+  
+
+    if (runAllRules){
+        // set nullable fields to null when they don't need to have a value
+        let model = event.target;
+    
+        if (Object.prototype.hasOwnProperty.call(model, 'militaryActive')) {
+            if (model.militaryActive == true) {
+                applyRulesForPrerequisites(model);
+                return;
+            }            
+        }
+
+        if (Object.prototype.hasOwnProperty.call(model, 'militarySchool')) {
+            if (model.militarySchool == true) {
+                applyRulesForPrerequisites(model);
+                return;
+            }            
+        }
+        
+        if (Object.prototype.hasOwnProperty.call(model, 'studentHouseResident')) {
+            if (model.studentHouseResident == true) {
+                applyRulesForPrerequisites(model);
+                return;
+            }                        
+        }
+        
+        if (Object.prototype.hasOwnProperty.call(model, 'sameDegreeHolder')) {
+            if (model.sameDegreeHolder == true) {
+                applyRulesForPrerequisites(model);
+                return;
+            }                        
+        }
+
+        if (Object.prototype.hasOwnProperty.call(model, 'foreignScholarStudent')) {
+            if (model.foreignScholarStudent == true) {
+                applyRulesForPrerequisites(model);
+                return;
+            }            
+        }
+
+
+        if (Object.prototype.hasOwnProperty.call(model, 'foreignStudentOrChildOfGreekExpatriate')) {
+            if (model.foreignStudentOrChildOfGreekExpatriate == true) {           
+                applyRulesForCyprusStudentOrForeignStudentOrChildOfGreekExpatriate(model);
+                return;
+            }        
+        }
+
+        if (Object.prototype.hasOwnProperty.call(model, 'studentReceivesUnemploymentBenefit')) {
+            if (model.studentReceivesUnemploymentBenefit == true){
+                model.institutionOrClubLocationSameAsStudentPermanentResidence = null;
+                model.studentSubmitsTaxReportInGreece = null;
+                nullifyFamilyInformation(model);
+                nullifyGuardianFinancialInformation(model);
+                nullifySpouseFinancialInformation(model);
+                nullifyStudentFinancialInformation(model);
+                return;
+            }
+        }
+
+        if (Object.prototype.hasOwnProperty.call(model, 'maritalStatus')) {
+            if (model.maritalStatus && model.maritalStatus.alternateName == 'single') {
+                model.noOfChildren = null;
+                nullifySpouseFinancialInformation(model);
+                if (model.guardianType.alternateName == 'nobody') {
+                    model.institutionOrClubLocationSameAsGuardianPermanentResidence = null;
+                    model.guardianNoOfChildren = null;
+                    model.numberOfStudyingSiblings = null;
+                    nullifyGuardianFinancialInformation(model);
+                }
+            }
+            else {
+                model.guardianType = null;
+                model.institutionOrClubLocationSameAsGuardianPermanentResidence = null;
+                model.guardianNoOfChildren = null;
+                model.numberOfStudyingSiblings = null;
+                nullifyGuardianFinancialInformation(model);
+                if (model.maritalStatus && model.maritalStatus.alternateName != 'married') {
+                    nullifySpouseFinancialInformation(model);
+                }
+            }
+        }
+    }
+    
+
+} 
+
+function applyRulesForPrerequisites(model) {
+    //nullify all other properties except foreignScholarStudent, inscriptionModeTag, lessThan25yrs and allInformationSubmittedIsTrueConfirmation
+    nullifyPersonalInformation(model);
+    nullifyFamilyInformation(model);
+    nullifyGuardianFinancialInformation(model);    
+    nullifySpouseFinancialInformation(model);
+    nullifyStudentFinancialInformation(model);    
+}
+
+function applyRulesForCyprusStudentOrForeignStudentOrChildOfGreekExpatriate(model) {
+    model.studentAfm = null;
+}
+
+function nullifyPersonalInformation(model){
+    model.foreignStudentOrChildOfGreekExpatriate = null;
+    model.studentDisabledPerson = null;
+    model.studentOrphan = null;
+    model.studentReceivesUnemploymentBenefit = null;
+    model.studentSubmitsTaxReportInGreece = null;
+    model.institutionOrClubLocationSameAsStudentPermanentResidence = null;
+}
+
+function nullifyFamilyInformation(model){
+    model.noOfChildren = null;
+    model.maritalStatus = null;
+    model.numberOfStudyingSiblings = null;
+    model.guardianNoOfChildren = null;
+    model.guardianType = null;
+    model.institutionOrClubLocationSameAsGuadianPermanentResidence = null;
+}
+
+function nullifyGuardianFinancialInformation(model){
+    model.studentGuardianTotalIncome = null;
+    model.studentGuardianAfm = null;
+    model.studentGuardianReceivesUnemploymentBenefit = null;
+    model.studentGuardianSubmitsTaxReportInGreece = null;
+}
+
+function nullifySpouseFinancialInformation(model){
+    model.studentSpouseTotalIncome = null;
+    model.studentSpouseAfm = null;
+    model.studentSpouseReceivesUnemploymentBenefit = null;
+}
+
+function nullifyStudentFinancialInformation(model){
+    model.studentTotalIncome = null;
+    model.studentAfm = null;
+}
+
+function removeAllInformationExceptStatus(model){
+    delete model.militaryActive;
+    delete model.militarySchool;
+    delete model.studentHouseResident;
+    delete model.sameDegreeHolder;
+    delete model.foreignScholarStudent;
+    delete model.lessThan25yrs;
+    delete model.institutionOrClubLocationSameAsStudentPermanentResidence;
+    delete model.studentDisabledPerson;
+    delete model.studentOrphan;
+    delete model.numberOfStudyingSiblings ;
+    delete model.maritalStatus;
+    delete model.noOfChildren;
+    delete model.guardianType;
+    delete model.institutionOrClubLocationSameAsGuadianPermanentResidence;
+    delete model.guardianNoOfChildren;
+    delete model.studentReceivesUnemploymentBenefit;
+    delete model.studentSubmitsTaxReportInGreece;
+    delete model.studentGuardianSubmitsTaxReportInGreece;
+    delete model.studentAfm;
+    delete model.studentTotalIncome;
+    delete model.studentSpouseReceivesUnemploymentBenefit;
+    delete model.studentSpouseAfm;
+    delete model.studentSpouseTotalIncome;
+    delete model.studentGuardianReceivesUnemploymentBenefit ;
+    delete model.foreignStudentOrChildOfGreekExpatriate;
+    delete model.studentGuardianAfm;
+    delete model.studentGuardianTotalIncome;
+    delete model.allInformationSubmittedIsTrueConfirmation;
+}
+
+async function afterSaveAsync(event) {
+    // on insert
+
+}
+
+async function beforeRemoveAsync(event) {
+    
+}
+
+async function afterRemoveAsync(event) {
+    const context = event.model.context;
+    // try to find if a preference exists for that 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);
+    });
+}
+
+/**
+ * @param {DataEventArgs} event
+ * @param {Function} callback
+ */
+export function afterRemove(event, callback) {
+    return afterRemoveAsync(event).then(() => {
+        return callback();
+    }).catch((err) => {
+        return callback(err);
+    });
+}
+
+
+/**
+ * @param {DataEventArgs} event
+ * @param {Function} callback
+ */
+export function beforeRemove(event, callback) {
+    return beforeRemoveAsync(event).then(() => {
+        return callback();
+    }).catch((err) => {
+        return callback(err);
+    });
+}

package/src/listeners/data-localization.js

@@ -0,0 +1,214 @@
+import {Args} from '@themost/common';
+import {ElotConverter} from '@universis/elot-converter';
+
+/**
+ * @name DataContext#locale
+ * @description Gets or sets the current context locale
+ * @type {string}
+ */
+/**
+ * Returns true if a data model has a localization enabled
+ * @param {DataModel} model
+ * @returns {DataField}
+ */
+function hasLocales(model) {
+    Args.notNull(model, 'model');
+    const attribute = model.getAttribute('locales');
+    // if target model does not have a `locales` attribute
+    if (attribute == null) {
+        return null;
+    }
+    // if attribute belongs to another model (and it's being inherited by this model)
+    if (attribute.model !== model.name) {
+        return null;
+    }
+    return attribute;
+}
+
+function getElotAttributes(context) {
+    // do not require elotAttributes configuration
+    // make it completely optional
+    return context.getConfiguration().getSourceAt('settings/i18n/elotAttributes') || ['familyName', 'givenName', 'motherName', 'fatherName'];
+}
+
+function getElotLocale() {
+    return {
+        requiresDefault: 'el',
+        isInLocale: 'en'
+    }
+}
+/**
+ * @param {DataEventArgs} event
+ * @returns {Promise<void>}
+ */
+async function afterSaveAsync(event) {
+    const context = event.model.context;
+    const attribute = hasLocales(event.model);
+    if (attribute == null) {
+        // do nothing
+        return;
+    }
+    if (Object.prototype.hasOwnProperty.call(event.target, 'locales') === false) {
+        // do nothing and exit because locales property is missing
+        return;
+    }
+    // get localized model
+    const childModel = context.model(attribute.type);
+    // throw error for invalid model
+    if (childModel == null) {
+        throw new Error('Invalid configuration. Localization model cannot be found or is not inaccessible yet');
+    }
+    if (Array.isArray(event.target.locales) === false) {
+        throw new Error('Invalid property type. Property locales must be an array');
+    }
+    for (let i = 0; i < event.target.locales.length; i++) {
+        const itemLocale = event.target.locales[i];
+        if (childModel.sealed === false) {
+            // delete primary key if any
+            delete itemLocale[childModel.primaryKey];
+        }
+        if (itemLocale.object == null) {
+            // set object key
+            Object.defineProperty(itemLocale, 'object', {
+                configurable: true,
+                enumerable: true,
+                writable: true,
+                value: event.target[event.model.primaryKey]
+            });
+        }
+    }
+    if (childModel.sealed === true) {
+        // if child model (locale model) is sealed add only other language (not default)
+        // get default application locale
+        let defaultLocale = context.getConfiguration().getSourceAt('settings/i18n/defaultLocale');
+        // throw error if default locale is not defined
+        if (defaultLocale == null) {
+            throw new Error('Invalid application configuration. The default locale is missing.');
+        }
+        event.target.locales = event.target.locales.filter((item) => {
+            return item.inLanguage !== defaultLocale;
+        });
+    }
+    // important note: get silent mode of parent model
+    const silentMode = event.model.isSilent();
+    // apply silent mode and save items
+    if (event.target.locales.length > 0) {
+        await childModel.silent(silentMode).save(event.target.locales);
+    }
+}
+/**
+ * @param {DataEventArgs} event
+ * @returns {Promise<void>}
+ */
+async function beforeSaveAsync(event) {
+    const context = event.model.context;
+    const attribute = hasLocales(event.model);
+    if (attribute == null) {
+        // do nothing
+        return;
+    }
+    // get localized model
+    const childModel = context.model(attribute.type);
+    // ensure locales property
+    event.target.locales = event.target.locales || [];
+    // get default application locale
+    let defaultLocale = context.getConfiguration().getSourceAt('settings/i18n/defaultLocale');
+    // throw error if default locale is not defined
+    if (defaultLocale == null) {
+        throw new Error('Invalid application configuration. The default locale is missing.');
+    }
+    let findLocale = event.target.locales.find((item) => {
+        return item.inLanguage === defaultLocale;
+    });
+    let add = false;
+    if (findLocale == null) {
+        add = true;
+        findLocale = {};
+    }
+    // enumerate properties and update object
+    childModel.attributes.forEach((attribute) => {
+        if (!attribute.primary && attribute.type !== event.model.name) {
+            if (Object.prototype.hasOwnProperty.call(event.target, attribute.name)) {
+                Object.defineProperty(findLocale, attribute.name, {
+                    configurable: true,
+                    enumerable: true,
+                    writable: true,
+                    value:  event.target[attribute.name]
+                });
+            }
+        }
+    });
+    // set language
+    findLocale.inLanguage = defaultLocale;
+    if (add) {
+        event.target.locales.push(findLocale);
+    }
+    if (defaultLocale === getElotLocale().requiresDefault) {
+        // try to find locale that is in language of elot locale
+        let elotLocale = event.target.locales.find(locale => locale.inLanguage === getElotLocale().isInLocale);
+        let addElotLocale = false;
+        if (!elotLocale) {
+            elotLocale = {};
+            addElotLocale = true;
+        }
+        // get elot attributes
+        const elotAttributes = getElotAttributes(context);
+        // if they are configured, validate them
+        if (!(Array.isArray(elotAttributes) && elotAttributes.length)) {
+            throw new Error('Invalid configuration. Elot attributes must be a (not-empty) array, e.g. ["familyName", "givenName"]');
+        }
+        // get previous state
+        // it can be undefined for various reasons (e.g. insert state, missing or misplaced previous-state-listener)
+        const previous = event.previous;
+        // enumerate elot attributes
+        for (const attribute of elotAttributes) {
+            // if target has the property
+            if (Object.prototype.hasOwnProperty.call(event.target, attribute)) {
+                // it's not null and has been changed
+                if (event.target[attribute] != null && event.target[attribute] != (previous && previous[attribute])) {
+                    // convert and assign to elot locale
+                    elotLocale[attribute] = ElotConverter.convert(event.target[attribute]);
+                }
+            }
+        }
+        if (addElotLocale) {
+            elotLocale.inLanguage = getElotLocale().isInLocale;
+            // and finally push the contructed locale
+            event.target.locales.push(elotLocale);
+        }
+    }
+}
+// noinspection JSUnusedGlobalSymbols
+/**
+ *
+ * @param {DataEventArgs} event
+ * @param {*} callback
+ * @returns {any}
+ */
+function beforeSave(event, callback) {
+    return beforeSaveAsync(event).then(() => {
+        return callback();
+    }).catch((err) => {
+        return callback(err);
+    });
+}
+// noinspection JSUnusedGlobalSymbols
+/**
+ *
+ * @param {DataEventArgs} event
+ * @param {*} callback
+ * @returns {any}
+ */
+function afterSave(event, callback) {
+    return afterSaveAsync(event).then(() => {
+        return callback();
+    }).catch((err) => {
+        return callback(err);
+    });
+}
+
+export {
+    hasLocales,
+    beforeSave,
+    afterSave
+}

package/src/listeners/lookup-cache-listener.js

@@ -0,0 +1,89 @@
+import {TextUtils, TraceUtils} from '@themost/common';
+import {DataCacheStrategy} from "@themost/data";
+
+/**
+ * @param {DataEventArgs} event
+ * @param {Function} callback
+ */
+export function beforeExecute(event, callback) {
+    try {
+        const context = event.model.context;
+        if (event.query) {
+            if (event.query.$select) {
+                //create hash
+                const hash = event.emitter? event.emitter.toMD5() : TextUtils.toMD5(event.query);
+                const key = '/' + event.model.name + '/?query=' + hash + '&lang=' + event.model.context.locale;
+                TraceUtils.debug('Getting data from cache [' + key + ']');
+                return context.getConfiguration().getStrategy(DataCacheStrategy).get(key).then((result) => {
+                    if (typeof result !== 'undefined') {
+                        //delete expandables
+                        if (event.emitter) {
+                            delete event.emitter.$expand;
+                        }
+                        event.cached = true;
+                        event.result = result;
+                        return callback();
+                    }
+                    else {
+                        return callback();
+                    }
+                }).catch((err)=> {
+                    return callback(err);
+                });
+            }
+        }
+        callback();
+    }
+    catch (e) {
+        callback(e)
+    }
+}
+
+export function afterExecute(event, callback) {
+    try {
+        const context = event.model.context;
+        if (event.query) {
+            if (event.query.$select) {
+                if (typeof event.result !== 'undefined' && !event.cached) {
+                    //create hash
+                    const hash = event.emitter? event.emitter.toMD5() : TextUtils.toMD5(event.query);
+                    const key = '/' + event.model.name + '/?query=' + hash + '&lang=' + event.model.context.locale;
+                    TraceUtils.debug('Setting data to cache [' + key + ']');
+                    context.getConfiguration().getStrategy(DataCacheStrategy).add(key, event.result);
+                    return callback();
+                }
+            }
+        }
+        callback();
+    }
+    catch (e) {
+        callback(e)
+    }
+}
+
+function cleanupCache(event, callback) {
+    const { name, caching, context } = event.model;
+    if (caching === 'none') {
+        return callback();
+    }
+    const service = context.getConfiguration().getStrategy(DataCacheStrategy);
+    if (service) {
+        return service.remove(`/${name}/*`).then(() => {
+            return callback();
+        }).catch((err) => {
+            TraceUtils.warn('An error occurred while cleaning up cache items');
+            TraceUtils.warn(err);
+            return callback();
+        }); 
+    }
+    return callback();
+}
+
+
+export function afterSave(event, callback) {
+    return cleanupCache(event, callback);
+}
+
+export function afterRemove(event, callback) {
+    return cleanupCache(event, callback);
+}

package/src/models/Accommodation.js

@@ -0,0 +1,52 @@
+/* eslint-disable no-unused-vars */
+import { DataError } from "@themost/common";
+import { DataObject, EdmMapping } from "@themost/data";
+
+
+@EdmMapping.entityType('Accommodation')
+class AccommodationRequestEvent extends DataObject {
+    /**
+     * @constructor
+     */
+    constructor() {
+        super();
+    }
+
+    /**
+    * POST AccommodationRequestEvents/:id/Remove
+    */
+
+    //remove accommodation request event
+    @EdmMapping.param('data', 'Object', false, true)
+    @EdmMapping.action('remove', 'Accommodation')
+    async remove(data) {
+        /**
+        * @type {import('@themost/data').DataModel}
+        */
+
+        const model = this.getModel();
+
+        const item = await model.where('id')
+            .equal(this.getId())
+            .getItem();
+        const translateService = this.context.application.getStrategy(function TranslateService() { });
+
+        if (item == null) {
+            throw new DataError('E_ACCOMMODATION', translateService.translate('The specified Accommodation cannot be found or is inaccessible.'));
+        }
+
+        const hasRooms = await this.context.model('AccommodationRooms')
+            .where('containedInPlace').equal(item.id).count();
+
+        if (hasRooms) {
+            throw new DataError('E_ACCOMMODATION_ROOM', translateService.translate('Cannot remove accommodation. Accommodation is related to rooms.'), null, 'Accommodation');
+        }
+
+        return model.silent().remove(item);
+    }
+
+
+  
+}
+
+module.exports = AccommodationRequestEvent;