@universis/accommodation 1.0.0

package/src/models/AccommodationRequestAction.js

@@ -0,0 +1,195 @@
+import { DataError, HttpForbiddenError } from "@themost/common";
+import { EdmMapping, EdmType } from "@themost/data";
+import EnableAttachmentModel from './EnableAttachmentModel';
+
+class AccommodationRequestAction extends EnableAttachmentModel {
+    constructor() {
+        super();
+    }
+    /**
+     * Adds an attachment
+     * @param {*} file
+     * @param {*=} extraAttributes
+     */
+    @EdmMapping.param('extraAttributes', 'Object', true, true)
+    @EdmMapping.param('file', EdmType.EdmStream, false)
+    @EdmMapping.action('AddAttachment', 'Attachment')
+    async addAttachment(file, extraAttributes) {
+        const attachment = Object.assign({
+            name: file.contentFileName
+        }, file, extraAttributes);
+        return await super.addAttachment(attachment);
+    }
+    /**
+     * Removes an attachment
+     * @param {*} attachment
+     */
+    @EdmMapping.param('attachment', 'Attachment', true, true)
+    @EdmMapping.action('RemoveAttachment', 'Attachment')
+    async removeAttachment(attachment) {
+        return await super.removeAttachment(attachment.id);
+    }
+
+    /**
+     * Rejects an attachment
+     * @param {*} attachment
+     */
+    @EdmMapping.param('attachment', 'Attachment', true, true)
+    @EdmMapping.action('RejectAttachment', 'Attachment')
+    async rejectAttachment(attachment) {
+        return await super.rejectAttachment(attachment.id);
+    }    
+    
+    /**
+     * Reverts (re-accepts) an attachment
+     * @param {*} attachment
+     */
+     @EdmMapping.param('attachment', 'Attachment', true, true)
+     @EdmMapping.action('RevertAttachment', 'Attachment')
+     async revertAttachment(attachment) {
+         return await super.revertAttachment(attachment.id);
+     }
+
+    /**
+     * Add action messages
+     * @param {Array<any>} items
+     */
+ @EdmMapping.param('item', 'AccommodationRequestActionMessage', true, true)
+ @EdmMapping.action('messages', 'AccommodationRequestActionMessage')
+ async postMessages(item) {
+     // set initiator
+     item.action = this.getId();
+     return this.context.model('AccommodationRequestActionMessage').save(item);
+ }
+
+ /**
+  * Gets item review
+  */
+ @EdmMapping.func('review', 'AccommodationRequestActionReview')
+ getReview() {
+     return this.context.model('AccommodationRequestActionReview')
+         .where('itemReviewed').equal(this.getId()).prepare();
+ }
+
+ /**
+  * Set item review
+  * @param {*} item
+  */
+ @EdmMapping.param('item', 'AccommodationRequestActionReview', true, true)
+ @EdmMapping.action('review', 'AccommodationRequestActionReview')
+ async setReview(item) {
+     const AccommodationRequestActionReviews = this.context.model('AccommodationRequestActionReview');
+     // infer object state
+     const currentReview = await AccommodationRequestActionReviews.where('itemReviewed').equal(this.getId()).getItem();
+     if (currentReview == null) {
+         if (item == null) {
+             return;
+         }
+         // a new item is going to be inserted
+         delete item.id;
+         // set reviewed item
+         item.itemReviewed = this.getId();
+     } else {
+         if (item == null) {
+             // delete review
+             AccommodationRequestActionReviews.remove(currentReview);
+         }
+         // up
+         item.id = currentReview.id;
+         // set reviewed item
+         item.itemReviewed = this.getId();
+     }
+     return AccommodationRequestActionReviews.save(item);
+ }
+
+ /**
+  * Adds an attachment
+  * @param {{contentFileName:string}|*} attachment
+  * @param {*=} message
+  */
+ @EdmMapping.param('message', 'Object', true, true)
+ @EdmMapping.param('attachment', EdmType.EdmStream, true)
+ @EdmMapping.action('SendMessage', 'AccommodationRequestActionMessage')
+ sendMessage(attachment, message) {
+     const thisArg = this;
+     return new Promise((resolve, reject) => {
+         this.context.db.executeInTransaction((cb) => {
+                (async () => {
+                    const AccommodationRequestActionMessage = thisArg.context.model('AccommodationRequestActionMessage');
+                    if (message.recipient) {
+                        // try to find the message recipient by bypassing privileges
+                        // note: Students do not-and should not-have read access to Account or User models.
+                        // this process will help to identify an account by its name, e.g. recipient: 'AccommodationUsers'
+                        const recipient = await thisArg.context.model('Account')
+                            .where('name').equal(message.recipient.name || message.recipient)
+                            .select('id')
+                            .silent()
+                            .value()
+                        ?? await thisArg.context.model('Account')
+                            .where('id').equal(message.recipient.id || message.recipient)
+                            .select('id')
+                            .silent()
+                            .value()
+                        if (recipient == null) {
+                            throw new DataError('The specified message recipient (User/Account) cannot be found.');
+                        }
+                        // and override the message recipient
+                        message.recipient = recipient;
+                    }
+                    const newMessage = AccommodationRequestActionMessage.convert(message);
+                    Object.assign(newMessage, {
+                        action: thisArg.getId()
+                    });
+                    // add message
+                    await AccommodationRequestActionMessage.silent().save(newMessage);
+                    // if message has an attachment
+                    if (attachment) {
+                        // prepare attachment data
+                        const newAttachment = Object.assign({
+                            name: attachment.contentFileName
+                        }, attachment);
+                        // and add attachment
+                        await newMessage.addAttachment(newAttachment)
+                    }
+                })().then(() => {
+                    return cb();
+                }).catch((err) => {
+                    return cb(err);
+                });
+            }, (err) => {
+                if (err) {
+                    return reject(err);
+                }
+                return resolve(message);
+            })
+        });
+    }   
+    
+    //remove accommodation request action
+    @EdmMapping.action('Cancel', 'AccommodationRequestAction')
+    async cancel() {
+        /**
+        * @type {import('@themost/data').DataModel}
+        */
+
+        const model = this.getModel();
+
+        const item = await model.where('owner/name')
+            .equal(this.context.user.name)
+            .and('actionStatus/alternateName')
+            .equal('PotentialActionStatus')
+            .and('id')
+            .equal(this.getId())
+            .getItem();
+
+        if (item == null) {
+            throw new HttpForbiddenError();
+        }
+
+        return model.silent().remove(item); // silent() is used to bypass privileges
+    }
+}
+
+
+
+module.exports = AccommodationRequestAction;

package/src/models/AccommodationRequestEvent.js

@@ -0,0 +1,276 @@
+/* eslint-disable no-unused-vars */
+import { DataError } from "@themost/common";
+import { DataObject, EdmMapping } from "@themost/data";
+
+
+@EdmMapping.entityType('AccommodationRequestEvent')
+class AccommodationRequestEvent extends DataObject {
+    /**
+     * @constructor
+     */
+    constructor() {
+        super();
+    }
+
+    /**
+    * POST AccommodationRequestEvents/:id/Remove
+    */
+
+    //remove accommodation request event
+    @EdmMapping.param('data', 'Object', false, true)
+    @EdmMapping.action('remove', 'AccommodationRequestEvent')
+    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_REQUEST_EVENT', translateService.translate('The specified AccommodationRequestEvent cannot be found or is inaccessible.'));
+        }
+
+        const hasActions = await this.context.model('AccommodationRequestAction')
+            .where('accommodationRequestEvent').equal(item.id).count();
+
+        if (hasActions) {
+            throw new DataError('E_ACCOMMODATION_REQUESTS_EXISTS', translateService.translate('Cannot remove accommodation request event. Accommodation request event is related to requests.'), null, 'AccommodationRequestEvent');
+        }
+
+        return model.silent().remove(item);
+    }
+
+
+    /**
+    * POST AccommodationRequestEvents/:id/Extend
+    */
+
+    /**
+     * @returns {AccommodationRequestEvent}
+     */
+
+    //extend accommodation request event
+    @EdmMapping.param("data", "Object", false, true)
+    @EdmMapping.action('extend', 'AccommodationRequestEvent')
+    async extend(data) {
+
+        const model = this.getModel();
+
+        const previous = await model.where('id')
+            .equal(this.getId())
+            .getItem();
+
+        const target = data.event;
+        const translateService = this.context.application.getStrategy(function TranslateService() { });
+        if (previous == null) {
+            throw new DataError('E_ACCOMMODATION_REQUEST_EVENT', translateService.translate('The specified AccommodationRequestEvent cannot be found or is inaccessible.'));
+        }
+
+
+        if (previous.eventStatus && previous.eventStatus.alternateName !== 'EventOpened' && target.eventStatus && target.eventStatus.alternateName !== 'EventOpened') {
+            throw new DataError('E_EVENT_STATUS', translateService.translate('The AccommodationRequestEvent can only be extended when it is open.'));
+        }
+
+        if ((target.validThrough && target.validFrom)
+            && target.validThrough < target.validFrom) {
+            throw new DataError('E_DATES', translateService.translate('ValidThrough date cannot be earlier than validFrom date.'));
+        }
+
+        const today = new Date().toISOString();
+        if (previous.validThrough && previous.validThrough <= today) {
+            throw new DataError('E_DATES', translateService.translate('The AccommodationRequestEvent can only be extended if it has not already expired.'));
+        }
+
+        if (previous.eventStatus && previous.eventStatus.alternateName === 'EventOpened') {
+            
+            const validThroughChange = previous.validThrough && previous.validThrough.toISOString() !== target.validThrough.toISOString();
+            const endDateChange = previous.endDate && previous.endDate.toISOString() !== target.endDate.toISOString();
+            
+            if (validThroughChange || endDateChange) {
+                const actionItem = {
+                    object: previous.id,
+                    currentValidThrough: validThroughChange === true ? previous.validThrough : null,
+                    validThrough: validThroughChange === true ? target.validThrough : null,
+                    currentEndDate: endDateChange === true ? previous.endDate : null,
+                    endDate: endDateChange === true ? target.endDate : null,
+                    status: previous.eventStatus,
+                    description: validThroughChange === true ? (endDateChange === true ? translateService.translate('END_DATE_VALID_THROUGH_DATE') : translateService.translate('VALID_THROUGH_DATE')) : translateService.translate('END_DATE')
+                };
+                const action = await this.context.model('UpdateAccommodationRequestEventAction').save(actionItem);
+                if (action) {
+                    return await this.context.model('AccommodationRequestEvent').save(target).then(async res => {
+                        if (res) {
+                            const response = res;
+                            let sseUser;
+                            sseUser = this.context.user || await this.context.model('User');
+                            // check if there are active cards to extend
+                            const cards = await this.context.model('StudentAccommodationCards')
+                                            .where('student/studentStatus/alternateName').equal('active')
+                                            .or('student/studentStatus/alternateName').equal('declared')
+                                            .prepare()
+                                            .and('active').equal(true)
+                                            .and('action/accommodationRequestEvent/id').equal(previous.id)
+                                            .and('action/actionStatus/alternateName').equal('CompletedActionStatus')
+                                            .count();
+                            if (validThroughChange === true && cards) {
+                                Promise.all([
+                                    action,
+                                    this.handleStudentAccommodationCards(res, action)
+                                ]).then(([actionResult]) => {
+                                     this.sendSse(sseUser, this.context, actionResult, null);
+                                     return;
+                                }).catch(err => {
+                                    this.sendSse(sseUser, this.context, action, err);
+                                });
+                            } else {
+                                action.totalCards = action.totalCardsAffected = 0;
+                                action.actionResult = translateService.translate('The process was completed successfully.');
+                                action.actionStatus = { alternateName: 'CompletedActionStatus' };
+                                await this.context.model('UpdateAccommodationRequestEventAction').save(action);
+                                this.sendSse(sseUser, this.context, action, null);
+                            }
+                            return response;
+                        } else {
+                            //set action status fail
+                            action.actionResult = translateService.translate('Error occured while trying to extend AccommodationRequestEvent.')
+                            action.actionStatus = { alternateName: 'FailedActionStatus' };
+                            await this.context.model('UpdateAccommodationRequestEventAction').save(action);
+                            return false;
+                        }
+                    })
+                }
+            } else {
+                return false;
+            }
+        }
+    }
+
+    sendSse(user, context, updateEventAction, error) {
+        // try to find ServerSentEventService
+        const sse = context.getApplication().getService(function ServerSentEventService() {});
+        // only if it exists - it is not required
+        if (sse != null) {
+            if (user != null && updateEventAction != null) {
+                // create an event
+                const event = {
+                    entitySet: "UpdateAccommodationRequestEventActions",
+                    entityType: "UpdateAccommodationRequestEventAction",
+                    target: {
+                        id: updateEventAction.id,
+                        object: updateEventAction.object.id || updateEventAction.object,
+                        actionResult: updateEventAction.actionResult
+                    },
+                    status: {
+                        success: true,
+                    },
+                    dateCreated: new Date()
+                }
+                if (error) {
+                    Object.assign(event, {
+                        status: {
+                            success: false
+                        },
+                        error: {
+                            message: error.code || error.message
+                        }
+                    })
+                }
+                // and send it to the user that is performing the approval (accommodation scope)
+                sse.emit(user.name, user.authenticationScope || "accommodation", event);
+            }
+        }
+    }
+
+    /**
+     * @returns Promise<ValidationResult[]>
+     */
+    async handleStudentAccommodationCards(event, action) {
+
+        const translateService = this.context.application.getStrategy(function TranslateService() { });
+        const model = this.getModel();
+        const eventNext = await model.where('id')
+            .equal(event.id)
+            .getItem();
+
+        if (!eventNext) {
+            action.actionResult = translateService.translate('The specified AccommodationRequestEvent cannot be found or is inaccessible.')
+            action.actionStatus = { alternateName: 'FailedActionStatus' };
+            await this.context.model('UpdateAccommodationRequestEventAction').save(action);
+            throw new DataError('E_ACCOMMODATION_REQUEST_EVENT', translateService.translate('The specified AccommodationRequestEvent cannot be found or is inaccessible.'));
+        }
+
+        /**
+        * Try to update valid through date of active student accommodation cards
+        * Do not throw errors, but catch the procedure errors
+        */
+        let actionItem = action;
+        let cardResults = [];
+            const accommodationCardsToChange = await this.context.model('StudentAccommodationCards')
+                .where('student/studentStatus/alternateName').equal('active')
+                .or('student/studentStatus/alternateName').equal('declared')
+                .prepare()
+                .and('active').equal(true)
+                .and('action/accommodationRequestEvent/id').equal(eventNext.id)
+                .and('action/actionStatus/alternateName').equal('CompletedActionStatus')
+                .expand({
+                    name: 'student',
+                    options: {
+                        $expand: 'studentStatus'
+                    }
+                })
+                .getItems();
+
+            // extend all active accommodationCards
+            // let index = 0; // debugging purposes
+                for (const item of accommodationCardsToChange) {
+                try {
+                    // update only validThrough date
+                    // property student is required
+                    // check if studentStatus allows card to be updated (active and declared actionStatus)
+                    if (item && item.student && item.student.studentStatus && item.student.studentStatus.alternateName
+                        && (item.student.studentStatus.alternateName === 'active' || item.student.studentStatus.alternateName === 'declared')){
+                        const itemNext = {
+                            id: item.id, 
+                            validThrough: eventNext.validThrough, 
+                            student: item.student
+                        };
+                        await this.context.model('StudentAccommodationCards').save(itemNext);
+                    }
+                } catch (err) {
+                    // if err catch on cardResults
+                    const res = item && item.action && item.action.requestNumber
+                    cardResults.push(res)
+                }
+                // index ++; // debugging purposes
+            }
+
+            // return result
+            try {
+                actionItem.totalCards = accommodationCardsToChange.length;
+                actionItem.totalCardsAffected = accommodationCardsToChange.length - cardResults.length;
+                if (cardResults && cardResults.length === 0) {
+                    //set action status completed
+                    actionItem.actionStatus = { alternateName: 'CompletedActionStatus' };
+                    actionItem.actionResult = translateService.translate('The process was completed successfully.');
+                } else {
+                    //set action status fail
+                    actionItem.actionStatus = { alternateName: 'FailedActionStatus' };
+                    actionItem.actionResult = translateService.translate('Error occured while trying to update student accommodation cards') + '<br>' + cardResults.join("<br>");
+                }
+                const res = await this.context.model('UpdateAccommodationRequestEventActions').save(actionItem);
+
+            } catch (err) {
+                let sseUser;
+                sseUser = this.context.user || await this.context.model('User');
+                this.sendSse(sseUser, this.context, action, null);
+                throw new DataError('E_UPDATE_ACTION', 'Error occured while trying to update the UpdateAccommodationRequestEventAction.');
+            }
+    }
+}
+
+module.exports = AccommodationRequestEvent;

package/src/models/EnableAttachmentModel.js

@@ -0,0 +1,209 @@
+import {DataObject} from '@themost/data';
+import {TraceUtils, DataNotFoundError, HttpServerError, HttpBadRequestError} from "@themost/common";
+import path from 'path';
+
+class MimeTypeError extends HttpBadRequestError {
+    constructor(message) {
+        super(message);
+        this.code = "EMIME";
+    }
+}
+
+class EnableAttachmentModel extends DataObject {
+
+    constructor() {
+        super();
+    }
+
+    /**
+     * @returns {Promise<*>}
+     */
+    getRecipient() {
+       if (this.getModel().getAttribute('recipient')) {
+           return this.getModel().where('id').equal(this.id).select('recipient').silent().value();
+       }
+       return Promise.resolve();
+    }
+
+    addAttachment(file) {
+        const context = this.context;
+        const self = this;
+        let finalResult;
+        return new Promise((resolve, reject)=> {
+            this.context.db.executeInTransaction((callback)=> {
+                if (typeof file.originalname === 'string') {
+                    file.name = file.originalname.replace(/\.[A-Z0-9]+$/ig, function(x) { return x.toLowerCase(); });
+                }
+                const mime = file.mimetype || file.contentType;
+                if (mime == null) {
+                    return reject(new MimeTypeError('The specified file type is not supported by the system.'))
+                }
+                const addAttributes ={};
+                const attributeNames = context.model('Attachment').attributeNames;
+                attributeNames.forEach((attribute)=> {
+                    if (Object.prototype.hasOwnProperty.call(file, attribute)) {
+                        addAttributes[attribute] = file[attribute];
+                    }
+                });
+                const newAttachment = Object.assign(addAttributes, { contentType:mime });
+                const svc = context.getApplication().getService(function PrivateContentService() { });
+                    //add attachment to attachments
+                    context.unattended((cb)=> {
+                        // set attachment ownership to recipient
+                        EnableAttachmentModel.prototype.getRecipient.call(self).then( recipient => {
+                            if (recipient) {
+                                newAttachment.owner = recipient;
+                            }
+                            let filePath;
+                            if (file.destination && file.filename) {
+                                filePath = path.resolve(file.destination, file.filename);
+                            } else {
+                                filePath = file.path;
+                            }
+                            svc.copyFrom(context,  filePath, newAttachment, function(err) {
+                                if (err) {
+                                    TraceUtils.error(err);
+                                    return cb(new HttpServerError());
+                                }
+                                return cb();
+                            });
+                        }).catch( err=> {
+                            return cb(err);
+                        });
+
+                    }, (err)=> {
+                        if (err) {
+                            return callback(err);
+                        }
+                        const attachments = self.property('attachments');
+                        // set attachment ownership
+                        attachments.insert(newAttachment, (err)=> {
+                            if (err) {
+                                return callback(err);
+                            }
+                            svc.resolveUrl(context, newAttachment, function(err, url) {
+                                if (err) {
+                                    callback(err);
+                                }
+                                else {
+                                    finalResult =Object.assign({
+                                    }, newAttachment, {
+                                        url: url,
+                                        name: newAttachment.filename
+                                    });
+                                    callback();
+                                }
+                            });
+                        });
+                    });
+
+            }, (err)=> {
+                if (err) {
+                    return reject(err);
+                }
+                return resolve(finalResult);
+            });
+        })
+
+    }
+
+    removeAttachment(id) {
+        const context = this.context;
+        const self = this;
+        let result;
+        return new Promise((resolve, reject)=> {
+            context.db.executeInTransaction((callback)=> {
+                //get attachment
+                return context.model('Attachment').where('id').equal(id).getItem().then((attachment)=> {
+                   if (attachment) {
+                       //remove attachment connection
+                       return self.property('attachments').remove(attachment,(err)=> {
+                           //remove attachment
+                           if (err) {
+                               return callback(err);
+                           }
+                           return context.model('Attachment').silent().remove(attachment).then(()=> {
+                               result = attachment;
+                               return callback();
+                           }).catch((err)=> {
+                               return callback(err);
+                           });
+                       });
+                   }
+                   return callback(new DataNotFoundError());
+                }).catch((err)=> {
+                    return callback(err);
+                });
+            }, (err)=> {
+                if (err) {
+                    return reject(err);
+                }
+                return resolve(result);
+            });
+        });
+    }
+
+    rejectAttachment(id) {
+        const context = this.context;
+        const self = this;
+        let result;
+        return new Promise((resolve, reject)=> {
+            context.db.executeInTransaction((callback)=> {
+                //get attachment
+                return context.model('Attachment').where('id').equal(id).getItem().then((attachment)=> {
+                   if (attachment) {
+                       //reject attachment
+                       attachment.published = false;
+                        return context.model('Attachment').silent().save(attachment).then(()=> {
+                            result = attachment;
+                            return callback();
+                        }).catch((err)=> {
+                            return callback(err);
+                        });
+                   }
+                   return callback(new DataNotFoundError());
+                }).catch((err)=> {
+                    return callback(err);
+                });
+            }, (err)=> {
+                if (err) {
+                    return reject(err);
+                }
+                return resolve(result);
+            });
+        });
+    }    
+
+    revertAttachment(id) {
+        const context = this.context;
+        const self = this;
+        let result;
+        return new Promise((resolve, reject)=> {
+            context.db.executeInTransaction((callback)=> {
+                //get attachment
+                return context.model('Attachment').where('id').equal(id).getItem().then((attachment)=> {
+                   if (attachment) {
+                       //revert attachment
+                       attachment.published = true;
+                        return context.model('Attachment').silent().save(attachment).then(()=> {
+                            result = attachment;
+                            return callback();
+                        }).catch((err)=> {
+                            return callback(err);
+                        });
+                   }
+                   return callback(new DataNotFoundError());
+                }).catch((err)=> {
+                    return callback(err);
+                });
+            }, (err)=> {
+                if (err) {
+                    return reject(err);
+                }
+                return resolve(result);
+            });
+        });
+    }    
+}
+
+module.exports = EnableAttachmentModel;