Merge branch '2015-chat_sendCheckingPresence' of verdnatura/salix into dev

back/methods/chat/send.js

@@ -0,0 +1,96 @@
+const request = require('request-promise-native');
+module.exports = Self => {
+    Self.remoteMethodCtx('send', {
+        description: 'Send a RocketChat message',
+        accessType: 'WRITE',
+        accepts: [{
+            arg: 'to',
+            type: 'String',
+            required: true,
+            description: 'user (@) or channel (#) to send the message'
+        }, {
+            arg: 'message',
+            type: 'String',
+            required: true,
+            description: 'The message'
+        }],
+        returns: {
+            type: 'Object',
+            root: true
+        },
+        http: {
+            path: `/send`,
+            verb: 'POST'
+        }
+    });
+
+    Self.send = async(ctx, to, message) => {
+        const models = Self.app.models;
+        const accessToken = ctx.req.accessToken;
+        const sender = await models.Account.findById(accessToken.userId);
+        const recipient = to.replace('@', '');
+
+        if (sender.name != recipient)
+            return sendMessage(to, `@${sender.name}: ${message}`);
+    };
+
+    async function sendMessage(name, message) {
+        const models = Self.app.models;
+        const chatConfig = await models.ChatConfig.findOne();
+
+        if (!Self.token)
+            Self.token = await login();
+
+        const uri = `${chatConfig.uri}/chat.postMessage`;
+        return makeRequest(uri, {
+            'channel': name,
+            'text': message
+        }).catch(async error => {
+            if (error.statusCode === 401 && !Self.loginAttempted) {
+                Self.token = await login();
+                Self.loginAttempted = true;
+
+                return sendMessage(name, message);
+            }
+
+            throw new Error(error.message);
+        });
+    }
+
+    /**
+     * Returns a rocketchat token
+     * @return {Object} userId and authToken
+     */
+    async function login() {
+        const models = Self.app.models;
+        const chatConfig = await models.ChatConfig.findOne();
+        const uri = `${chatConfig.uri}/login`;
+        return makeRequest(uri, {
+            user: chatConfig.user,
+            password: chatConfig.password
+        }).then(res => res.data);
+    }
+
+    function makeRequest(uri, body) {
+        if (process.env.NODE_ENV !== 'production') {
+            return new Promise(resolve => {
+                return resolve({statusCode: 200, message: 'Fake notification sent'});
+            });
+        }
+
+        const options = {
+            method: 'POST',
+            uri: uri,
+            body: body,
+            headers: {'content-type': 'application/json'},
+            json: true
+        };
+
+        if (Self.token) {
+            options.headers['X-Auth-Token'] = Self.token.authToken;
+            options.headers['X-User-Id'] = Self.token.userId;
+        }
+
+        return request(options);
+    }
+};

back/methods/chat/sendCheckingPresence.js

@@ -0,0 +1,53 @@
+module.exports = Self => {
+    Self.remoteMethodCtx('sendCheckingPresence', {
+        description: 'Sends a RocketChat message to a working worker or department channel',
+        accessType: 'WRITE',
+        accepts: [{
+            arg: 'workerId',
+            type: 'Number',
+            required: true,
+            description: 'The worker id of the destinatary'
+        }, {
+            arg: 'message',
+            type: 'String',
+            required: true,
+            description: 'The message'
+        }],
+        returns: {
+            type: 'Object',
+            root: true
+        },
+        http: {
+            path: `/sendCheckingPresence`,
+            verb: 'POST'
+        }
+    });
+
+    Self.sendCheckingPresence = async(ctx, workerId, message) => {
+        const models = Self.app.models;
+        const account = await models.Account.findById(workerId);
+
+        const query = `SELECT worker_isWorking(?) isWorking`;
+        const [result] = await Self.rawSql(query, [workerId]);
+
+        let room;
+        if (result.isWorking)
+            room = `@${account.name}`;
+        else {
+            const workerDepartment = await models.WorkerDepartment.findById(workerId, {
+                include: {
+                    relation: 'department'
+                }
+            });
+            const department = workerDepartment.department();
+            const channelName = department.chatName;
+            room = `#${channelName}`;
+
+            if (channelName)
+                room = `#${channelName}`;
+            else room = `@${account.name}`;
+        }
+
+        return Self.send(ctx, room, message);
+    };
+};

back/methods/chat/sendMessage.js

@@ -1,138 +0,0 @@
-const request = require('request-promise-native');
-module.exports = Self => {
-    Self.remoteMethodCtx('sendMessage', {
-        description: 'Send a RocketChat message',
-        accessType: 'WRITE',
-        accepts: [{
-            arg: 'to',
-            type: 'String',
-            required: true,
-            description: 'user (@) or channel (#) to send the message'
-        }, {
-            arg: 'message',
-            type: 'String',
-            required: true,
-            description: 'The message'
-        }],
-        returns: {
-            type: 'Object',
-            root: true
-        },
-        http: {
-            path: `/sendMessage`,
-            verb: 'POST'
-        }
-    });
-
-    Self.sendMessage = async(ctx, to, message) => {
-        const models = Self.app.models;
-        const accessToken = ctx.req.accessToken;
-        const sender = await models.Account.findById(accessToken.userId);
-        const recipient = to.replace('@', '');
-
-        if (sender.name != recipient)
-            return sendMessage(sender, to, `@${sender.name}: ${message} `);
-    };
-
-    async function sendMessage(sender, channel, message) {
-        const config = await getConfig();
-
-        const avatar = `${config.host}/avatar/${sender.name}`;
-        const uri = `${config.api}/chat.postMessage`;
-        return sendAuth(uri, {
-            'channel': channel,
-            'avatar': avatar,
-            'text': message
-        }).catch(async error => {
-            if (error.statusCode === 401 && !this.resendAttempted) {
-                this.resendAttempted = true;
-
-                return sendMessage(sender, channel, message);
-            }
-
-            throw new Error(error.message);
-        });
-    }
-
-    /**
-     * Returns a rocketchat token
-     * @return {Object} userId and authToken
-     */
-    async function getAuthToken() {
-        if (!this.auth || this.auth && !this.auth.authToken) {
-            const config = await getConfig();
-            const uri = `${config.api}/login`;
-            const res = await send(uri, {
-                user: config.user,
-                password: config.password
-            });
-
-            this.auth = res.data;
-        }
-
-        return this.auth;
-    }
-
-    /**
-     * Returns a rocketchat config
-     * @return {Object} Auth config
-     */
-    async function getConfig() {
-        if (!this.chatConfig) {
-            const models = Self.app.models;
-
-            this.chatConfig = await models.ChatConfig.findOne();
-        }
-
-        return this.chatConfig;
-    }
-
-    /**
-     * Send unauthenticated request
-     * @param {*} uri - Request uri
-     * @param {*} body - Request params
-     * @param {*} options - Request options
-     *
-     * @return {Object} Request response
-     */
-    async function send(uri, body, options) {
-        if (process.env.NODE_ENV !== 'production') {
-            return new Promise(resolve => {
-                return resolve({statusCode: 200, message: 'Fake notification sent'});
-            });
-        }
-
-        const defaultOptions = {
-            method: 'POST',
-            uri: uri,
-            body: body,
-            headers: {'content-type': 'application/json'},
-            json: true
-        };
-
-        if (options) Object.assign(defaultOptions, options);
-
-        return request(defaultOptions);
-    }
-
-    /**
-     * Send authenticated request
-     * @param {*} uri - Request uri
-     * @param {*} body - Request params
-     *
-     * @return {Object} Request response
-     */
-    async function sendAuth(uri, body) {
-        const login = await getAuthToken();
-        const options = {
-            headers: {'content-type': 'application/json'}
-        };
-
-        if (login) {
-            options.headers['X-Auth-Token'] = login.authToken;
-            options.headers['X-User-Id'] = login.userId;
-        }
-
-        return send(uri, body, options);
-    }
-};

back/methods/chat/spec/send.spec.js

@@ -1,9 +1,9 @@
 const app = require('vn-loopback/server/server');
 
-describe('chat sendMessage()', () => {
+describe('chat send()', () => {
     it('should return a "Fake notification sent" as response', async() => {
         let ctx = {req: {accessToken: {userId: 1}}};
-        let response = await app.models.Chat.sendMessage(ctx, '@salesPerson', 'I changed something');
+        let response = await app.models.Chat.send(ctx, '@salesPerson', 'I changed something');
 
         expect(response.statusCode).toEqual(200);
         expect(response.message).toEqual('Fake notification sent');
@@ -11,7 +11,7 @@ describe('chat sendMessage()', () => {
 
     it('should not return a response', async() => {
         let ctx = {req: {accessToken: {userId: 18}}};
-        let response = await app.models.Chat.sendMessage(ctx, '@salesPerson', 'I changed something');
+        let response = await app.models.Chat.send(ctx, '@salesPerson', 'I changed something');
 
         expect(response).toBeUndefined();
     });

back/methods/chat/spec/sendCheckingPresence.spec.js

@@ -0,0 +1,65 @@
+const app = require('vn-loopback/server/server');
+
+describe('chat sendCheckingPresence()', () => {
+    const departmentId = 23;
+    const workerId = 107;
+    let timeEntry;
+
+    afterAll(async done => {
+        const department = await app.models.Department.findById(departmentId);
+        await department.updateAttribute('chatName', null);
+        await app.models.WorkerTimeControl.destroyById(timeEntry.id);
+        done();
+    });
+
+    it(`should call to send() method with the worker username when no department channel is specified
+        and then return a "Fake notification sent" as response`, async() => {
+        const ctx = {req: {accessToken: {userId: 1}}};
+        const chatModel = app.models.Chat;
+        spyOn(chatModel, 'send').and.callThrough();
+
+        const response = await chatModel.sendCheckingPresence(ctx, workerId, 'I changed something');
+
+        expect(response.statusCode).toEqual(200);
+        expect(response.message).toEqual('Fake notification sent');
+        expect(chatModel.send).toHaveBeenCalledWith(ctx, '@HankPym', 'I changed something');
+    });
+
+    it(`should call to send() method with the worker department channel if is specified
+        and then return a "Fake notification sent" as response`, async() => {
+        const ctx = {req: {accessToken: {userId: 1}}};
+        const chatModel = app.models.Chat;
+        spyOn(chatModel, 'send').and.callThrough();
+
+        const department = await app.models.Department.findById(departmentId);
+        await department.updateAttribute('chatName', 'cooler');
+
+        const response = await chatModel.sendCheckingPresence(ctx, workerId, 'I changed something');
+
+        expect(response.statusCode).toEqual(200);
+        expect(response.message).toEqual('Fake notification sent');
+        expect(chatModel.send).toHaveBeenCalledWith(ctx, '#cooler', 'I changed something');
+    });
+
+    it(`should call to send() method with the worker username when the worker is working`, async() => {
+        const ctx = {req: {accessToken: {userId: 1}}};
+        const chatModel = app.models.Chat;
+        spyOn(chatModel, 'send').and.callThrough();
+
+        const today = new Date();
+        today.setHours(6, 0);
+
+        timeEntry = await app.models.WorkerTimeControl.create({
+            userFk: workerId,
+            timed: today,
+            manual: false,
+            direction: 'in'
+        });
+
+        const response = await chatModel.sendCheckingPresence(ctx, workerId, 'I changed something');
+
+        expect(response.statusCode).toEqual(200);
+        expect(response.message).toEqual('Fake notification sent');
+        expect(chatModel.send).toHaveBeenCalledWith(ctx, '@HankPym', 'I changed something');
+    });
+});

back/models/chat.js

@@ -1,3 +1,4 @@
 module.exports = Self => {
-    require('../methods/chat/sendMessage')(Self);
+    require('../methods/chat/send')(Self);
+    require('../methods/chat/sendCheckingPresence')(Self);
 };

db/changes/10140-kings/00-department.sql

@@ -0,0 +1,2 @@
+ALTER TABLE `vn`.`department` 
+ADD COLUMN `chatName` VARCHAR(45) NULL AFTER `path`;

db/changes/10140-kings/00-worker_isWorking.sql

@@ -0,0 +1,32 @@
+USE `vn`;
+DROP function IF EXISTS `worker_isWorking`;
+
+DELIMITER $$
+USE `vn`$$
+CREATE DEFINER=`root`@`%` FUNCTION `worker_isWorking`(vWorkerFk INT) RETURNS tinyint(1)
+    READS SQL DATA
+BEGIN
+/**
+ * Comprueba si el trabajador está trabajando en el momento de la consulta
+ * @return Devuelve TRUE en caso de que este trabajando. Si se encuentra en un descanso devolverá FALSE
+ */
+	DECLARE vLastIn DATETIME ;
+	
+	SELECT MAX(timed) INTO vLastIn
+		FROM vn.workerTimeControl 
+		WHERE userFk = vWorkerFk AND
+		      direction = 'in';
+
+	IF (SELECT MOD(COUNT(*),2) 						
+			FROM vn.workerTimeControl 
+			WHERE userFk = vWorkerFk AND 
+                  timed >= vLastIn
+	   ) THEN	
+		RETURN TRUE;
+	ELSE
+		RETURN FALSE;
+	END IF;
+END$$
+
+DELIMITER ;
+

loopback/common/models/vn-model.js

@@ -155,10 +155,10 @@ module.exports = function(Self) {
                         const result = await realMethod.call(this, data, options);
 
                         if (cb) cb(null, result);
+                        else return result;
                     } catch (err) {
                         let myErr = replaceErr(err, replaceErrFunc);
-                        if (cb)
-                            cb(myErr);
+                        if (cb) cb(myErr);
                         else
                             throw myErr;
                     }

modules/ticket/back/methods/ticket/setDeleted.js

@@ -94,7 +94,7 @@ module.exports = Self => {
                 id: id,
                 url: `${origin}/#!/ticket/${id}/summary`
             });
-            await models.Chat.sendMessage(ctx, `@${salesPersonUser}`, message);
+            await models.Chat.send(ctx, `@${salesPersonUser}`, message);
         }
 
         return ticket.updateAttribute('isDeleted', true);

modules/worker/back/models/department.json

@@ -25,6 +25,9 @@
         },
         "sons": {
             "type": "Number"
+        },
+        "chatName": {
+            "type": "String"
         }
     }
 }