refs #5066 metodo getVehiclesSorted

.dockerignore

@@ -1,6 +1,4 @@
 node_modules
 print/node_modules
-front
+front/node_modules
-db
+services
-e2e
-storage

.eslintrc.yml

@@ -1,6 +1,6 @@
 extends: [eslint:recommended, google, plugin:jasmine/recommended]
 parserOptions:
-    ecmaVersion: 2020
+    ecmaVersion: 2018
     sourceType: "module"
 plugins:
     - jasmine
@@ -17,7 +17,7 @@ rules:
     camelcase: 0
     default-case: 0
     no-eq-null: 0
-    no-console: ["warn"]
+    no-console: ["error"]
     no-warning-comments: 0
     no-empty: [error, allowEmptyCatch: true]
     complexity: 0
@@ -35,8 +35,4 @@ rules:
     space-in-parens: ["error", "never"]
     jasmine/no-focused-tests: 0
     jasmine/prefer-toHaveBeenCalledWith: 0
-    arrow-spacing: ["error", { "before": true, "after": true }]
+    arrow-spacing: ["error", { "before": true, "after": true }]
-    no-restricted-syntax:
-    - "error"
-    - selector: "NewExpression[callee.name='Date']"
-      message: "Use Date.vnNew() instead of new Date()."

.gitignore

@@ -10,4 +10,3 @@ print.*.json
 db.json
 junit.xml
 .DS_Store
-storage

.husky/addReferenceTag.js

@@ -1,33 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-
-function getCurrentBranchName(p = process.cwd()) {
-    if (!fs.existsSync(p)) return false;
-
-    const gitHeadPath = path.join(p, '.git', 'HEAD');
-
-    if (!fs.existsSync(gitHeadPath))
-        return getCurrentBranchName(path.resolve(p, '..'));
-
-    const headContent = fs.readFileSync(gitHeadPath, 'utf-8');
-    return headContent.trim().split('/')[2];
-}
-
-const branchName = getCurrentBranchName();
-
-if (branchName) {
-    const msgPath = `.git/COMMIT_EDITMSG`;
-    const msg = fs.readFileSync(msgPath, 'utf-8');
-    const reference = branchName.match(/^\d+/);
-
-    const referenceTag = `refs #${reference}`;
-    if (!msg.includes(referenceTag) && reference) {
-        const splitedMsg = msg.split(':');
-
-        if (splitedMsg.length > 1) {
-            const finalMsg = splitedMsg[0] + ': ' + referenceTag + splitedMsg.slice(1).join(':');
-            fs.writeFileSync(msgPath, finalMsg);
-        }
-    }
-}
-

.husky/commit-msg

@@ -1,8 +0,0 @@
-#!/usr/bin/env sh
-. "$(dirname -- "$0")/_/husky.sh"
-
-echo "Running husky commit-msg hook"
-npx --no-install commitlint --edit
-echo "Adding reference tag to commit message"
-node .husky/addReferenceTag.js
-

.vscode/settings.json

@@ -3,20 +3,12 @@
     // Carácter predeterminado de final de línea.
     "files.eol": "\n",
     "editor.codeActionsOnSave": {
-        "source.fixAll.eslint": "explicit"
+        "source.fixAll.eslint": true
     },
     "search.useIgnoreFiles": false,
     "editor.defaultFormatter": "dbaeumer.vscode-eslint",
     "eslint.format.enable": true,
     "[javascript]": {
         "editor.defaultFormatter": "dbaeumer.vscode-eslint"
-    },
+    }
-    "[json]": {
-        "editor.defaultFormatter": "vscode.json-language-features"
-    },
-    "cSpell.words": [
-        "salix",
-        "fdescribe",
-        "Loggable"
-    ]
 }

Dockerfile

@@ -0,0 +1,55 @@
+FROM debian:bullseye-slim
+ENV TZ Europe/Madrid
+
+ARG DEBIAN_FRONTEND=noninteractive
+
+# NodeJs
+
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends \
+        curl \
+        ca-certificates \
+        gnupg2 \
+        graphicsmagick \
+    && curl -fsSL https://deb.nodesource.com/setup_14.x | bash - \
+    && apt-get install -y --no-install-recommends nodejs \
+    && npm install -g npm@8.19.2
+
+# Puppeteer
+
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends \
+        libfontconfig lftp xvfb gconf-service libasound2 libatk1.0-0 libc6 \
+        libcairo2 libcups2 libdbus-1-3 libexpat1 libfontconfig1 libgbm1 \
+        libgcc1 libgconf-2-4 libgdk-pixbuf2.0-0 libglib2.0-0 libgtk-3-0 \
+        libnspr4 libpango-1.0-0 libpangocairo-1.0-0 libstdc++6 libx11-6 \
+        libx11-xcb1 libxcb1 libxcomposite1 libxcursor1 libxdamage1 libxext6 \
+        libxfixes3 libxi6 libxrandr2 libxrender1 libxss1 libxtst6 \
+        fonts-liberation libappindicator1 libnss3 lsb-release xdg-utils wget \
+    && rm -rf /var/lib/apt/lists/* \
+    && npm -g install pm2
+
+# Salix
+
+WORKDIR /salix
+
+COPY print/package.json print/package-lock.json print/
+RUN npm --prefix ./print install --omit=dev ./print
+
+COPY package.json package-lock.json ./
+COPY loopback/package.json loopback/
+RUN npm install --omit=dev
+
+COPY loopback loopback
+COPY back back
+COPY modules modules
+COPY print print
+COPY \
+    LICENSE \
+    README.md \
+    ./
+
+CMD ["pm2-runtime", "./back/process.yml"]
+
+HEALTHCHECK --interval=15s --timeout=10s \
+    CMD curl -f http://localhost:3000/api/Applications/status || exit 1

Jenkinsfile

@@ -1,266 +1,143 @@
 #!/usr/bin/env groovy
-
-def PROTECTED_BRANCH
-def FROM_GIT
-def RUN_TESTS
-def RUN_BUILD
-
-def BRANCH_ENV = [
-    test: 'test',
-    master: 'production',
-    beta: 'production'
-]
-
-node {
-    stage('Setup') {
-        env.BACK_REPLICAS = 1
-        env.NODE_ENV = BRANCH_ENV[env.BRANCH_NAME] ?: 'dev'
-
-        PROTECTED_BRANCH = [
-            'dev',
-            'test',
-            'master',
-            'beta'
-        ].contains(env.BRANCH_NAME)
-
-        FROM_GIT = env.JOB_NAME.startsWith('gitea/')
-        RUN_TESTS = !PROTECTED_BRANCH && FROM_GIT
-        RUN_BUILD = PROTECTED_BRANCH && FROM_GIT
-
-        // https://www.jenkins.io/doc/book/pipeline/jenkinsfile/#using-environment-variables
-        echo "NODE_NAME: ${env.NODE_NAME}"
-        echo "WORKSPACE: ${env.WORKSPACE}"
-
-        configFileProvider([
-            configFile(fileId: 'salix.properties',
-            variable: 'PROPS_FILE')
-        ]) {
-            def props = readProperties file: PROPS_FILE
-            props.each {key, value -> env."${key}" = value }
-            props.each {key, value -> echo "${key}: ${value}" }
-        }
-
-        if (PROTECTED_BRANCH) {
-            configFileProvider([
-                configFile(fileId: "salix.branch.${env.BRANCH_NAME}",
-                variable: 'BRANCH_PROPS_FILE')
-            ]) {
-                def props = readProperties file: BRANCH_PROPS_FILE
-                props.each {key, value -> env."${key}" = value }
-                props.each {key, value -> echo "${key}: ${value}" }
-            }
-        }
-    }
-}
 pipeline {
     agent any
     options {
         disableConcurrentBuilds()
     }
-    tools {
-        nodejs 'node-v20'
-    }
     environment {
         PROJECT_NAME = 'salix'
+        STACK_NAME   = "${env.PROJECT_NAME}-${env.BRANCH_NAME}"
     }
     stages {
-        stage('Version') {
+        stage('Checkout') {
-            when {
-                expression { RUN_BUILD }
-            }
             steps {
                 script {
-                    def packageJson = readJSON file: 'package.json'
+                    switch (env.BRANCH_NAME) {
-                    def version = "${packageJson.version}-build${env.BUILD_ID}"
+                        case 'master':
-                    writeFile(file: 'VERSION.txt', text: version)
+                            env.NODE_ENV = 'production'
+                            env.BACK_REPLICAS = 4
+                            break
+                        case 'test':
+                            env.NODE_ENV = 'test'
+                            env.BACK_REPLICAS = 2
+                            break
+                    }
                 }
+
+                configFileProvider([
+                    configFile(fileId: "salix.groovy",
+                    variable: 'GROOVY_FILE')
+                ]) {
+                    load env.GROOVY_FILE
+                }
+
+                setEnv()
             }
         }
         stage('Install') {
             environment {
-                NODE_ENV = ''
+                NODE_ENV = ""
-            }
-            parallel {
-                stage('Back') {
-                    steps {
-                        sh 'pnpm install --prefer-offline'
-                        sh 'node node_modules/puppeteer/install.mjs'
-                    }
-                }
-                stage('Print') {
-                    when {
-                        expression { FROM_GIT }
-                    }
-                    steps {
-                        sh 'pnpm install --prefer-offline --prefix=print'
-                    }
-                }
-                stage('Front') {
-                    when {
-                        expression { FROM_GIT }
-                    }
-                    steps {
-                        sh 'pnpm install --prefer-offline --prefix=front'
-                    }
-                }
-            }
-        }
-        stage('Stack') {
-            parallel {
-                stage('Back') {
-                    stages {
-                        stage('Test') {
-                            when {
-                                expression { RUN_TESTS }
-                            }
-                            environment {
-                                NODE_ENV = ''
-                            }
-                            steps {
-                                sh 'node back/tests.js --junit'
-                            }
-                            post {
-                                always {
-                                    junit(
-                                        testResults: 'junitresults.xml',
-                                        allowEmptyResults: true
-                                    )
-                                }
-                            }
-                        }
-                        stage('Build') {
-                            when {
-                                expression { RUN_BUILD }
-                            }
-                            environment {
-                                VERSION = readFile 'VERSION.txt'
-                            }
-                            steps {
-                                sh 'docker-compose build back'
-                            }
-                        }
-                    }
-                }
-                stage('Front') {
-                    when {
-                        expression { FROM_GIT }
-                    }
-                    stages {
-                        stage('Test') {
-                            when {
-                                expression { RUN_TESTS }
-                            }
-                            environment {
-                                NODE_ENV = ''
-                            }
-                            steps {
-                                sh 'jest --ci --reporters=default --reporters=jest-junit --maxWorkers=10'
-                            }
-                            post {
-                                always {
-                                    junit(
-                                        testResults: 'junit.xml',
-                                        allowEmptyResults: true
-                                    )
-                                }
-                            }
-                        }
-                        stage('Build') {
-                            when {
-                                expression { RUN_BUILD }
-                            }
-                            environment {
-                                VERSION = readFile 'VERSION.txt'
-                            }
-                            steps {
-                                sh 'gulp build'
-                                sh 'docker-compose build front'
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        stage('Push') {
-            when {
-                expression { RUN_BUILD }
-            }
-            environment {
-                CREDENTIALS = credentials('docker-registry')
-                VERSION = readFile 'VERSION.txt'
             }
             steps {
-                sh 'docker login --username $CREDENTIALS_USR --password $CREDENTIALS_PSW $REGISTRY'
+                nodejs('node-v14') {
-                sh 'docker-compose push'
+                    sh 'npm install --no-audit --prefer-offline'
+                    sh 'gulp install --ci'
+                }
+            }
+        }
+        stage('Test') {
+            when { not { anyOf {
+                branch 'test'
+                branch 'master'
+            }}}
+            environment {
+                NODE_ENV = ""
+            }
+            parallel {
+                stage('Frontend') {
+                    steps {
+                        nodejs('node-v14') {
+                            sh 'jest --ci --reporters=default --reporters=jest-junit --maxWorkers=2'
+                        }
+                    }
+                }
+                stage('Backend') {
+                    steps {
+                        nodejs('node-v14') {
+                            sh 'npm run test:back:ci'
+                        }
+                    }
+                }
+            }
+        }
+        stage('Build') {
+            when { anyOf {
+                branch 'test'
+                branch 'master'
+            }}
+            environment {
+                CREDENTIALS = credentials('docker-registry')
+            }
+            steps {
+                nodejs('node-v14') {
+                    sh 'gulp build'
+                }
+
+                dockerBuild()
             }
         }
         stage('Deploy') {
-            when {
+            when { anyOf {
-                expression { PROTECTED_BRANCH }
+                branch 'test'
+                branch 'master'
+            }}
+            environment {
+                DOCKER_HOST = "${env.SWARM_HOST}"
             }
-            parallel {
+            steps {
-                stage('Database') {
+                sh "docker stack deploy --with-registry-auth --compose-file docker-compose.yml ${env.STACK_NAME}"
-                    steps {
+            }
-                        configFileProvider([
+        }
-                            configFile(fileId: "config.${env.NODE_ENV}.ini",
+        stage('Database') {
-                            variable: 'MYSQL_CONFIG')
+            when { anyOf {
-                        ]) {
+                branch 'test'
-                            sh 'mkdir -p db/remotes'
+                branch 'master'
-                            sh 'cp "$MYSQL_CONFIG" db/remotes/$NODE_ENV.ini'
+            }}
-                        }
+            steps {
+                configFileProvider([
+                    configFile(fileId: "config.${env.NODE_ENV}.ini",
+                    variable: 'MYSQL_CONFIG')
+                ]) {
+                    sh 'cp "$MYSQL_CONFIG" db/config.$NODE_ENV.ini'
+                }
 
-                        sh 'npx myt push $NODE_ENV --force --commit'
+                sh 'db/import-changes.sh -f $NODE_ENV'
-                    }
-                }
-                stage('Kubernetes') {
-                    when {
-                        expression { FROM_GIT }
-                    }
-                    environment {
-                        VERSION = readFile 'VERSION.txt'
-                    }
-                    steps {
-                        withKubeConfig([
-                            serverUrl: "$KUBERNETES_API",
-                            credentialsId: 'kubernetes',
-                            namespace: 'salix'
-                        ]) {
-                            sh 'kubectl set image deployment/salix-back-$BRANCH_NAME salix-back-$BRANCH_NAME=$REGISTRY/salix-back:$VERSION'
-                            sh 'kubectl set image deployment/salix-front-$BRANCH_NAME salix-front-$BRANCH_NAME=$REGISTRY/salix-front:$VERSION'
-                        }
-                    }
-                }
             }
         }
     }
     post {
-        success {
+        always {
             script {
-                if (env.BRANCH_NAME == 'master' && FROM_GIT) {
+                if (!['master', 'test'].contains(env.BRANCH_NAME)) {
-                    env.GIT_COMMIT_MSG = sh(
+                    try {
-                        script: 'git log -1 --pretty=%B ${GIT_COMMIT}',
+                        junit 'junitresults.xml'
-                        returnStdout: true
+                        junit 'junit.xml'
-                    ).trim()
+                    } catch (e) {
+                        echo e.toString()
+                    }
+                }
 
-                    String message = env.GIT_COMMIT_MSG
+                if (!env.COMMITTER_EMAIL || currentBuild.currentResult == 'SUCCESS') return;
-                    int index = message.indexOf('\n')
+                try {
-                    if (index != -1)
+                    mail(
-                        message = message.substring(0, index)
+                        to: env.COMMITTER_EMAIL,
-
+                        subject: "Pipeline: ${env.JOB_NAME} (${env.BUILD_NUMBER}): ${currentBuild.currentResult}",
-                    setEnv()
+                        body: "Check status at ${env.BUILD_URL}"
-                    rocketSend(
-                        channel: 'vn-database',
-                        message: "*DB version uploaded:* ${message}"
-                            +"\n$COMMITTER_EMAIL ($BRANCH_NAME)"
-                            +"\n$RUN_DISPLAY_URL",
-                        rawMessage: true
                     )
+                } catch (e) {
+                    echo e.toString()
                 }
             }
         }
-        unsuccessful {
-            setEnv()
-            sendEmail()
-        }
     }
 }

README.md

@@ -8,27 +8,35 @@ Salix is also the scientific name of a beautifull tree! :)
 
 Required applications.
 
-* Node.js
+* Node.js = 14.x LTS
 * Docker
 * Git
-* MYT
 
 You will need to install globally the following items.
 ```
 $ sudo npm install -g jest gulp-cli
 ```
-After installing MYT you will need the following item.
+
+For the usage of jest --watch on macOs.
 ```
-$ apt install libkrb5-dev libssl-dev
+$ brew install watchman
+```
+* [watchman](https://facebook.github.io/watchman/)
+
+## Linux Only Prerequisites
+
+Your user must be on the docker group to use it so you will need to run this command:
+```
+$ sudo usermod -a -G docker yourusername
 ```
 
-## Installing dependencies and launching
+## Getting Started // Installing
 
 Pull from repository.
 
 Run this commands on project root directory to install Node dependencies.
 ```
-$ pnpm install
+$ npm install
 $ gulp install
 ```
 
@@ -59,21 +67,38 @@ For end-to-end tests run from project's root.
 $ npm run test:e2e
 ```
 
-## Generate changeLog test → master
-```
-$ bash changelog.sh
-```
-
-
 ## Visual Studio Code extensions
 
 Open Visual Studio Code, press Ctrl+P and paste the following commands.
 
-In Visual Studio Code we use the ESLint extension.
+In Visual Studio Code we use the ESLint extension. 
 ```
 ext install dbaeumer.vscode-eslint
 ```
 
+Gitlens for visualization of code authorship
+```
+ext install eamodio.gitlens
+```
+
+Spanish language pack
+```
+ext install ms-ceintl.vscode-language-pack-es
+```
+
+### Recommended extensions
+
+Material icon Theme
+```
+ext install pkief.material-icon-theme
+```
+
+Material UI Themes
+```
+ext install equinusocio.vsc-material-theme
+```
+
+
 ## Built With
 
 * [angularjs](https://angularjs.org/)

back/Dockerfile

@@ -1,57 +0,0 @@
-FROM debian:bookworm-slim
-ENV TZ Europe/Madrid
-
-ARG DEBIAN_FRONTEND=noninteractive
-
-# NodeJs
-
-RUN apt-get update \
-    && apt-get install -y --no-install-recommends \
-        curl \
-        ca-certificates \
-        gnupg2 \
-        graphicsmagick \
-    && curl -fsSL https://deb.nodesource.com/setup_20.x | bash - \
-    && apt-get install -y --no-install-recommends nodejs \
-    && corepack enable pnpm
-
-# Puppeteer
-
-RUN apt-get update \
-    && apt-get install -y --no-install-recommends \
-        libfontconfig lftp xvfb gconf-service libasound2 libatk1.0-0 libc6 \
-        libcairo2 libcups2 libdbus-1-3 libexpat1 libfontconfig1 libgbm1 \
-        libgcc1 libgconf-2-4 libgdk-pixbuf2.0-0 libglib2.0-0 libgtk-3-0 \
-        libnspr4 libpango-1.0-0 libpangocairo-1.0-0 libstdc++6 libx11-6 \
-        libx11-xcb1 libxcb1 libxcomposite1 libxcursor1 libxdamage1 libxext6 \
-        libxfixes3 libxi6 libxrandr2 libxrender1 libxss1 libxtst6 \
-        fonts-liberation libappindicator1 libnss3 lsb-release xdg-utils wget
-
-# Extra dependencies
-
-RUN apt-get update \
-    && apt-get install -y --no-install-recommends \
-        samba-common-bin samba-dsdb-modules\
-    && rm -rf /var/lib/apt/lists/*
-
-# Salix
-
-WORKDIR /salix
-
-COPY print/package.json print/pnpm-lock.yaml print/
-RUN pnpm install --prod --prefix=print
-
-COPY package.json pnpm-lock.yaml ./
-COPY loopback/package.json loopback/
-RUN pnpm install --prod
-
-COPY loopback loopback
-COPY back back
-COPY modules modules
-COPY print print
-COPY \
-    LICENSE \
-    README.md \
-    ./
-
-CMD ["node", "--tls-min-v1.0", "--openssl-legacy-provider", "./loopback/server/server.js"]

back/methods/chat/sendCheckingPresence.js

@@ -1,5 +1,3 @@
-const isProduction = require('vn-loopback/server/boot/isProduction');
-
 module.exports = Self => {
     Self.remoteMethodCtx('sendCheckingPresence', {
         description: 'Creates a message in the chat model checking the user status',
@@ -27,46 +25,39 @@ module.exports = Self => {
     });
 
     Self.sendCheckingPresence = async(ctx, recipientId, message) => {
+        if (!recipientId) return false;
+
+        const models = Self.app.models;
         const userId = ctx.req.accessToken.userId;
+        const sender = await models.VnUser.findById(userId, {fields: ['id']});
+        const recipient = await models.VnUser.findById(recipientId, null);
+
+        // Prevent sending messages to yourself
+        if (recipientId == userId) return false;
+
+        if (!recipient)
+            throw new Error(`Could not send message "${message}" to worker id ${recipientId} from user ${userId}`);
+
+        if (process.env.NODE_ENV == 'test')
+            message = `[Test:Environment to user ${userId}] ` + message;
+
+        const chat = await models.Chat.create({
+            senderFk: sender.id,
+            recipient: `@${recipient.name}`,
+            dated: Date.vnNew(),
+            checkUserStatus: 1,
+            message: message,
+            status: 'sending',
+            attempts: 0
+        });
+
         try {
-            const models = Self.app.models;
+            await Self.sendCheckingUserStatus(chat);
-            const sender = await models.VnUser.findById(userId, {fields: ['id']});
+            await Self.updateChat(chat, 'sent');
-            const error = `Could not send message from user ${userId}`;
+        } catch (error) {
-
+            await Self.updateChat(chat, 'error', error);
-            if (!recipientId) throw new Error(error);
-            const recipient = await models.VnUser.findById(recipientId, null);
-            if (!recipient)
-                throw new Error(error);
-
-            // Prevent sending messages to yourself
-            if (recipientId == userId) return false;
-
-            if (!isProduction())
-                message = `[Test:Environment to user ${userId}] ` + message;
-
-            const chat = await models.Chat.create({
-                senderFk: sender.id,
-                recipient: `@${recipient.name}`,
-                dated: Date.vnNew(),
-                checkUserStatus: 1,
-                message: message,
-                status: 'sending',
-                attempts: 0
-            });
-
-            try {
-                await Self.sendCheckingUserStatus(chat);
-                await Self.updateChat(chat, 'sent');
-            } catch (error) {
-                await Self.updateChat(chat, 'error', error);
-            }
-
-            return true;
-        } catch (e) {
-            await Self.rawSql(`
-                INSERT INTO util.debug (variable, value)
-                    VALUES ('sendCheckingPresence_error', ?)
-            `, [`User: ${userId}, recipient: ${recipientId}, message: ${message}, error: ${e}`]);
         }
+
+        return true;
     };
 };

back/methods/chat/sendQueued.js

@@ -1,6 +1,4 @@
 const axios = require('axios');
-const isProduction = require('vn-loopback/server/boot/isProduction');
-
 module.exports = Self => {
     Self.remoteMethodCtx('sendQueued', {
         description: 'Send a RocketChat message',
@@ -96,7 +94,7 @@ module.exports = Self => {
      * @return {Promise} - The request promise
      */
     Self.sendMessage = async function sendMessage(senderFk, recipient, message) {
-        if (!isProduction(false)) {
+        if (process.env.NODE_ENV !== 'production') {
             return new Promise(resolve => {
                 return resolve({
                     statusCode: 200,
@@ -151,7 +149,7 @@ module.exports = Self => {
      * @return {Promise} - The request promise
      */
     Self.getUserStatus = async function getUserStatus(username) {
-        if (!isProduction(false)) {
+        if (process.env.NODE_ENV !== 'production') {
             return new Promise(resolve => {
                 return resolve({
                     data: {

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

@@ -3,14 +3,14 @@ const {models} = require('vn-loopback/server/server');
 describe('Chat send()', () => {
     it('should return true as response', async() => {
         let ctx = {req: {accessToken: {userId: 1}}};
-        let response = await models.Chat.send(ctx, '@salesperson', 'I changed something');
+        let response = await models.Chat.send(ctx, '@salesPerson', 'I changed something');
 
         expect(response).toEqual(true);
     });
 
     it('should return false as response', async() => {
         let ctx = {req: {accessToken: {userId: 18}}};
-        let response = await models.Chat.send(ctx, '@salesperson', 'I changed something');
+        let response = await models.Chat.send(ctx, '@salesPerson', 'I changed something');
 
         expect(response).toEqual(false);
     });

back/methods/collection/assign.js

@@ -1,37 +0,0 @@
-const UserError = require('vn-loopback/util/user-error');
-module.exports = Self => {
-    Self.remoteMethodCtx('assign', {
-        description: 'Assign a collection',
-        accessType: 'WRITE',
-        http: {
-            path: `/assign`,
-            verb: 'POST'
-        },
-        returns: {
-            type: ['object'],
-            root: true
-        },
-    });
-
-    Self.assign = async(ctx, options) => {
-        const userId = ctx.req.accessToken.userId;
-        const myOptions = {userId};
-
-        if (typeof options == 'object')
-            Object.assign(myOptions, options);
-
-        const randStr = Math.random().toString(36).substring(3);
-        const result = await Self.rawSql(`
-            CALL vn.collection_assign(?, @vCollectionFk);
-            SELECT @vCollectionFk ?
-            `, [userId, randStr], myOptions);
-
-        // Por si entra en SELECT FOR UPDATE una o varias veces
-        const collectionFk = result.find(item => item[0]?.[randStr] !== undefined)?.[0]?.[randStr];
-
-        if (!collectionFk) throw new UserError('There are not picking tickets');
-        await Self.rawSql('CALL vn.collection_printSticker(?, NULL)', [collectionFk], myOptions);
-
-        return collectionFk;
-    };
-};

back/methods/collection/assignCollection.js

@@ -1,36 +0,0 @@
-const UserError = require('vn-loopback/util/user-error');
-module.exports = Self => {
-    Self.remoteMethodCtx('assignCollection', {
-        description: 'Assign a collection',
-        accessType: 'WRITE',
-        http: {
-            path: `/assignCollection`,
-            verb: 'POST'
-        },
-        returns: {
-            type: ['object'],
-            root: true
-        },
-    });
-
-    Self.assignCollection = async(ctx, options) => {
-        const userId = ctx.req.accessToken.userId;
-        const myOptions = {userId};
-
-        if (typeof options == 'object')
-            Object.assign(myOptions, options);
-
-        const randStr = Math.random().toString(36).substring(3);
-        const result = await Self.rawSql(`
-            CALL vn.collection_getAssigned(?, @vCollectionFk);
-            SELECT @vCollectionFk ?
-            `, [userId, randStr], myOptions);
-
-        const collectionFk = result.find(item => item[0]?.[randStr] !== undefined)?.[0]?.[randStr];
-
-        if (!collectionFk) throw new UserError('There are not picking tickets');
-        await Self.rawSql('CALL vn.collection_printSticker(?, NULL)', [collectionFk], myOptions);
-
-        return collectionFk;
-    };
-};

back/methods/collection/getSales.js

@@ -1,142 +0,0 @@
-module.exports = Self => {
-    Self.remoteMethodCtx('getSales', {
-        description: 'Get sales from ticket, collection or sectorCollection',
-        accessType: 'READ',
-        accepts: [
-            {
-                arg: 'collectionOrTicketFk',
-                type: 'number',
-                required: true
-            }, {
-                arg: 'print',
-                type: 'boolean',
-                required: true
-            }, {
-                arg: 'source',
-                type: 'string',
-                required: true
-            },
-
-        ],
-        returns: {
-            type: 'Object',
-            root: true
-        },
-        http: {
-            path: `/getSales`,
-            verb: 'GET'
-        },
-    });
-
-    Self.getSales = async(ctx, collectionOrTicketFk, print, source, options) => {
-        const userId = ctx.req.accessToken.userId;
-        const myOptions = {userId};
-
-        if (typeof options == 'object')
-            Object.assign(myOptions, options);
-
-        const [{id}] = await Self.rawSql('SELECT vn.ticket_get(?) as id',
-            [collectionOrTicketFk],
-            myOptions);
-
-        const [tickets] = await Self.rawSql('CALL vn.collection_getTickets(?)', [id], myOptions);
-
-        if (source) {
-            await Self.rawSql(
-                'CALL vn.ticketStateToday_setState(?,?)', [id, source], myOptions
-            );
-        }
-
-        const [sales] = await Self.rawSql('CALL vn.sale_getFromTicketOrCollection(?)',
-            [id], myOptions);
-
-        const isPicker = source != 'CHECKER';
-        const [placements] = await Self.rawSql('CALL vn.collectionPlacement_get(?, ?)',
-            [id, isPicker], myOptions
-        );
-
-        if (print) await Self.rawSql('CALL vn.collection_printSticker(?,NULL)', [id], myOptions);
-
-        return getCollection(id, tickets, sales, placements, myOptions);
-    };
-
-    async function getCollection(id, tickets, sales, placements, options) {
-        const collection = {
-            collectionFk: id,
-            tickets: [],
-        };
-        for (let ticket of tickets) {
-            const {ticketFk} = ticket;
-            ticket.sales = [];
-
-            const barcodes = await getBarcodes(ticketFk, options);
-            await Self.rawSql(
-                'CALL util.log_add(?, ?, ?, ?, ?, ?, ?, ?)',
-                ['vn', 'ticket', 'Ticket', ticketFk, ticketFk, 'select', null, null],
-                options
-            );
-
-            for (let sale of sales) {
-                if (sale.ticketFk == ticketFk) {
-                    sale.placements = [];
-                    for (const salePlacement of placements) {
-                        if (salePlacement.saleFk == sale.saleFk && salePlacement.order) {
-                            const placement = {
-                                saleFk: salePlacement.saleFk,
-                                itemFk: salePlacement.itemFk,
-                                placement: salePlacement.placement,
-                                shelving: salePlacement.shelving,
-                                created: salePlacement.created,
-                                visible: salePlacement.visible,
-                                order: salePlacement.order,
-                                grouping: salePlacement.grouping,
-                                priority: salePlacement.priority,
-                                saleOrder: salePlacement.saleOrder,
-                                isPreviousPrepared: salePlacement.isPreviousPrepared,
-                                itemShelvingSaleFk: salePlacement.itemShelvingSaleFk,
-                                ticketFk: salePlacement.ticketFk,
-                                id: salePlacement.id
-                            };
-                            sale.placements.push(placement);
-                        }
-                    }
-
-                    sale.barcodes = [];
-                    for (const barcode of barcodes) {
-                        if (barcode.movementId == sale.saleFk) {
-                            if (barcode.code) {
-                                sale.barcodes.push(barcode.code);
-                                sale.barcodes.push(`0 ${barcode.code}`);
-                            }
-
-                            if (barcode.id) {
-                                sale.barcodes.push(barcode.id);
-                                sale.barcodes.push(`0 ${barcode.id}`);
-                            }
-                        }
-                    }
-
-                    ticket.sales.push(sale);
-                }
-            }
-            collection.tickets.push(ticket);
-        }
-
-        return collection;
-    }
-
-    async function getBarcodes(ticketId, options) {
-        const query =
-                `SELECT s.id movementId, 
-                        b.code, 
-                        c.id
-                    FROM vn.sale s
-                        LEFT JOIN vn.itemBarcode b ON b.itemFk = s.itemFk
-                        LEFT JOIN vn.buy c ON c.itemFk = s.itemFk
-                        LEFT JOIN vn.entry e ON e.id = c.entryFk
-                        LEFT JOIN vn.travel tr ON tr.id = e.travelFk
-                    WHERE s.ticketFk = ? 
-                        AND tr.landed >= DATE_SUB(CURDATE(), INTERVAL 1 YEAR)`;
-        return Self.rawSql(query, [ticketId], options);
-    }
-};

back/methods/collection/getSectors.js

@@ -0,0 +1,20 @@
+module.exports = Self => {
+    Self.remoteMethod('getSectors', {
+        description: 'Get all sectors',
+        accessType: 'READ',
+        returns: {
+            type: 'Object',
+            root: true
+        },
+        http: {
+            path: `/getSectors`,
+            verb: 'GET'
+        }
+    });
+
+    Self.getSectors = async() => {
+        const query = `CALL vn.sector_get()`;
+        const [result] = await Self.rawSql(query);
+        return result;
+    };
+};

back/methods/collection/getTickets.js

@@ -1,189 +0,0 @@
-
-module.exports = Self => {
-    Self.remoteMethodCtx('getTickets', {
-        description: 'Make a new collection of tickets',
-        accessType: 'WRITE',
-        accepts: [{
-            arg: 'id',
-            type: 'number',
-            description: 'The collection id',
-            required: true,
-            http: {source: 'path'}
-        }, {
-            arg: 'print',
-            type: 'boolean',
-            description: 'True if you want to print'
-        }],
-        returns: {
-            type: ['object'],
-            root: true
-        },
-        http: {
-            path: `/:id/getTickets`,
-            verb: 'POST'
-        }
-    });
-
-    Self.getTickets = async(ctx, id, print, options) => {
-        const userId = ctx.req.accessToken.userId;
-        const url = await Self.app.models.Url.getUrl();
-        const $t = ctx.req.__;
-        const myOptions = {};
-
-        if (typeof options == 'object')
-            Object.assign(myOptions, options);
-
-        myOptions.userId = userId;
-
-        const promises = [];
-        const [tickets] = await Self.rawSql(`CALL vn.collection_getTickets(?)`, [id], myOptions);
-
-        const sales = await Self.rawSql(`
-            SELECT s.ticketFk,
-                    NULL ticketOrder,
-                    sgd.saleGroupFk,
-                    s.id saleFk,
-                    s.itemFk,
-                    i.longName,
-                    i.size,
-                    ic.color,
-                    o.code origin,
-                    ish.packing,
-                    ish.grouping,
-                    s.isAdded,
-                    s.originalQuantity,
-                    s.quantity saleQuantity,
-                    iss.quantity reservedQuantity,
-                    SUM(iss.quantity) OVER (PARTITION BY s.id ORDER BY ish.id) accumulatedQuantity,
-                    ROW_NUMBER () OVER (PARTITION BY s.id ORDER BY pickingOrder) currentItemShelving,
-                    COUNT(*) OVER (PARTITION BY s.id ORDER BY s.id) totalItemShelving,
-                    sh.code,
-                    p2.code parkingCodePrevia,
-                    p2.pickingOrder pickingOrderPrevia,
-                    p.code parkingCode,
-                    p.pickingOrder pickingOrder,
-                    iss.id itemShelvingSaleFk,
-                    iss.isPicked,
-                    iss.itemShelvingFk,
-                    st.code stateCode,
-                    ac.username
-                FROM ticketCollection tc
-                    LEFT JOIN collection c ON c.id = tc.collectionFk
-                    JOIN sale s ON s.ticketFk = tc.ticketFk
-                    LEFT JOIN saleGroupDetail sgd ON sgd.saleFk = s.id
-                    LEFT JOIN saleGroup sg ON sg.id = sgd.saleGroupFk
-                    LEFT JOIN parking p2 ON p2.id = sg.parkingFk
-                    JOIN item i ON i.id = s.itemFk
-                    JOIN itemShelvingSale iss ON iss.saleFk = s.id
-                    LEFT JOIN itemShelving ish ON ish.id = iss.itemShelvingFk
-                    LEFT JOIN shelving sh ON sh.id = ish.shelvingFk
-                    LEFT JOIN parking p ON p.id = sh.parkingFk
-                    LEFT JOIN itemColor ic ON ic.itemFk = s.itemFk
-                    LEFT JOIN origin o ON o.id = i.originFk
-                    LEFT JOIN state st ON st.id = sg.stateFk
-                    LEFT JOIN account.user ac ON ac.id = iss.userFk
-                WHERE tc.collectionFk = ?
-                GROUP BY s.id, ish.id, p.code, p2.code
-            UNION ALL
-            SELECT s.ticketFk,
-                DENSE_RANK() OVER (ORDER BY ss.id),
-                sgd.saleGroupFk,
-                s.id saleFk,
-                s.itemFk,
-                i.longName,
-                i.size,
-                ic.color,
-                o.code origin,
-                ish.packing,
-                ish.grouping,
-                s.isAdded,
-                s.originalQuantity,
-                s.quantity,
-                iss.quantity,
-                SUM(iss.quantity) OVER (PARTITION BY s.id ORDER BY ish.id),
-                ROW_NUMBER () OVER (PARTITION BY s.id ORDER BY p.pickingOrder),
-                COUNT(*) OVER (PARTITION BY s.id ORDER BY s.id) ,
-                sh.code,
-                p2.code,
-                p2.pickingOrder,
-                p.code,
-                p.pickingOrder,
-                iss.id itemShelvingSaleFk,
-                iss.isPicked,
-                iss.itemShelvingFk,
-                st.code stateCode,
-                ac.username
-            FROM sectorCollection sc
-                JOIN sectorCollectionSaleGroup ss ON ss.sectorCollectionFk  = sc.id 
-                JOIN saleGroup sg ON sg.id = ss.saleGroupFk
-                LEFT JOIN saleGroupDetail sgd ON sgd.saleGroupFk = sg.id
-                JOIN sale s ON s.id = sgd.saleFk 
-                LEFT JOIN parking p2 ON p2.id = sg.parkingFk
-                JOIN item i ON i.id = s.itemFk
-                JOIN itemShelvingSale iss ON iss.saleFk = s.id
-                LEFT JOIN itemShelving ish ON ish.id = iss.itemShelvingFk
-                LEFT JOIN shelving sh ON sh.id = ish.shelvingFk
-                LEFT JOIN parking p ON p.id = sh.parkingFk
-                LEFT JOIN itemColor ic ON ic.itemFk = s.itemFk
-                LEFT JOIN origin o ON o.id = i.originFk
-                LEFT JOIN state st ON st.id = sg.stateFk
-                LEFT JOIN account.user ac ON ac.id = sg.userFk
-            WHERE sc.id = ? 
-                AND sgd.saleGroupFk
-            GROUP BY s.id, ish.id, p.code, p2.code`, [id, id], myOptions);
-        if (print)
-            await Self.rawSql(`CALL vn.collection_printSticker(?, ?)`, [id, null], myOptions);
-
-        const collection = {collectionFk: id, tickets: []};
-
-        if (tickets && tickets.length) {
-            for (const ticket of tickets) {
-                const ticketId = ticket.ticketFk;
-                if (ticket.observation) {
-                    for (observation of ticket.observation?.split(' ')) {
-                        if (['#', '@'].includes(observation.charAt(0))) {
-                            promises.push(Self.app.models.Chat.send(ctx, observation,
-                                $t('The ticket is in preparation', {
-                                    ticketId: ticketId,
-                                    ticketUrl: `${url}ticket/${ticketId}/summary`,
-                                    salesPersonId: ticket.salesPersonFk
-                                })));
-                        }
-                    }
-                }
-                if (sales && sales.length) {
-                    const barcodes = await Self.rawSql(`
-                        SELECT s.id saleFk, b.code, c.id
-                            FROM sale s
-                                LEFT JOIN itemBarcode b ON b.itemFk = s.itemFk
-                                LEFT JOIN buy c ON c.itemFk = s.itemFk
-                                LEFT JOIN entry e ON e.id = c.entryFk
-                                LEFT JOIN travel tr ON tr.id = e.travelFk
-                            WHERE s.ticketFk = ?
-                                AND tr.landed >= util.VN_CURDATE() - INTERVAL 1 YEAR`,
-                    [ticketId], myOptions);
-                    ticket.sales = [];
-                    for (const sale of sales) {
-                        if (sale.ticketFk === ticketId) {
-                            sale.Barcodes = [];
-                            if (barcodes && barcodes.length) {
-                                for (const barcode of barcodes) {
-                                    if (barcode.saleFk === sale.saleFk) {
-                                        for (const prop in barcode) {
-                                            if (['id', 'code'].includes(prop) && barcode[prop])
-                                                sale.Barcodes.push(barcode[prop].toString(), '0' + barcode[prop]);
-                                        }
-                                    }
-                                }
-                            }
-                            ticket.sales.push(sale);
-                        }
-                    }
-                }
-                collection.tickets.push(ticket);
-            }
-        }
-        await Promise.all(promises);
-        return collection;
-    };
-};

back/methods/collection/newCollection.js

@@ -0,0 +1,133 @@
+module.exports = Self => {
+    Self.remoteMethodCtx('newCollection', {
+        description: 'Make a new collection of tickets',
+        accessType: 'WRITE',
+        accepts: [{
+            arg: 'collectionFk',
+            type: 'Number',
+            required: false,
+            description: 'The collection id'
+        }, {
+            arg: 'sectorFk',
+            type: 'Number',
+            required: true,
+            description: 'The sector of worker'
+        }, {
+            arg: 'vWagons',
+            type: 'Number',
+            required: true,
+            description: 'The number of wagons'
+        }],
+        returns: {
+            type: 'Object',
+            root: true
+        },
+        http: {
+            path: `/newCollection`,
+            verb: 'POST'
+        }
+    });
+
+    Self.newCollection = async(ctx, collectionFk, sectorFk, vWagons) => {
+        let query = '';
+
+        if (!collectionFk) {
+            const userId = ctx.req.accessToken.userId;
+            query = `CALL vn.collectionTrain_newBeta(?,?,?)`;
+            const [result] = await Self.rawSql(query, [sectorFk, vWagons, userId]);
+            if (result.length == 0)
+                throw new Error(`No collections for today`);
+
+            collectionFk = result[0].vCollectionFk;
+        }
+
+        query = `CALL vn.collectionTicket_get(?)`;
+        const [tickets] = await Self.rawSql(query, [collectionFk]);
+
+        query = `CALL vn.collectionSale_get(?)`;
+        const [sales] = await Self.rawSql(query, [collectionFk]);
+
+        query = `CALL vn.collectionPlacement_get(?)`;
+        const [placements] = await Self.rawSql(query, [collectionFk]);
+
+        query = `CALL vn.collectionSticker_print(?,?)`;
+        await Self.rawSql(query, [collectionFk, sectorFk]);
+
+        return makeCollection(tickets, sales, placements, collectionFk);
+    };
+
+    /**
+     * Returns a collection json
+     * @param {*} tickets - Request tickets
+     * @param {*} sales - Request sales
+     * @param {*} placements - Request placements
+     * @param {*} collectionFk - Request placements
+     * @return {Object} Collection JSON
+     */
+    async function makeCollection(tickets, sales, placements, collectionFk) {
+        let collection = [];
+
+        for (let i = 0; i < tickets.length; i++) {
+            let ticket = {};
+            ticket['ticketFk'] = tickets[i]['ticketFk'];
+            ticket['level'] = tickets[i]['level'];
+            ticket['agencyName'] = tickets[i]['agencyName'];
+            ticket['warehouseFk'] = tickets[i]['warehouseFk'];
+            ticket['salesPersonFk'] = tickets[i]['salesPersonFk'];
+
+            let ticketSales = [];
+
+            for (let x = 0; x < sales.length; x++) {
+                if (sales[x]['ticketFk'] == ticket['ticketFk']) {
+                    let sale = {};
+                    sale['collectionFk'] = collectionFk;
+                    sale['ticketFk'] = sales[x]['ticketFk'];
+                    sale['saleFk'] = sales[x]['saleFk'];
+                    sale['itemFk'] = sales[x]['itemFk'];
+                    sale['quantity'] = sales[x]['quantity'];
+                    if (sales[x]['quantityPicked'] != null)
+                        sale['quantityPicked'] = sales[x]['quantityPicked'];
+                    else
+                        sale['quantityPicked'] = 0;
+                    sale['longName'] = sales[x]['longName'];
+                    sale['size'] = sales[x]['size'];
+                    sale['color'] = sales[x]['color'];
+                    sale['discount'] = sales[x]['discount'];
+                    sale['price'] = sales[x]['price'];
+                    sale['stems'] = sales[x]['stems'];
+                    sale['category'] = sales[x]['category'];
+                    sale['origin'] = sales[x]['origin'];
+                    sale['clientFk'] = sales[x]['clientFk'];
+                    sale['productor'] = sales[x]['productor'];
+                    sale['reserved'] = sales[x]['reserved'];
+                    sale['isPreviousPrepared'] = sales[x]['isPreviousPrepared'];
+                    sale['isPrepared'] = sales[x]['isPrepared'];
+                    sale['isControlled'] = sales[x]['isControlled'];
+
+                    let salePlacements = [];
+
+                    for (let z = 0; z < placements.length; z++) {
+                        if (placements[z]['saleFk'] == sale['saleFk']) {
+                            let placement = {};
+                            placement['saleFk'] = placements[z]['saleFk'];
+                            placement['itemFk'] = placements[z]['itemFk'];
+                            placement['placement'] = placements[z]['placement'];
+                            placement['shelving'] = placements[z]['shelving'];
+                            placement['created'] = placements[z]['created'];
+                            placement['visible'] = placements[z]['visible'];
+                            placement['order'] = placements[z]['order'];
+                            placement['grouping'] = placements[z]['grouping'];
+                            salePlacements.push(placement);
+                        }
+                    }
+                    sale['placements'] = salePlacements;
+                    ticketSales.push(sale);
+                }
+            }
+            ticket['sales'] = ticketSales;
+            collection.push(ticket);
+        }
+
+        return collection;
+    }
+};

back/methods/collection/setSaleQuantity.js

@@ -40,7 +40,8 @@ module.exports = Self => {
         try {
             const sale = await models.Sale.findById(saleId, null, myOptions);
             const saleUpdated = await sale.updateAttributes({
-                quantity
+                originalQuantity: sale.quantity,
+                quantity: quantity
             }, myOptions);
 
             if (tx) await tx.commit();

back/methods/collection/spec/assign.spec.js

@@ -1,39 +0,0 @@
-const models = require('vn-loopback/server/server').models;
-const LoopBackContext = require('loopback-context');
-
-describe('ticket assign()', () => {
-    let ctx;
-    let options;
-    let tx;
-    beforeEach(async() => {
-        ctx = {
-            req: {
-                accessToken: {userId: 1106},
-                headers: {origin: 'http://localhost'},
-                __: value => value
-            },
-            args: {}
-        };
-
-        spyOn(LoopBackContext, 'getCurrentContext').and.returnValue({
-            active: ctx.req
-        });
-
-        options = {transaction: tx};
-        tx = await models.Sale.beginTransaction({});
-        options.transaction = tx;
-    });
-
-    afterEach(async() => {
-        await tx.rollback();
-    });
-
-    it('should throw an error when there are no picking tickets', async() => {
-        try {
-            await models.Collection.assign(ctx, options);
-            fail('Expected an error to be thrown, but none was thrown.');
-        } catch (e) {
-            expect(e.message).toEqual('There are not picking tickets');
-        }
-    });
-});

back/methods/collection/spec/assignCollection.spec.js

@@ -1,36 +0,0 @@
-const models = require('vn-loopback/server/server').models;
-const LoopBackContext = require('loopback-context');
-
-describe('ticket assignCollection()', () => {
-    let ctx;
-    let options;
-    let tx;
-    beforeEach(async() => {
-        ctx = {
-            req: {
-                accessToken: {userId: 1106},
-                headers: {origin: 'http://localhost'},
-                __: value => value
-            },
-            args: {}
-        };
-
-        spyOn(LoopBackContext, 'getCurrentContext').and.returnValue({active: ctx.req});
-
-        options = {transaction: tx};
-        tx = await models.Sale.beginTransaction({});
-        options.transaction = tx;
-    });
-
-    afterEach(async() => {
-        if (tx) await tx.rollback();
-    });
-
-    it('should throw an error when  there is not picking tickets', async() => {
-        try {
-            await models.Collection.assignCollection(ctx, options);
-        } catch (e) {
-            expect(e.message).toEqual('There are not picking tickets');
-        }
-    });
-});

back/methods/collection/spec/getSales.spec.js

@@ -1,54 +0,0 @@
-const {models} = require('vn-loopback/server/server');
-
-describe('collection getSales()', () => {
-    const collectionOrTicketFk = 999999;
-    const print = true;
-    const source = 'CHECKER';
-    const ctx = beforeAll.getCtx();
-
-    it('should return a collection with tickets, placements and barcodes settled correctly', async() => {
-        const tx = await models.Collection.beginTransaction({});
-        const options = {transaction: tx};
-        try {
-            const collection = await models.Collection.getSales(ctx,
-                collectionOrTicketFk, print, source, options);
-
-            const [firstTicket] = collection.tickets;
-            const [firstSale] = firstTicket.sales;
-            const [firstPlacement] = firstSale.placements;
-
-            expect(collection.tickets.length).toBeTruthy();
-            expect(collection.collectionFk).toEqual(firstTicket.ticketFk);
-
-            expect(firstSale.ticketFk).toEqual(firstTicket.ticketFk);
-            expect(firstSale.placements.length).toBeTruthy();
-            expect(firstSale.barcodes.length).toBeTruthy();
-
-            expect(firstSale.saleFk).toEqual(firstPlacement.saleFk);
-            await tx.rollback();
-        } catch (e) {
-            await tx.rollback();
-            throw e;
-        }
-    });
-
-    it('should print a sticker', async() => {
-        const tx = await models.Collection.beginTransaction({});
-        const options = {transaction: tx};
-        const query = 'SELECT * FROM printQueue pq JOIN printQueueArgs pqa ON pqa.printQueueFk = pq.id';
-        try {
-            const printQueueBefore = await models.Collection.rawSql(
-                query, [], options);
-            await models.Collection.getSales(ctx,
-                collectionOrTicketFk, true, source, options);
-            const printQueueAfter = await models.Collection.rawSql(
-                query, [], options);
-
-            expect(printQueueAfter.length).toEqual(printQueueBefore.length + 1);
-            await tx.rollback();
-        } catch (e) {
-            await tx.rollback();
-            throw e;
-        }
-    });
-});

back/methods/collection/spec/getSectors.spec.js

@@ -0,0 +1,11 @@
+const {models} = require('vn-loopback/server/server');
+
+describe('getSectors()', () => {
+    it('return list of sectors', async() => {
+        let response = await models.Collection.getSectors();
+
+        expect(response.length).toBeGreaterThan(0);
+        expect(response[0].id).toEqual(1);
+        expect(response[0].description).toEqual('First sector');
+    });
+});

back/methods/collection/spec/getTickets.spec.js

@@ -1,31 +0,0 @@
-const models = require('vn-loopback/server/server').models;
-
-describe('collection getTickets()', () => {
-    const ctx = beforeAll.getCtx();
-
-    it('should get tickets, sales and barcodes from collection', async() => {
-        const tx = await models.Collection.beginTransaction({});
-
-        try {
-            const options = {transaction: tx};
-            const collectionId = 1;
-
-            const collectionTickets = await models.Collection.getTickets(ctx, collectionId, null, options);
-
-            expect(collectionTickets.collectionFk).toEqual(collectionId);
-            expect(collectionTickets.tickets.length).toEqual(3);
-            expect(collectionTickets.tickets[0].ticketFk).toEqual(1);
-            expect(collectionTickets.tickets[1].ticketFk).toEqual(2);
-            expect(collectionTickets.tickets[2].ticketFk).toEqual(23);
-            expect(collectionTickets.tickets[0].sales[0].ticketFk).toEqual(1);
-            expect(collectionTickets.tickets[1].sales.length).toEqual(0);
-            expect(collectionTickets.tickets[2].sales.length).toEqual(0);
-            expect(collectionTickets.tickets[0].sales[0].Barcodes.length).toBeTruthy();
-
-            await tx.rollback();
-        } catch (e) {
-            await tx.rollback();
-            throw e;
-        }
-    });
-});

back/methods/collection/spec/newCollection.spec.js

@@ -0,0 +1,12 @@
+const {models} = require('vn-loopback/server/server');
+
+describe('newCollection()', () => {
+    it('should return a new collection', async() => {
+        pending('#3400 analizar que hacer con rutas de back collection');
+        let ctx = {req: {accessToken: {userId: 1106}}};
+        let response = await models.Collection.newCollection(ctx, 1, 1, 1);
+
+        expect(response.length).toBeGreaterThan(0);
+        expect(response[0].ticketFk).toEqual(2);
+    });
+});

back/methods/collection/spec/setSaleQuantity.spec.js

@@ -1,18 +1,23 @@
 const models = require('vn-loopback/server/server').models;
+const LoopBackContext = require('loopback-context');
 
 describe('setSaleQuantity()', () => {
-    beforeAll.mockLoopBackContext();
+    beforeAll(async() => {
+        const activeCtx = {
+            accessToken: {userId: 9},
+            http: {
+                req: {
+                    headers: {origin: 'http://localhost'}
+                }
+            }
+        };
+        spyOn(LoopBackContext, 'getCurrentContext').and.returnValue({
+            active: activeCtx
+        });
+    });
 
     it('should change quantity sale', async() => {
         const tx = await models.Ticket.beginTransaction({});
-        spyOn(models.Sale, 'rawSql').and.callFake((sqlStatement, params, options) => {
-            if (sqlStatement.includes('catalog_calcFromItem')) {
-                sqlStatement = `CREATE OR REPLACE TEMPORARY TABLE tmp.ticketCalculateItem ENGINE = MEMORY
-                        SELECT 100 as available;`;
-                params = null;
-            }
-            return models.Ticket.rawSql(sqlStatement, params, options);
-        });
 
         try {
             const options = {transaction: tx};
@@ -25,7 +30,7 @@ describe('setSaleQuantity()', () => {
             await models.Collection.setSaleQuantity(saleId, newQuantity, options);
             const updateSale = await models.Sale.findById(saleId, null, options);
 
-            expect(updateSale.quantity).not.toEqual(originalSale.quantity);
+            expect(updateSale.originalQuantity).toEqual(originalSale.quantity);
             expect(updateSale.quantity).toEqual(newQuantity);
 
             await tx.rollback();

back/methods/dms/deleteTrashFiles.js

@@ -1,7 +1,6 @@
 const UserError = require('vn-loopback/util/user-error');
 const fs = require('fs-extra');
 const path = require('path');
-const isProduction = require('vn-loopback/server/boot/isProduction');
 
 module.exports = Self => {
     Self.remoteMethod('deleteTrashFiles', {
@@ -23,7 +22,7 @@ module.exports = Self => {
         if (typeof options == 'object')
             Object.assign(myOptions, options);
 
-        if (!isProduction())
+        if (process.env.NODE_ENV == 'test')
             throw new UserError(`Action not allowed on the test environment`);
 
         const models = Self.app.models;

back/methods/dms/downloadFile.js

@@ -29,8 +29,7 @@ module.exports = Self => {
         http: {
             path: `/:id/downloadFile`,
             verb: 'GET'
-        },
+        }
-        accessScopes: ['DEFAULT', 'read:multimedia']
     });
 
     Self.downloadFile = async function(ctx, id) {

back/methods/dms/removeFile.js

@@ -22,8 +22,8 @@ module.exports = Self => {
 
     Self.removeFile = async(ctx, id, options) => {
         const models = Self.app.models;
-        const myOptions = {};
         let tx;
+        const myOptions = {};
 
         if (typeof options == 'object')
             Object.assign(myOptions, options);

back/methods/dms/updateFile.js

@@ -38,7 +38,7 @@ module.exports = Self => {
         {
             arg: 'hasFile',
             type: 'Boolean',
-            description: 'True if has the original in paper'
+            description: 'True if has an attached file'
         },
         {
             arg: 'hasFileAttached',

back/methods/dms/uploadFile.js

@@ -49,6 +49,7 @@ module.exports = Self => {
     Self.uploadFile = async(ctx, options) => {
         const models = Self.app.models;
         const TempContainer = models.TempContainer;
+        const DmsContainer = models.DmsContainer;
         const fileOptions = {};
         const args = ctx.args;
 
@@ -78,21 +79,19 @@ module.exports = Self => {
 
             const addedDms = [];
             for (const uploadedFile of files) {
+                const newDms = await createDms(ctx, uploadedFile, myOptions);
+                const pathHash = DmsContainer.getHash(newDms.id);
+
                 const file = await TempContainer.getFile(tempContainer.name, uploadedFile.name);
                 srcFile = path.join(file.client.root, file.container, file.name);
 
-                const data = {
+                const dmsContainer = await DmsContainer.container(pathHash);
-                    workerFk: ctx.req.accessToken.userId,
+                const dstFile = path.join(dmsContainer.client.root, pathHash, newDms.file);
-                    dmsTypeFk: args.dmsTypeId,
+
-                    companyFk: args.companyId,
+                await fs.move(srcFile, dstFile, {
-                    warehouseFk: args.warehouseId,
+                    overwrite: true
-                    reference: args.reference,
+                });
-                    description: args.description,
+
-                    contentType: uploadedFile.type,
-                    hasFile: args.hasFile
-                };
-                const extension = await models.DmsContainer.getFileExtension(uploadedFile.name);
-                const newDms = await Self.createFromFile(data, extension, srcFile, myOptions);
                 addedDms.push(newDms);
             }
 
@@ -108,4 +107,27 @@ module.exports = Self => {
             throw e;
         }
     };
+
+    async function createDms(ctx, file, myOptions) {
+        const models = Self.app.models;
+        const myUserId = ctx.req.accessToken.userId;
+        const args = ctx.args;
+
+        const newDms = await Self.create({
+            workerFk: myUserId,
+            dmsTypeFk: args.dmsTypeId,
+            companyFk: args.companyId,
+            warehouseFk: args.warehouseId,
+            reference: args.reference,
+            description: args.description,
+            contentType: file.type,
+            hasFile: args.hasFile
+        }, myOptions);
+
+        let fileName = file.name;
+        const extension = models.DmsContainer.getFileExtension(fileName);
+        fileName = `${newDms.id}.${extension}`;
+
+        return newDms.updateAttribute('file', fileName, myOptions);
+    }
 };

back/methods/docuware/checkFile.js

@@ -1,5 +1,7 @@
+const axios = require('axios');
+
 module.exports = Self => {
-    Self.remoteMethod('checkFile', {
+    Self.remoteMethodCtx('checkFile', {
         description: 'Check if exist docuware file',
         accessType: 'READ',
         accepts: [
@@ -15,16 +17,12 @@ module.exports = Self => {
                 required: true,
                 description: 'The fileCabinet name'
             },
-            {
-                arg: 'filter',
-                type: 'object',
-                description: 'The filter'
-            },
             {
                 arg: 'signed',
                 type: 'boolean',
+                required: true,
                 description: 'If pdf is necessary to be signed'
-            },
+            }
         ],
         returns: {
             type: 'object',
@@ -36,7 +34,7 @@ module.exports = Self => {
         }
     });
 
-    Self.checkFile = async function(id, fileCabinet, filter, signed) {
+    Self.checkFile = async function(ctx, id, fileCabinet, signed) {
         const models = Self.app.models;
         const action = 'find';
 
@@ -47,34 +45,40 @@ module.exports = Self => {
             }
         });
 
-        if (!filter) {
+        const searchFilter = {
-            filter = {
+            condition: [
-                condition: [
+                {
-                    {
+                    DBName: docuwareInfo.findById,
-                        DBName: docuwareInfo.findById,
+
-                        Value: [id]
+                    Value: [id]
-                    }
+                }
-                ],
+            ],
-                sortOrder: [
+            sortOrder: [
-                    {
+                {
-                        Field: 'FILENAME',
+                    Field: 'FILENAME',
-                        Direction: 'Desc'
+                    Direction: 'Desc'
-                    }
+                }
-                ]
+            ]
-            };
+        };
-        }
-        if (signed) {
-            filter.condition.push({
-                DBName: 'ESTADO',
-                Value: ['Firmado']
-            });
-        }
 
         try {
-            const [response] = await Self.get(fileCabinet, filter);
+            const options = await Self.getOptions();
-            if (!response) return false;
 
-            return {id: response['Document ID']};
+            const fileCabinetId = await Self.getFileCabinet(fileCabinet);
+            const dialogId = await Self.getDialog(fileCabinet, action, fileCabinetId);
+
+            const response = await axios.post(
+                `${options.url}/FileCabinets/${fileCabinetId}/Query/DialogExpression?dialogId=${dialogId}`,
+                searchFilter,
+                options.headers
+            );
+            const [documents] = response.data.Items;
+            if (!documents) return false;
+
+            const state = documents.Fields.find(field => field.FieldName == 'ESTADO');
+            if (signed && state.Item != 'Firmado') return false;
+
+            return {id: documents.Id};
         } catch (error) {
             return false;
         }

back/methods/docuware/core.js

@@ -1,52 +1,6 @@
 const axios = require('axios');
 
 module.exports = Self => {
-    /**
-     * Returns basic headers
-     *
-     * @return {object} - The headers
-     */
-    Self.getOptions = async() => {
-        const docuwareConfig = await Self.app.models.DocuwareConfig.findOne();
-        const now = Date.vnNow();
-        let {url, username, password, token, expired} = docuwareConfig;
-
-        if (process.env.NODE_ENV && (!expired || expired < now + 60)) {
-            const {data: {IdentityServiceUrl}} = await axios.get(`${url}/Home/IdentityServiceInfo`);
-            const {data: {token_endpoint}} = await axios.get(`${IdentityServiceUrl}/.well-known/openid-configuration`);
-            const {data} = await axios.post(token_endpoint, {
-                grant_type: 'password',
-                scope: 'docuware.platform',
-                client_id: 'docuware.platform.net.client',
-                username,
-                password
-            }, {headers: {
-                'Accept': 'application/json',
-                'Content-Type': 'application/x-www-form-urlencoded'
-            }});
-
-            const newToken = data.access_token;
-            token = data.token_type + ' ' + newToken;
-            await docuwareConfig.updateAttributes({
-                token,
-                expired: now + data.expires_in
-            });
-        }
-
-        const headers = {
-            headers: {
-                'Accept': 'application/json',
-                'Content-Type': 'application/json',
-                'Authorization': token
-            }
-        };
-
-        return {
-            url,
-            headers
-        };
-    };
-
     /**
      * Returns the dialog id
      *
@@ -56,19 +10,19 @@ module.exports = Self => {
      * @return {number} - The fileCabinet id
      */
     Self.getDialog = async(code, action, fileCabinetId) => {
-        if (!process.env.NODE_ENV)
-            return Math.floor(Math.random() + 100);
-
         const docuwareInfo = await Self.app.models.Docuware.findOne({
             where: {
-                code,
+                code: code,
-                action
+                action: action
             }
         });
         if (!fileCabinetId) fileCabinetId = await Self.getFileCabinet(code);
 
         const options = await Self.getOptions();
 
+        if (!process.env.NODE_ENV)
+            return Math.round();
+
         const response = await axios.get(`${options.url}/FileCabinets/${fileCabinetId}/dialogs`, options.headers);
         const dialogs = response.data.Dialog;
         const dialogId = dialogs.find(dialogs => dialogs.DisplayName === docuwareInfo.dialogName).Id;
@@ -83,16 +37,16 @@ module.exports = Self => {
      * @return {number} - The fileCabinet id
      */
     Self.getFileCabinet = async code => {
-        if (!process.env.NODE_ENV)
-            return Math.floor(Math.random() + 100);
-
         const options = await Self.getOptions();
         const docuwareInfo = await Self.app.models.Docuware.findOne({
             where: {
-                code
+                code: code
             }
         });
 
+        if (!process.env.NODE_ENV)
+            return Math.round();
+
         const fileCabinetResponse = await axios.get(`${options.url}/FileCabinets`, options.headers);
         const fileCabinets = fileCabinetResponse.data.FileCabinet;
         const fileCabinetId = fileCabinets.find(fileCabinet => fileCabinet.Name === docuwareInfo.fileCabinetName).Id;
@@ -101,84 +55,24 @@ module.exports = Self => {
     };
 
     /**
-     * Returns docuware data
+     * Returns basic headers
      *
-     * @param {string} code - The fileCabinet code
+     * @param {string} cookie - The docuware cookie
-     * @param {object} filter - The filter for docuware
+     * @return {object} - The headers
-     * @param {object} parse - The fields parsed
-     * @return {object} - The data
      */
-    Self.get = async(code, filter, parse) => {
+    Self.getOptions = async() => {
-        if (!process.env.NODE_ENV) return;
+        const docuwareConfig = await Self.app.models.DocuwareConfig.findOne();
-
+        const headers = {
-        const options = await Self.getOptions();
+            headers: {
-        const fileCabinetId = await Self.getFileCabinet(code);
+                'Accept': 'application/json',
-        const dialogId = await Self.getDialog(code, 'find', fileCabinetId);
+                'Content-Type': 'application/json',
-
+                'Cookie': docuwareConfig.cookie
-        const data = await axios.post(
-            `${options.url}/FileCabinets/${fileCabinetId}/Query/DialogExpression?dialogId=${dialogId}`,
-            filter,
-            options.headers
-        );
-        return parser(data.data, parse);
-    };
-
-    /**
-     * Returns docuware data
-     *
-     * @param {string} code - The fileCabinet code
-     * @param {any} id - The id of docuware
-     * @param {object} parse - The fields parsed
-     * @return {object} - The data
-     */
-    Self.getById = async(code, id, parse) => {
-        if (!process.env.NODE_ENV) return;
-
-        const docuwareInfo = await Self.app.models.Docuware.findOne({
-            fields: ['findById'],
-            where: {
-                code,
-                action: 'find'
             }
-        });
-        const filter = {
-            condition: [
-                {
-                    DBName: docuwareInfo.findById,
-                    Value: [id]
-                }
-            ]
         };
 
-        return Self.get(code, filter, parse);
+        return {
+            url: docuwareConfig.url,
+            headers
+        };
     };
-
-    /**
-     * Returns docuware data filtered
-     *
-     * @param {array} data - The data
-     * @param {object} parse - The fields parsed
-     * @return {object} - The data parsed
-     */
-    function parser(data, parse) {
-        if (!(data && data.Items)) return data;
-
-        const parsed = [];
-        for (item of data.Items) {
-            const itemParsed = {};
-            item.Fields.map(field => {
-                if (field.ItemElementName.includes('Date')) field.Item = toDate(field.Item);
-                if (!parse) return itemParsed[field.FieldLabel] = field.Item;
-                if (parse[field.FieldLabel])
-                    itemParsed[parse[field.FieldLabel]] = field.Item;
-            });
-            parsed.push(itemParsed);
-        }
-        return parsed;
-    }
-
-    function toDate(value) {
-        if (!value) return;
-        return new Date(Number(value.substring(6, 19)));
-    }
 };

back/methods/docuware/deliveryNoteEmail.js

@@ -4,25 +4,25 @@ module.exports = Self => {
     Self.remoteMethodCtx('deliveryNoteEmail', {
         description: 'Sends the delivery note email with an docuware attached PDF',
         accessType: 'WRITE',
-        accessScopes: ['docuwareDeliveryNoteEmail'],
         accepts: [
             {
                 arg: 'id',
-                type: 'number',
+                type: 'string',
                 required: true,
                 description: 'The ticket id',
-            },
+                http: {source: 'path'}
-            {
-                arg: 'recipientId',
-                type: 'number',
-                description: 'The client id',
-                required: true
             },
             {
                 arg: 'recipient',
                 type: 'string',
                 description: 'The recipient email',
-                required: false,
+                required: true,
+            },
+            {
+                arg: 'recipientId',
+                type: 'number',
+                description: 'The client id',
+                required: false
             }
         ],
         returns: [
@@ -41,13 +41,12 @@ module.exports = Self => {
             }
         ],
         http: {
-            path: '/delivery-note-email',
+            path: '/:id/delivery-note-email',
             verb: 'POST'
         }
     });
 
-    Self.deliveryNoteEmail = async(ctx, id, recipientId, recipient) => {
+    Self.deliveryNoteEmail = async(ctx, id) => {
-        const models = Self.app.models;
         const args = Object.assign({}, ctx.args);
         const params = {
             recipient: args.recipient,
@@ -58,14 +57,9 @@ module.exports = Self => {
         for (const param in args)
             params[param] = args[param];
 
-        if (!recipient) {
-            client = await models.Client.findById(recipientId, {fields: ['email']});
-            params.recipient = client.email;
-        }
-
         const email = new Email('delivery-note', params);
 
-        const docuwareFile = await models.Docuware.download(id, 'deliveryNote');
+        const docuwareFile = await Self.app.models.Docuware.download(ctx, id, 'deliveryNote');
 
         return email.send({
             overrideAttachments: true,

back/methods/docuware/download.js

@@ -3,7 +3,7 @@ const axios = require('axios');
 const UserError = require('vn-loopback/util/user-error');
 
 module.exports = Self => {
-    Self.remoteMethod('download', {
+    Self.remoteMethodCtx('download', {
         description: 'Download an docuware PDF',
         accessType: 'READ',
         accepts: [
@@ -16,12 +16,8 @@ module.exports = Self => {
             {
                 arg: 'fileCabinet',
                 type: 'string',
-                description: 'The file cabinet'
+                description: 'The file cabinet',
-            },
+                http: {source: 'path'}
-            {
-                arg: 'filter',
-                type: 'object',
-                description: 'The filter'
             }
         ],
         returns: [
@@ -40,16 +36,14 @@ module.exports = Self => {
             }
         ],
         http: {
-            path: `/:id/download`,
+            path: `/:id/download/:fileCabinet`,
             verb: 'GET'
-        },
+        }
-        accessScopes: ['DEFAULT', 'read:multimedia']
     });
 
-    Self.download = async function(id, fileCabinet, filter) {
+    Self.download = async function(ctx, id, fileCabinet) {
         const models = Self.app.models;
-
+        const docuwareFile = await models.Docuware.checkFile(ctx, id, fileCabinet, true);
-        const docuwareFile = await models.Docuware.checkFile(id, fileCabinet, filter);
         if (!docuwareFile) throw new UserError('The DOCUWARE PDF document does not exists');
 
         const fileCabinetId = await Self.getFileCabinet(fileCabinet);

back/methods/docuware/specs/checkFile.spec.js

@@ -1,27 +1,81 @@
 const models = require('vn-loopback/server/server').models;
+const axios = require('axios');
 
 describe('docuware download()', () => {
     const ticketId = 1;
+    const userId = 9;
+    const ctx = {
+        req: {
+
+            accessToken: {userId: userId},
+            headers: {origin: 'http://localhost:5000'},
+        }
+    };
 
     const docuwareModel = models.Docuware;
     const fileCabinetName = 'deliveryNote';
 
-    it('should return false if there are no documents', async() => {
+    beforeAll(() => {
-        spyOn(docuwareModel, 'get').and.returnValue((new Promise(resolve => resolve({Items: []}))));
+        spyOn(docuwareModel, 'getFileCabinet').and.returnValue((new Promise(resolve => resolve(Math.random()))));
+        spyOn(docuwareModel, 'getDialog').and.returnValue((new Promise(resolve => resolve(Math.random()))));
+    });
 
-        const result = await models.Docuware.checkFile(ticketId, fileCabinetName, null, true);
+    it('should return false if there are no documents', async() => {
+        const response = {
+            data: {
+                Items: []
+            }
+        };
+        spyOn(axios, 'post').and.returnValue(new Promise(resolve => resolve(response)));
+
+        const result = await models.Docuware.checkFile(ctx, ticketId, fileCabinetName, true);
+
+        expect(result).toEqual(false);
+    });
+
+    it('should return false if the document is unsigned', async() => {
+        const response = {
+            data: {
+                Items: [
+                    {
+                        Id: 1,
+                        Fields: [
+                            {
+                                FieldName: 'ESTADO',
+                                Item: 'Unsigned'
+                            }
+                        ]
+                    }
+                ]
+            }
+        };
+        spyOn(axios, 'post').and.returnValue(new Promise(resolve => resolve(response)));
+
+        const result = await models.Docuware.checkFile(ctx, ticketId, fileCabinetName, true);
 
         expect(result).toEqual(false);
     });
 
     it('should return the document data', async() => {
         const docuwareId = 1;
-        const response = [{
+        const response = {
-            'Document ID': docuwareId
+            data: {
-        }];
+                Items: [
-        spyOn(docuwareModel, 'get').and.returnValue((new Promise(resolve => resolve(response))));
+                    {
+                        Id: docuwareId,
+                        Fields: [
+                            {
+                                FieldName: 'ESTADO',
+                                Item: 'Firmado'
+                            }
+                        ]
+                    }
+                ]
+            }
+        };
+        spyOn(axios, 'post').and.returnValue(new Promise(resolve => resolve(response)));
 
-        const result = await models.Docuware.checkFile(ticketId, fileCabinetName, null, true);
+        const result = await models.Docuware.checkFile(ctx, ticketId, fileCabinetName, true);
 
         expect(result.id).toEqual(docuwareId);
     });

back/methods/docuware/specs/core.spec.js

@@ -1,139 +0,0 @@
-const axios = require('axios');
-const models = require('vn-loopback/server/server').models;
-
-describe('Docuware core', () => {
-    const fileCabinetCode = 'deliveryNote';
-    beforeAll(async() => {
-        process.env.NODE_ENV = 'testing';
-
-        const docuwareInfo = await models.Docuware.findOne({
-            where: {
-                code: fileCabinetCode
-            }
-        });
-
-        spyOn(axios, 'get').and.callFake(url => {
-            if (url.includes('IdentityServiceInfo')) return {data: {IdentityServiceUrl: 'IdentityServiceUrl'}};
-            if (url.includes('IdentityServiceUrl')) return {data: {token_endpoint: 'token_endpoint'}};
-            if (url.includes('dialogs')) {
-                return {
-                    data: {
-                        Dialog: [
-                            {
-                                DisplayName: 'find',
-                                Id: 'getDialogTest'
-                            }
-                        ]
-                    }
-                };
-            }
-
-            if (url.includes('FileCabinets')) {
-                return {data: {
-                    FileCabinet: [
-                        {
-                            Name: docuwareInfo.fileCabinetName,
-                            Id: 'getFileCabinetTest'
-                        }
-                    ]
-                }};
-            }
-        });
-
-        spyOn(axios, 'post').and.callFake(url => {
-            if (url.includes('token_endpoint')) {
-                return {data: {
-                    access_token: 'access_token',
-                    token_type: 'bearer',
-                    expires_in: 10000
-                }};
-            }
-            if (url.includes('DialogExpression')) {
-                return {data: {
-                    Items: [{
-                        Fields: [
-                            {
-                                ItemElementName: 'integer',
-                                FieldLabel: 'firstRequiredField',
-                                Item: 1
-                            },
-                            {
-                                ItemElementName: 'string',
-                                FieldLabel: 'secondRequiredField',
-                                Item: 'myName'
-                            },
-                            {
-                                ItemElementName: 'integer',
-                                FieldLabel: 'notRequiredField',
-                                Item: 2
-                            }
-                        ]
-                    }]
-                }
-                };
-            }
-        });
-    });
-
-    afterAll(() => {
-        delete process.env.NODE_ENV;
-    });
-
-    describe('getOptions()', () => {
-        it('should return url and headers', async() => {
-            const result = await models.Docuware.getOptions();
-
-            expect(result.url).toBeDefined();
-            expect(result.headers).toBeDefined();
-        });
-    });
-
-    describe('Dialog()', () => {
-        it('should return dialogId', async() => {
-            const result = await models.Docuware.getDialog('deliveryNote', 'find', 'randomFileCabinetId');
-
-            expect(result).toEqual('getDialogTest');
-        });
-    });
-
-    describe('getFileCabinet()', () => {
-        it('should return fileCabinetId', async() => {
-            const result = await models.Docuware.getFileCabinet(fileCabinetCode);
-
-            expect(result).toEqual('getFileCabinetTest');
-        });
-    });
-
-    describe('get()', () => {
-        it('should return data without parse', async() => {
-            const [result] = await models.Docuware.get('deliveryNote');
-
-            expect(result.firstRequiredField).toEqual(1);
-        });
-
-        it('should return data with parse', async() => {
-            const parse = {
-                'firstRequiredField': 'id',
-                'secondRequiredField': 'name',
-            };
-            const [result] = await models.Docuware.get('deliveryNote', null, parse);
-
-            expect(result.id).toEqual(1);
-            expect(result.name).toEqual('myName');
-            expect(result.notRequiredField).not.toBeDefined();
-        });
-    });
-
-    describe('getById()', () => {
-        it('should return data', async() => {
-            spyOn(models.Docuware, 'get');
-            await models.Docuware.getById('deliveryNote', 1);
-
-            expect(models.Docuware.get).toHaveBeenCalledWith(
-                'deliveryNote',
-                {condition: [Object({DBName: 'N__ALBAR_N', Value: [1]})]},
-                undefined
-            );
-        });
-    });
-});

back/methods/docuware/specs/download.spec.js

@@ -39,7 +39,7 @@ describe('docuware download()', () => {
         spyOn(docuwareModel, 'checkFile').and.returnValue({});
         spyOn(axios, 'get').and.returnValue(new stream.PassThrough({objectMode: true}));
 
-        const result = await models.Docuware.download(ticketId, fileCabinetName);
+        const result = await models.Docuware.download(ctx, ticketId, fileCabinetName);
 
         expect(result[1]).toEqual('application/pdf');
         expect(result[2]).toEqual(`filename="${ticketId}.pdf"`);

back/methods/docuware/specs/upload.spec.js

@@ -2,9 +2,8 @@ const models = require('vn-loopback/server/server').models;
 
 describe('docuware upload()', () => {
     const userId = 9;
-    const ticketIds = [10];
+    const ticketId = 10;
     const ctx = {
-        args: {ticketIds},
         req: {
             getLocale: () => {
                 return 'en';
@@ -24,40 +23,15 @@ describe('docuware upload()', () => {
     });
 
     it('should try upload file', async() => {
-        const tx = await models.Docuware.beginTransaction({});
         spyOn(ticketModel, 'deliveryNotePdf').and.returnValue(new Promise(resolve => resolve({})));
 
         let error;
         try {
-            const options = {transaction: tx};
+            await models.Docuware.upload(ctx, ticketId, fileCabinetName);
-            const user = await models.UserConfig.findById(userId, null, options);
-            await user.updateAttribute('tabletFk', 'Tablet1', options);
-            await models.Docuware.upload(ctx, ticketIds, fileCabinetName, options);
-
-            await tx.rollback();
         } catch (e) {
-            error = e;
+            error = e.message;
-            await tx.rollback();
         }
 
-        expect(error.message).toEqual('Action not allowed on the test environment');
+        expect(error).toEqual('Action not allowed on the test environment');
-    });
-
-    it('should throw error when not have tablet assigned', async() => {
-        const tx = await models.Docuware.beginTransaction({});
-        spyOn(ticketModel, 'deliveryNotePdf').and.returnValue(new Promise(resolve => resolve({})));
-
-        let error;
-        try {
-            const options = {transaction: tx};
-            await models.Docuware.upload(ctx, ticketIds, fileCabinetName, options);
-
-            await tx.rollback();
-        } catch (e) {
-            error = e;
-            await tx.rollback();
-        }
-
-        expect(error.message).toEqual('This user does not have an assigned tablet');
     });
 });

back/methods/docuware/upload.js

@@ -1,164 +1,141 @@
 const UserError = require('vn-loopback/util/user-error');
 const axios = require('axios');
-const isProduction = require('vn-loopback/server/boot/isProduction');
 
 module.exports = Self => {
     Self.remoteMethodCtx('upload', {
-        description: 'Upload docuware PDFs',
+        description: 'Upload an docuware PDF',
         accessType: 'WRITE',
         accepts: [
             {
-                arg: 'ticketIds',
+                arg: 'id',
-                type: ['number'],
+                type: 'number',
-                description: 'The ticket ids',
+                description: 'The ticket id',
-                required: true
+                http: {source: 'path'}
             },
             {
                 arg: 'fileCabinet',
                 type: 'string',
-                description: 'The file cabinet',
+                description: 'The file cabinet'
-                required: true
+            },
+            {
+                arg: 'dialog',
+                type: 'string',
+                description: 'The dialog'
             }
         ],
-        returns: {
+        returns: [],
-            type: 'object',
-            root: true
-        },
         http: {
-            path: `/upload`,
+            path: `/:id/upload`,
             verb: 'POST'
         }
     });
 
-    Self.upload = async function(ctx, ticketIds, fileCabinet, options) {
+    Self.upload = async function(ctx, id, fileCabinet) {
-        delete ctx.args.ticketIds;
         const models = Self.app.models;
         const action = 'store';
 
-        const myOptions = {};
+        const options = await Self.getOptions();
-
-        if (typeof options == 'object')
-            Object.assign(myOptions, options);
-
-        const userConfig = await models.UserConfig.findById(ctx.req.accessToken.userId, {
-            fields: ['tabletFk']
-        }, myOptions);
-
-        if (!userConfig?.tabletFk)
-            throw new UserError('This user does not have an assigned tablet');
-
-        const docuwareOptions = await Self.getOptions();
         const fileCabinetId = await Self.getFileCabinet(fileCabinet);
         const dialogId = await Self.getDialog(fileCabinet, action, fileCabinetId);
 
-        const uploaded = [];
+        // get delivery note
-        for (id of ticketIds) {
+        const deliveryNote = await models.Ticket.deliveryNotePdf(ctx, {
-            // get delivery note
+            id,
-            ctx.args.id = id;
+            type: 'deliveryNote'
-            const deliveryNote = await models.Ticket.deliveryNotePdf(ctx, {
+        });
-                id,
-                type: 'deliveryNote'
-            }, myOptions);
-            // get ticket data
-            const ticket = await models.Ticket.findById(id, {
-                include: [{
-                    relation: 'client',
-                    scope: {
-                        fields: ['id', 'name', 'fi']
-                    }
-                }]
-            }, myOptions);
 
-            // upload file
+        // get ticket data
-            const templateJson = {
+        const ticket = await models.Ticket.findById(id, {
-                'Fields': [
+            include: [{
-                    {
+                relation: 'client',
-                        'FieldName': 'N__ALBAR_N',
+                scope: {
-                        'ItemElementName': 'string',
+                    fields: ['id', 'socialName', 'fi']
-                        'Item': id,
+                }
-                    },
+            }]
-                    {
+        });
-                        'FieldName': 'CIF_PROVEEDOR',
-                        'ItemElementName': 'string',
-                        'Item': ticket.client().fi,
-                    },
-                    {
-                        'FieldName': 'CODIGO_PROVEEDOR',
-                        'ItemElementName': 'string',
-                        'Item': ticket.client().id,
-                    },
-                    {
-                        'FieldName': 'NOMBRE_PROVEEDOR',
-                        'ItemElementName': 'string',
-                        'Item': ticket.client().name + ' - ' + id,
-                    },
-                    {
-                        'FieldName': 'FECHA_FACTURA',
-                        'ItemElementName': 'date',
-                        'Item': ticket.shipped,
-                    },
-                    {
-                        'FieldName': 'TOTAL_FACTURA',
-                        'ItemElementName': 'Decimal',
-                        'Item': ticket.totalWithVat,
-                    },
-                    {
-                        'FieldName': 'ESTADO',
-                        'ItemElementName': 'string',
-                        'Item': 'Pendiente procesar',
-                    },
-                    {
-                        'FieldName': 'FIRMA_',
-                        'ItemElementName': 'string',
-                        'Item': 'Si',
-                    },
-                    {
-                        'FieldName': 'FILTRO_TABLET',
-                        'ItemElementName': 'string',
-                        'Item': userConfig.tabletFk,
-                    }
-                ]
-            };
 
-            if (!isProduction(false))
+        // upload file
-                throw new UserError('Action not allowed on the test environment');
+        const templateJson = {
-
+            'Fields': [
-            // delete old
+                {
-            const docuwareFile = await models.Docuware.checkFile(id, fileCabinet, false);
+                    'FieldName': 'N__ALBAR_N',
-            if (docuwareFile) {
+                    'ItemElementName': 'string',
-                const deleteJson = {
+                    'Item': id,
-                    'Field': [{'FieldName': 'ESTADO', 'Item': 'Pendiente eliminar', 'ItemElementName': 'String'}]
-                };
-                const deleteUri = `${docuwareOptions.url}/FileCabinets/${fileCabinetId}/Documents/${docuwareFile.id}/Fields`;
-                await axios.put(deleteUri, deleteJson, docuwareOptions.headers);
-            }
-
-            const uploadUri = `${docuwareOptions.url}/FileCabinets/${fileCabinetId}/Documents?StoreDialogId=${dialogId}`;
-            const FormData = require('form-data');
-            const data = new FormData();
-
-            data.append('document', JSON.stringify(templateJson), 'schema.json');
-            data.append('file[]', deliveryNote[0], 'file.pdf');
-            const uploadOptions = {
-                headers: {
-                    'Content-Type': 'multipart/form-data',
-                    'X-File-ModifiedDate': Date.vnNew(),
-                    'Authorization': docuwareOptions.headers.headers.Authorization,
-                    ...data.getHeaders()
                 },
-            };
+                {
+                    'FieldName': 'CIF_PROVEEDOR',
+                    'ItemElementName': 'string',
+                    'Item': ticket.client().fi,
+                },
+                {
+                    'FieldName': 'CODIGO_PROVEEDOR',
+                    'ItemElementName': 'string',
+                    'Item': ticket.client().id,
+                },
+                {
+                    'FieldName': 'NOMBRE_PROVEEDOR',
+                    'ItemElementName': 'string',
+                    'Item': ticket.client().socialName,
+                },
+                {
+                    'FieldName': 'FECHA_FACTURA',
+                    'ItemElementName': 'date',
+                    'Item': ticket.shipped,
+                },
+                {
+                    'FieldName': 'TOTAL_FACTURA',
+                    'ItemElementName': 'Decimal',
+                    'Item': ticket.totalWithVat,
+                },
+                {
+                    'FieldName': 'ESTADO',
+                    'ItemElementName': 'string',
+                    'Item': 'Pendiente procesar',
+                },
+                {
+                    'FieldName': 'FIRMA_',
+                    'ItemElementName': 'string',
+                    'Item': 'Si',
+                },
+                {
+                    'FieldName': 'FILTRO_TABLET',
+                    'ItemElementName': 'string',
+                    'Item': 'Tablet1',
+                }
+            ]
+        };
 
-            try {
+        if (process.env.NODE_ENV != 'production')
-                await axios.post(uploadUri, data, uploadOptions);
+            throw new UserError('Action not allowed on the test environment');
-            } catch (err) {
+
-                const $t = ctx.req.__;
+        // delete old
-                const message = $t('Failed to upload delivery note', {id});
+        const docuwareFile = await models.Docuware.checkFile(ctx, id, fileCabinet, false);
-                if (uploaded.length)
+        if (docuwareFile) {
-                    await models.TicketTracking.setDelivered(ctx, uploaded, myOptions);
+            const deleteJson = {
-                throw new UserError(message);
+                'Field': [{'FieldName': 'ESTADO', 'Item': 'Pendiente eliminar', 'ItemElementName': 'String'}]
-            }
+            };
-            uploaded.push(id);
+            const deleteUri = `${options.url}/FileCabinets/${fileCabinetId}/Documents/${docuwareFile.id}/Fields`;
+            await axios.put(deleteUri, deleteJson, options.headers);
         }
-        return models.TicketTracking.setDelivered(ctx, ticketIds, myOptions);
+
+        const uploadUri = `${options.url}/FileCabinets/${fileCabinetId}/Documents?StoreDialogId=${dialogId}`;
+        const FormData = require('form-data');
+        const data = new FormData();
+
+        data.append('document', JSON.stringify(templateJson), 'schema.json');
+        data.append('file[]', deliveryNote[0], 'file.pdf');
+        const uploadOptions = {
+            headers: {
+                'Content-Type': 'multipart/form-data',
+                'X-File-ModifiedDate': Date.vnNew(),
+                'Cookie': options.headers.headers.Cookie,
+                ...data.getHeaders()
+            },
+        };
+
+        return await axios.post(uploadUri, data, uploadOptions)
+            .catch(() => {
+                throw new UserError('Failed to upload file');
+            });
     };
 };

back/methods/edi/sql/item.sql

@@ -1,9 +1,9 @@
 LOAD DATA LOCAL INFILE ?
 	INTO TABLE `edi`.`item`
-	CHARACTER SET ascii
 	FIELDS TERMINATED BY ';'
 	LINES TERMINATED BY '\n' (@col1, @col2, @col3, @col4, @col5, @col6, @col7, @col8, @col9, @col10, @col11, @col12)
-	SET id = @col2,
+	SET
+		id = @col2,
 		product_name = @col4,
 		name = @col5,
 		plant_id = @col7,
@@ -11,4 +11,3 @@ LOAD DATA LOCAL INFILE ?
 		entry_date = STR_TO_DATE(@col10, '%Y%m%d'),
 		expiry_date = IFNULL(NULL,STR_TO_DATE(@col11, '%Y%m%d')),
 		change_date_time = STR_TO_DATE(@col12, '%Y%m%d%H%i')
-		

back/methods/edi/updateData.js

@@ -16,15 +16,15 @@ module.exports = Self => {
         }
     });
 
-    Self.updateData = async ctx => {
+    Self.updateData = async() => {
         const models = Self.app.models;
 
         // Get files checksum
         const tx = await Self.beginTransaction({});
 
         try {
-            const options = {transaction: tx, userId: ctx.req.accessToken.userId};
+            const options = {transaction: tx};
-            const files = await Self.rawSql('SELECT name, checksum, keyValue FROM edi.fileMultiConfig', null, options);
+            const files = await Self.rawSql('SELECT name, checksum, keyValue FROM edi.fileConfig', null, options);
 
             const updatableFiles = [];
             for (const file of files) {
@@ -53,9 +53,9 @@ module.exports = Self => {
             const fileNames = updatableFiles.map(file => file.name);
 
             const tables = await Self.rawSql(`
-				SELECT fileName, toTable, file
+                SELECT fileName, toTable, file
-					FROM edi.tableMultiConfig
+                    FROM edi.tableConfig
-				WHERE file IN (?)`, [fileNames], options);
+                WHERE file IN (?)`, [fileNames], options);
 
             for (const table of tables) {
                 const fileName = table.file;
@@ -85,9 +85,9 @@ module.exports = Self => {
             for (const file of updatableFiles) {
                 console.log(`Updating file ${file.name} checksum...`);
                 await Self.rawSql(`
-                    UPDATE edi.fileMultiConfig
+                        UPDATE edi.fileConfig
-                        SET checksum = ?
+                            SET checksum = ?
-                    WHERE name = ?`,
+                        WHERE name = ?`,
                 [file.checksum, file.name], options);
             }
 
@@ -121,8 +121,7 @@ module.exports = Self => {
                 host: ftpConfig.host,
                 username: ftpConfig.user,
                 password: ftpConfig.password,
-                procotol: 'ftp',
+                procotol: 'ftp'
-                additionalLftpCommands: 'set ssl:verify-certificate no'
             });
         }
 
@@ -133,13 +132,13 @@ module.exports = Self => {
         const ftpClient = await getFtpClient();
         console.debug(`Checking checksum for file ${file.name}...`);
 
-        ftpClient.cat(`codes/${file.name}.TXT`);
+        ftpClient.cat(`codes/${file.name}.txt`);
 
         const response = await new Promise((resolve, reject) => {
             ftpClient.exec((err, response) => {
                 if (err || response.error) {
                     console.debug(`Error downloading checksum file... ${response.error}`);
-                    return reject(response.error || err);
+                    return reject(err);
                 }
 
                 resolve(response);
@@ -228,10 +227,10 @@ module.exports = Self => {
 
             await Self.rawSql(sqlTemplate, [filePath], options);
             await Self.rawSql(`
-						UPDATE edi.tableMultiConfig
+                        UPDATE edi.tableConfig
-							SET updated = ?
+                            SET updated = ?
-						WHERE fileName = ?
+                        WHERE fileName = ?
-				`, [Date.vnNew(), baseName], options);
+                `, [Date.vnNew(), baseName], options);
         }
 
         console.log(`Updated table ${toTable}\n`);

back/methods/image/download.js

@@ -47,8 +47,7 @@ module.exports = Self => {
         http: {
             path: `/:collection/:size/:id/download`,
             verb: 'GET'
-        },
+        }
-        accessScopes: ['DEFAULT', 'read:multimedia']
     });
 
     Self.download = async function(ctx, collection, size, id) {
@@ -68,7 +67,7 @@ module.exports = Self => {
 
         if (!image) return false;
 
-        const hasReadRole = await models.ImageCollection.hasReadRole(ctx, collection);
+        const hasReadRole = models.ImageCollection.hasReadRole(ctx, collection);
         if (!hasReadRole)
             throw new UserError(`You don't have enough privileges`);
 
@@ -88,6 +87,6 @@ module.exports = Self => {
 
         await fs.access(file.path);
         const stream = fs.createReadStream(file.path);
-        return [stream, file.contentType, `filename="${fileName}"`];
+        return [stream, file.contentType, `filename="${file.name}"`];
     };
 };

back/methods/image/scrub.js

@@ -1,130 +0,0 @@
-const fs = require('fs-extra');
-const path = require('path');
-const UserError = require('vn-loopback/util/user-error');
-const isProduction = require('vn-loopback/server/boot/isProduction');
-
-module.exports = Self => {
-    Self.remoteMethod('scrub', {
-        description: 'Deletes images without database reference',
-        accessType: 'WRITE',
-        accepts: [
-            {
-                arg: 'collection',
-                type: 'string',
-                description: 'The collection name',
-                required: true
-            }, {
-                arg: 'remove',
-                type: 'boolean',
-                description: 'Delete instead of move images to trash'
-            }, {
-                arg: 'limit',
-                type: 'integer',
-                description: 'Maximum number of images to clean'
-            }, {
-                arg: 'dryRun',
-                type: 'boolean',
-                description: 'Simulate actions'
-            }, {
-                arg: 'skipLock',
-                type: 'boolean',
-                description: 'Wether to skip exclusive lock'
-            }
-        ],
-        returns: {
-            type: 'integer',
-            root: true
-        },
-        http: {
-            path: `/scrub`,
-            verb: 'POST'
-        }
-    });
-
-    Self.scrub = async function(collection, remove, limit, dryRun, skipLock) {
-        const $ = Self.app.models;
-
-        dryRun = dryRun || !isProduction(false);
-
-        const instance = await $.ImageCollection.findOne({
-            fields: ['id'],
-            where: {name: collection}
-        });
-        if (!instance)
-            throw new UserError('Collection does not exist');
-
-        const container = await $.ImageContainer.container(collection);
-        const rootPath = container.client.root;
-
-        let tx;
-        let opts;
-        const lockName = 'salix.Image.scrub';
-
-        if (!skipLock) {
-            tx = await Self.beginTransaction({timeout: null});
-            opts = {transaction: tx};
-
-            const [row] = await Self.rawSql(
-                `SELECT GET_LOCK(?, 10) hasLock`, [lockName], opts);
-            if (!row.hasLock)
-                throw new UserError('Cannot obtain exclusive lock');
-        }
-
-        try {
-            const now = Date.vnNew().toJSON();
-            const scrubDir = path.join(rootPath, '.scrub', now);
-
-            const collectionDir = path.join(rootPath, collection);
-            const sizes = await fs.readdir(collectionDir);
-            let cleanCount = 0;
-
-            mainLoop: for (const size of sizes) {
-                const sizeDir = path.join(collectionDir, size);
-                const scrubSizeDir = path.join(scrubDir, collection, size);
-                const images = await fs.readdir(sizeDir);
-                for (const image of images) {
-                    const imageName = path.parse(image).name;
-                    const count = await Self.count({
-                        collectionFk: collection,
-                        name: imageName
-                    }, opts);
-                    const exists = count > 0;
-                    let scrubDirCreated = false;
-                    if (!exists) {
-                        const srcFile = path.join(sizeDir, image);
-                        if (remove !== true) {
-                            if (!scrubDirCreated) {
-                                if (!dryRun)
-                                    await fs.mkdir(scrubSizeDir, {recursive: true});
-                                scrubDirCreated = true;
-                            }
-                            const dstFile = path.join(scrubSizeDir, image);
-                            if (!dryRun) await fs.rename(srcFile, dstFile);
-                        } else {
-                            try {
-                                if (!dryRun) await fs.unlink(srcFile);
-                            } catch (err) {
-                                console.error(err.message);
-                            }
-                        }
-
-                        cleanCount++;
-                        if (limit && cleanCount == limit)
-                            break mainLoop;
-                    }
-                }
-            }
-
-            return cleanCount;
-        } finally {
-            if (!skipLock) {
-                try {
-                    await Self.rawSql(`DO RELEASE_LOCK(?)`, [lockName], opts);
-                    await tx.rollback();
-                } catch (err) {
-                    console.error(err.message);
-                }
-            }
-        }
-    };
-};

back/methods/image/specs/download.spec.js

@@ -4,21 +4,20 @@ describe('image download()', () => {
     const collection = 'user';
     const size = '160x160';
     const employeeId = 1;
-    const developerId = 9;
-    const jessicaJonesId = 1110;
     const ctx = {req: {accessToken: {userId: employeeId}}};
 
     it('should return the image content-type of the user', async() => {
-        const image = await models.Image.download(ctx, collection, size, developerId);
+        const userId = 9;
+        const image = await models.Image.download(ctx, collection, size, userId);
         const contentType = image[1];
 
         expect(contentType).toEqual('image/png');
     });
 
-    it('should return the user profile picture', async() => {
+    it(`should return false if the user doesn't have image`, async() => {
-        const image = await models.Image.download(ctx, collection, size, jessicaJonesId);
+        const userId = 1110;
-        const fileName = image[2];
+        const image = await models.Image.download(ctx, collection, size, userId);
 
-        expect(fileName).toMatch('1110.png');
+        expect(image).toBeFalse();
     });
 });

back/methods/image/specs/upload.spec.js

@@ -95,7 +95,10 @@ describe('image upload()', () => {
             spyOn(containerModel, 'upload');
 
             const ctx = {req: {accessToken: {userId: hhrrId}},
-                args: {id: itemId, collection: 'user'}
+                args: {
+                    id: itemId,
+                    collection: 'user'
+                }
             };
 
             try {
@@ -106,7 +109,7 @@ describe('image upload()', () => {
         });
 
         it('should try to upload a file for the collection "catalog" and throw a privilege error', async() => {
-            const ctx = {req: {accessToken: {userId: 1}},
+            const ctx = {req: {accessToken: {userId: hhrrId}},
                 args: {
                     id: workerId,
                     collection: 'catalog'

back/methods/image/upload.js

@@ -1,7 +1,6 @@
 const UserError = require('vn-loopback/util/user-error');
 const fs = require('fs/promises');
 const path = require('path');
-const isProduction = require('vn-loopback/server/boot/isProduction');
 
 module.exports = Self => {
     Self.remoteMethodCtx('upload', {
@@ -13,13 +12,13 @@ module.exports = Self => {
                 type: 'Number',
                 description: 'The entity id',
                 required: true
-            }, {
+            },
+            {
                 arg: 'collection',
                 type: 'string',
                 description: 'The collection name',
                 required: true
-            }
+            }],
-        ],
         returns: {
             type: 'Object',
             root: true
@@ -42,7 +41,7 @@ module.exports = Self => {
             if (!hasWriteRole)
                 throw new UserError(`You don't have enough privileges`);
 
-            if (!isProduction())
+            if (process.env.NODE_ENV == 'test')
                 throw new UserError(`Action not allowed on the test environment`);
 
             // Upload file to temporary path

back/methods/mobile-app-version-control/getVersion.js

@@ -1,50 +0,0 @@
-module.exports = Self => {
-    Self.remoteMethodCtx('getVersion', {
-        description: 'gets app version data',
-        accessType: 'READ',
-        accepts: [{
-            arg: 'app',
-            type: 'string',
-            required: true
-        }],
-        returns: {
-            type: ['object'],
-            root: true
-        },
-        http: {
-            path: `/getVersion`,
-            verb: 'GET'
-        }
-    });
-
-    Self.getVersion = async(ctx, app) => {
-        const {models} = Self.app;
-        const userId = ctx.req.accessToken.userId;
-
-        const workerFk = await models.WorkerAppTester.findOne({
-            where: {
-                workerFk: userId
-            }
-        });
-        let fields = ['id', 'appName'];
-
-        if (workerFk)
-            fields = fields.concat(['isVersionBetaCritical', 'versionBeta', 'urlBeta']);
-        else
-            fields = fields.concat(['isVersionCritical', 'version', 'urlProduction']);
-
-        const filter = {
-            where: {
-                appName: app
-            },
-            fields,
-        };
-
-        const result = await Self.findOne(filter);
-        return {
-            isVersionCritical: result?.isVersionBetaCritical ?? result?.isVersionCritical,
-            version: result?.versionBeta ?? result?.version,
-            url: result?.urlBeta ?? result?.urlProduction
-        };
-    };
-};

back/methods/mobile-app-version-control/specs/getVersion.spec.js

@@ -1,29 +0,0 @@
-const {models} = require('vn-loopback/server/server');
-
-describe('mobileAppVersionControl getVersion()', () => {
-    const appName = 'delivery';
-    const appNameVersion = '9.2';
-    const appNameVersionBeta = '9.7';
-    beforeAll(async() => {
-        ctx = {
-            req: {
-                accessToken: {},
-                headers: {origin: 'http://localhost'},
-            }
-        };
-    });
-
-    it('should get the version app', async() => {
-        ctx.req.accessToken.userId = 9;
-        const {version} = await models.MobileAppVersionControl.getVersion(ctx, appName);
-
-        expect(version).toEqual(appNameVersion);
-    });
-
-    it('should get the beta version app', async() => {
-        ctx.req.accessToken.userId = 66;
-        const {version} = await models.MobileAppVersionControl.getVersion(ctx, appName);
-
-        expect(version).toEqual(appNameVersionBeta);
-    });
-});

back/methods/mrw-config/cancelShipment.ejs

@@ -1,20 +0,0 @@
-<soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope" xmlns:mrw="http://www.mrw.es/">
-    <soap:Header>
-        <mrw:AuthInfo>
-            <mrw:CodigoFranquicia><%= mrw.franchiseCode %></mrw:CodigoFranquicia>
-            <mrw:CodigoAbonado><%= clientType %></mrw:CodigoAbonado>
-            <mrw:CodigoDepartamento/>
-            <mrw:UserName><%= mrw.user %></mrw:UserName>
-            <mrw:Password><%= mrw.password %></mrw:Password>
-        </mrw:AuthInfo>
-    </soap:Header>
-        <soap:Body>
-            <mrw:CancelarEnvio>
-                <mrw:request>
-                    <mrw:CancelaEnvio>
-                        <mrw:NumeroEnvioOriginal><%= externalId %></mrw:NumeroEnvioOriginal>
-                    </mrw:CancelaEnvio>
-                </mrw:request>
-            </mrw:CancelarEnvio>
-        </soap:Body>
-</soap:Envelope>

back/methods/mrw-config/cancelShipment.js

@@ -1,48 +0,0 @@
-const axios = require('axios');
-const fs = require('fs');
-const ejs = require('ejs');
-const {DOMParser} = require('xmldom');
-
-module.exports = Self => {
-    Self.remoteMethod('cancelShipment', {
-        description: 'Cancel a shipment by providing the expedition ID, interacting with MRW WebService',
-        accessType: 'WRITE',
-        accepts: [{
-            arg: 'expeditionFk',
-            type: 'number',
-            required: true
-        }],
-        returns: {
-            type: 'boolean',
-            root: true
-        },
-        http: {
-            path: `/cancelShipment`,
-            verb: 'POST'
-        }
-    });
-
-    Self.cancelShipment = async expeditionFk => {
-        const models = Self.app.models;
-        const mrw = await models.MrwConfig.findOne();
-        const {externalId} = await models.Expedition.findById(expeditionFk);
-        const clientType = await models.MrwConfig.getClientType(expeditionFk);
-        const template = fs.readFileSync(__dirname + '/cancelShipment.ejs', 'utf-8');
-        const renderedXml = ejs.render(template, {mrw, externalId, clientType});
-
-        await Self.rawSql('CALL util.debugAdd(?,?);', ['cancelShipment', renderedXml]);
-        const response = await axios.post(mrw.url, renderedXml, {
-            headers: {
-                'Content-Type': 'application/soap+xml; charset=utf-8'
-            }
-        });
-
-        const xmlString = response.data;
-        await Self.rawSql('CALL util.debugAdd(?,?);', ['cancelShipmentResponse', xmlString]);
-        const parser = new DOMParser();
-        const xmlDoc = parser.parseFromString(xmlString, 'text/xml');
-
-        const result = xmlDoc.getElementsByTagName('Mensaje')[0].textContent;
-        return ['no se ha encontrado', 'se ha cancelado correctamente'].some(res => result.toLowerCase().includes(res));
-    };
-};

back/methods/mrw-config/createShipment.ejs

@@ -1,51 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope" xmlns:mrw="http://www.mrw.es/">
-    <soap:Header>
-        <mrw:AuthInfo>
-            <mrw:CodigoFranquicia><%= mrw.franchiseCode %></mrw:CodigoFranquicia>
-            <mrw:CodigoAbonado><%= clientType %></mrw:CodigoAbonado>
-            <mrw:CodigoDepartamento/>
-            <mrw:UserName><%= mrw.user %></mrw:UserName>
-            <mrw:Password><%= mrw.password %></mrw:Password>
-        </mrw:AuthInfo>
-    </soap:Header>
-    <soap:Body>
-        <mrw:TransmEnvio>
-            <mrw:request>
-                <mrw:DatosEntrega>
-                    <mrw:Direccion>
-                        <mrw:CodigoTipoVia/>
-                        <mrw:Via><%= expeditionData.street %></mrw:Via>
-                        <mrw:Numero/>
-                        <mrw:Resto/>
-                        <mrw:CodigoPostal><%= expeditionData.postalCode %></mrw:CodigoPostal>
-                        <mrw:Poblacion><%= expeditionData.city %></mrw:Poblacion>
-                        <mrw:Provincia/>
-                        <mrw:CodigoPais/>
-                    </mrw:Direccion>
-                    <mrw:Nif><%= expeditionData.fi %></mrw:Nif>
-                    <mrw:Nombre><%= expeditionData.clientName %></mrw:Nombre>
-                    <mrw:Telefono><%= expeditionData.mobile %></mrw:Telefono>
-                    <mrw:Observaciones><%= expeditionData.deliveryObservation %></mrw:Observaciones>
-                </mrw:DatosEntrega>
-                <mrw:DatosServicio>
-                    <mrw:Fecha><%= expeditionData.created %></mrw:Fecha>
-                    <mrw:Referencia><%= expeditionData.reference %></mrw:Referencia>
-                    <mrw:CodigoServicio><%= expeditionData.serviceType %></mrw:CodigoServicio>
-                    <mrw:NumeroBultos>1</mrw:NumeroBultos>
-                    <mrw:EntregaSabado><%= expeditionData.weekDays %></mrw:EntregaSabado>
-                    <mrw:Reembolso/>
-                    <mrw:ImporteReembolso/>
-                    <mrw:Bultos>
-                        <mrw:BultoRequest>
-                            <mrw:Alto><%= mrw.defaultHeight %></mrw:Alto>
-                            <mrw:Largo><%= mrw.defaultLength %></mrw:Largo>
-                            <mrw:Ancho><%= mrw.defaultWidth %></mrw:Ancho>
-                            <mrw:Peso><%= mrw.defaultWeight %></mrw:Peso>
-                        </mrw:BultoRequest>
-                    </mrw:Bultos>
-                </mrw:DatosServicio>
-            </mrw:request>
-        </mrw:TransmEnvio>
-    </soap:Body>
-</soap:Envelope>

back/methods/mrw-config/createShipment.js

@@ -1,91 +0,0 @@
-const UserError = require('vn-loopback/util/user-error');
-
-module.exports = Self => {
-    Self.remoteMethod('createShipment', {
-        description: 'Create an expedition and return a base64Binary label from de MRW WebService',
-        accessType: 'WRITE',
-        accepts: [{
-            arg: 'expeditionFk',
-            type: 'number',
-            required: true
-        }],
-        returns: {
-            type: ['object'],
-            root: true
-        },
-        http: {
-            path: `/createShipment`,
-            verb: 'POST'
-        }
-    });
-
-    Self.createShipment = async expeditionFk => {
-        const models = Self.app.models;
-        const mrw = await Self.getConfig();
-        const clientType = await models.MrwConfig.getClientType(expeditionFk);
-
-        const today = Date.vnNew();
-        const [hours, minutes] = mrw?.expeditionDeadLine ? mrw.expeditionDeadLine.split(':').map(Number) : [0, 0];
-
-        const deadLine = Date.vnNew();
-        deadLine.setHours(hours, minutes, 0);
-
-        if (today > deadLine && (!mrw.notified || mrw.notified.setHours(0, 0, 0, 0) !== today.setHours(0, 0, 0, 0))) {
-            await models.NotificationQueue.create({notificationFk: 'mrw-deadline'});
-            await mrw.updateAttributes({notified: Date.vnNow()});
-        }
-
-        const query =
-            `SELECT 
-                CASE co.code 
-                    WHEN 'ES' THEN a.postalCode
-                    WHEN 'PT' THEN LEFT(a.postalCode, mc.portugalPostCodeTrim)
-                    WHEN 'AD' THEN REPLACE(a.postalCode, 'AD', '00')
-                END postalCode,
-                a.city,
-                a.street,
-                co.code countryCode,
-                c.fi,
-                c.name clientName,
-                IFNULL(a.mobile, c.mobile) mobile,
-                DATE_FORMAT(t.shipped, '%d/%m/%Y') created,
-                t.shipped,
-                CONCAT( e.ticketFk, LPAD(e.counter, mc.counterWidth, '0')) reference,
-                LPAD(IF(mw.serviceType IS NULL, ms.serviceType, mw.serviceType), mc.serviceTypeWidth, '0') serviceType,
-                IF(mw.weekdays, 'S', 'N') weekDays,
-                ta.description deliveryObservation
-            FROM expedition e
-                JOIN ticket t ON e.ticketFk = t.id
-                JOIN agencyMode am ON am.id = t.agencyModeFk
-                JOIN mrwService ms ON ms.agencyModeCodeFk = am.code
-                LEFT JOIN mrwServiceWeekday mw ON mw.agencyModeCodeFk = am.code
-                    AND mw.weekDays & (1 << WEEKDAY(t.landed)) 
-                JOIN client c ON t.clientFk = c.id
-                JOIN address a ON t.addressFk = a.id
-                LEFT JOIN ticketObservation ta ON ta.ticketFk = t.id
-                    AND ta.observationTypeFk IN (SELECT id FROM observationType ot WHERE ot.code = 'agency')
-                JOIN province p ON a.provinceFk = p.id
-                JOIN country co ON co.id = p.countryFk
-                JOIN mrwConfig mc
-            WHERE e.id = ?
-            LIMIT 1`;
-
-        const [expeditionData] = await Self.rawSql(query, [expeditionFk]);
-
-        if (expeditionData?.shipped.setHours(0, 0, 0, 0) < today.setHours(0, 0, 0, 0))
-            throw new UserError(`This ticket has a shipped date earlier than today`);
-
-        const shipmentResponse = await Self.sendXmlDoc(
-            __dirname + `/createShipment.ejs`,
-            {mrw, expeditionData, clientType},
-            'application/soap+xml'
-        );
-        const shipmentId = Self.getTextByTag(shipmentResponse, 'NumeroEnvio');
-
-        if (!shipmentId) throw new UserError(Self.getTextByTag(shipmentResponse, 'Mensaje'));
-
-        const file = await models.MrwConfig.getLabel(shipmentId, clientType);
-
-        return {shipmentId, file};
-    };
-};

back/methods/mrw-config/getLabel.ejs

@@ -1,25 +0,0 @@
-<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:mrw="http://www.mrw.es/">
-    <soapenv:Header>
-        <mrw:AuthInfo>
-            <mrw:CodigoFranquicia><%= mrw.franchiseCode %></mrw:CodigoFranquicia>
-            <mrw:CodigoAbonado><%= clientType %></mrw:CodigoAbonado>
-            <mrw:CodigoDepartamento/>
-            <mrw:UserName><%= mrw.user %></mrw:UserName>
-            <mrw:Password><%= mrw.password %></mrw:Password>
-        </mrw:AuthInfo>
-    </soapenv:Header>
-    <soapenv:Body>
-        <mrw:GetEtiquetaEnvio>
-            <mrw:request>
-                <mrw:NumeroEnvio><%= shipmentId %></mrw:NumeroEnvio>
-                <mrw:NumerosEtiqueta>1</mrw:NumerosEtiqueta>
-                <mrw:SeparadorNumerosEnvio></mrw:SeparadorNumerosEnvio>
-                <mrw:FechaInicioEnvio></mrw:FechaInicioEnvio>
-                <mrw:FechaFinEnvio></mrw:FechaFinEnvio>
-                <mrw:TipoEtiquetaEnvio>0</mrw:TipoEtiquetaEnvio>
-                <mrw:ReportTopMargin>0</mrw:ReportTopMargin>
-                <mrw:ReportLeftMargin>0</mrw:ReportLeftMargin>
-            </mrw:request>
-        </mrw:GetEtiquetaEnvio>
-    </soapenv:Body>
-</soapenv:Envelope>

back/methods/mrw-config/getLabel.js

@@ -1,37 +0,0 @@
-module.exports = Self => {
-    Self.remoteMethod('getLabel', {
-        description: 'Return a base64Binary label from de MRW WebService',
-        accessType: 'READ',
-        accepts: [{
-            arg: 'shipmentId',
-            type: 'string',
-            required: true
-        },
-        {
-            arg: 'clientType',
-            type: 'string',
-            required: true
-        },
-        ],
-        returns: {
-            type: 'string',
-            root: true
-        },
-        http: {
-            path: `/getLabel`,
-            verb: 'GET'
-        }
-    });
-
-    Self.getLabel = async(shipmentId, clientType) => {
-        const mrw = await Self.getConfig();
-
-        const getLabelResponse = await Self.sendXmlDoc(
-            __dirname + `/getLabel.ejs`,
-            {mrw, shipmentId, clientType},
-            'text/xml'
-        );
-
-        return Self.getTextByTag(getLabelResponse, 'EtiquetaFile');
-    };
-};

back/methods/mrw-config/specs/createShipment.spec.js

@@ -1,159 +0,0 @@
-const models = require('vn-loopback/server/server').models;
-const axios = require('axios');
-const fs = require('fs');
-
-const filter = {notificationFk: 'mrw-deadline'};
-const mockBase64Binary = 'base64BinaryString';
-const ticket1 = {
-    'id': '44',
-    'clientFk': 1101,
-    'shipped': Date.vnNew(),
-    'nickname': 'MRW',
-    'addressFk': 1,
-    'agencyModeFk': 999
-};
-let expedition;
-const expedition1 = {
-    'agencyModeFk': 999,
-    'ticketFk': 44,
-    'freightItemFk': 71,
-    'created': '2001-01-01',
-    'counter': 1,
-    'workerFk': 18,
-    'packagingFk': '94',
-    'hostFk': '',
-    'stateTypeFk': 3,
-    'hasNewRoute': 0,
-    'isBox': 71,
-    'editorFk': 100
-};
-
-describe('MRWConfig createShipment()', () => {
-    beforeAll(async() => {
-        await models.Agency.create(
-            {'id': 999, 'name': 'mrw'}
-        );
-
-        await models.AgencyMode.create(
-            {'id': 999, 'name': 'mrw', 'agencyFk': 999, 'code': 'mrw'}
-
-        );
-
-        await models.MrwService.create(
-            {'agencyModeCodeFk': 'mrw', 'clientType': '000001', 'serviceType': 105, 'kg': 10}
-        );
-
-        await createMrwConfig();
-
-        await models.Ticket.create(ticket1);
-        expedition = await models.Expedition.create(expedition1);
-    });
-
-    afterAll(async() => {
-        await cleanFixtures();
-        await models.Ticket.destroyAll(ticket1);
-        await models.Expedition.destroyAll(ticket1);
-    });
-
-    beforeEach(async() => {
-        const mockPostResponses = [
-            {data: fs.readFileSync(__dirname + '/mockGetLabel.xml', 'utf-8')},
-            {data: fs.readFileSync(__dirname + '/mockCreateShipment.xml', 'utf-8')}
-        ];
-
-        spyOn(axios, 'post').and.callFake(() => Promise.resolve(mockPostResponses.pop()));
-        await cleanFixtures();
-    });
-
-    async function cleanFixtures() {
-        await models.NotificationQueue.destroyAll(filter);
-        await models.MrwConfig.updateAll({id: 1}, {expeditionDeadLine: null, notified: null});
-    }
-
-    async function createMrwConfig() {
-        await models.MrwConfig.create(
-            {
-                'id': 1,
-                'url': 'https://url.com',
-                'user': 'user',
-                'password': 'password',
-                'franchiseCode': 'franchiseCode',
-                'subscriberCode': 'subscriberCode',
-                'clientTypeWidth': 6
-            }
-        );
-    }
-
-    async function getLastNotification() {
-        return models.NotificationQueue.findOne({
-            order: 'id DESC',
-            where: filter
-        });
-    }
-
-    it('should create a shipment and return a base64Binary label', async() => {
-        const {file} = await models.MrwConfig.createShipment(expedition.id);
-
-        expect(file).toEqual(mockBase64Binary);
-    });
-
-    it('should fail if mrwConfig has no data', async() => {
-        let error;
-        await models.MrwConfig.destroyAll();
-        await models.MrwConfig.createShipment(expedition.id).catch(e => {
-            error = e;
-        }).finally(async() => {
-            expect(error.message).toEqual(`MRW service is not configured`);
-        });
-        await createMrwConfig();
-
-        expect(error).toBeDefined();
-    });
-
-    it('should fail if expeditionFk is not a MrwExpedition', async() => {
-        let error;
-        await models.MrwConfig.createShipment(15).catch(e => {
-            error = e;
-        }).finally(async() => {
-            expect(error.message).toEqual(`ClientType not available`);
-        });
-    });
-
-    it('should fail if the creation date of this ticket is before the current date', async() => {
-        let error;
-        const yesterday = Date.vnNew();
-        yesterday.setDate(yesterday.getDate() - 1);
-
-        await models.Ticket.updateAll({id: ticket1.id}, {shipped: yesterday});
-        await models.MrwConfig.createShipment(expedition.id).catch(e => {
-            error = e;
-        }).finally(async() => {
-            expect(error.message).toEqual(`This ticket has a shipped date earlier than today`);
-        });
-        await models.Ticket.updateAll({id: ticket1.id}, {shipped: Date.vnNew()});
-    });
-
-    it('should send mail if you are past the dead line and is not notified today', async() => {
-        await models.MrwConfig.updateAll({id: 1}, {expeditionDeadLine: '10:00:00', notified: null});
-        await models.MrwConfig.createShipment(expedition.id);
-        const notification = await getLastNotification();
-
-        expect(notification.notificationFk).toEqual(filter.notificationFk);
-    });
-
-    it('should send mail if you are past the dead line and it is notified from another day', async() => {
-        await models.MrwConfig.updateAll({id: 1}, {expeditionDeadLine: '10:00:00', notified: new Date()});
-        await models.MrwConfig.createShipment(expedition.id);
-        const notification = await getLastNotification();
-
-        expect(notification.notificationFk).toEqual(filter.notificationFk);
-    });
-
-    it('should not send mail if you are past the dead line and it is notified', async() => {
-        await models.MrwConfig.updateAll({id: 1}, {expeditionDeadLine: '10:00:00', notified: Date.vnNew()});
-        await models.MrwConfig.createShipment(expedition.id);
-        const notification = await getLastNotification();
-
-        expect(notification).toEqual(null);
-    });
-});

back/methods/mrw-config/specs/mockCreateShipment.xml

@@ -1,16 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope"
-    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xmlns:xsd="http://www.w3.org/2001/XMLSchema">
-    <soap:Body>
-        <TransmEnvioResponse xmlns="http://www.mrw.es/">
-            <TransmEnvioResult>
-                <Estado>1</Estado>
-                <Mensaje />
-                <NumeroSolicitud>1</NumeroSolicitud>
-                <NumeroEnvio>1</NumeroEnvio>
-                <Url>http://url.com</Url>
-            </TransmEnvioResult>
-        </TransmEnvioResponse>
-    </soap:Body>
-</soap:Envelope>

back/methods/mrw-config/specs/mockGetLabel.xml

@@ -1,14 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
-    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xmlns:xsd="http://www.w3.org/2001/XMLSchema">
-    <soap:Body>
-        <GetEtiquetaEnvioResponse xmlns="http://www.mrw.es/">
-            <GetEtiquetaEnvioResult>
-                <Estado>1</Estado>
-                <Mensaje />
-                <EtiquetaFile>base64BinaryString</EtiquetaFile>
-            </GetEtiquetaEnvioResult>
-        </GetEtiquetaEnvioResponse>
-    </soap:Body>
-</soap:Envelope>

back/methods/notification/getList.js

@@ -1,53 +0,0 @@
-module.exports = Self => {
-    Self.remoteMethod('getList', {
-        description: 'Get list of the available and active notification subscriptions',
-        accessType: 'READ',
-        accepts: [
-            {
-                arg: 'id',
-                type: 'number',
-                description: 'User to modify',
-                http: {source: 'path'}
-            }
-        ],
-        returns: {
-            type: 'object',
-            root: true
-        },
-        http: {
-            path: `/:id/getList`,
-            verb: 'GET'
-        }
-    });
-
-    Self.getList = async(id, options) => {
-        const activeNotificationsMap = new Map();
-
-        const myOptions = {};
-
-        if (typeof options == 'object')
-            Object.assign(myOptions, options);
-
-        const availableNotificationsMap = await Self.getAvailable(id, myOptions);
-        const activeNotifications = await Self.app.models.NotificationSubscription.find({
-            fields: ['id', 'notificationFk'],
-            include: {relation: 'notification'},
-            where: {userFk: id}
-        }, myOptions);
-
-        for (active of activeNotifications) {
-            activeNotificationsMap.set(active.notificationFk, {
-                id: active.id,
-                notificationFk: active.notificationFk,
-                name: active.notification().name,
-                description: active.notification().description,
-                active: true
-            });
-            availableNotificationsMap.delete(active.notificationFk);
-        }
-        return {
-            active: [...activeNotificationsMap.entries()],
-            available: [...availableNotificationsMap.entries()]
-        };
-    };
-};

back/methods/notification/send.js

@@ -1,5 +1,4 @@
 const {Email} = require('vn-print');
-const isProduction = require('vn-loopback/server/boot/isProduction');
 
 module.exports = Self => {
     Self.remoteMethod('send', {
@@ -71,7 +70,7 @@ module.exports = Self => {
                     const newParams = Object.assign({}, queueParams, sendParams);
                     const email = new Email(queueName, newParams);
 
-                    if (isProduction())
+                    if (process.env.NODE_ENV != 'test')
                         await email.send();
 
                     await queue.updateAttribute('status', statusSent);

back/methods/notification/specs/getList.spec.js

@@ -1,13 +0,0 @@
-const models = require('vn-loopback/server/server').models;
-
-describe('NotificationSubscription getList()', () => {
-    it('should return a list of available and active notifications of a user', async() => {
-        const userId = 9;
-        const {active, available} = await models.NotificationSubscription.getList(userId);
-        const notifications = await models.NotificationSubscription.getAvailable(userId);
-        const totalAvailable = notifications.size - active.length;
-
-        expect(active.length).toEqual(3);
-        expect(available.length).toEqual(totalAvailable);
-    });
-});

back/methods/osrm-config/optimize.js

@@ -1,112 +0,0 @@
-const UserError = require('vn-loopback/util/user-error');
-const axios = require('axios');
-
-module.exports = Self => {
-    Self.remoteMethod('optimize', {
-        description: 'Return optimized coords',
-        accessType: 'READ',
-        accepts: [{
-            arg: 'addressIds',
-            type: 'array',
-            required: true
-        }, {
-            arg: 'firstAddressId',
-            type: 'number',
-            required: false
-        }, {
-            arg: 'lastAddressId',
-            type: 'number',
-            required: false
-        }],
-        returns: {
-            type: 'object',
-            root: true
-        },
-        http: {
-            path: `/optimize`,
-            verb: 'GET'
-        }
-    });
-
-    Self.optimize = async(addressIds, firstAddressId, lastAddressId) => {
-        const models = Self.app.models;
-        try {
-            const osrmConfig = await models.OsrmConfig.findOne();
-            if (!osrmConfig) throw new UserError(`OSRM service is not configured`);
-
-            let coords = [];
-            if (firstAddressId) {
-                const address = await models.Address.findById(firstAddressId);
-                if (address.latitude && address.longitude) {
-                    coords.push({
-                        addressId: address.id,
-                        latitude: address.latitude.toFixed(6),
-                        longitude: address.longitude.toFixed(6)
-                    });
-                }
-            }
-
-            for (const addressId of addressIds) {
-                const address = await models.Address.findById(addressId);
-                if (address.latitude && address.longitude) {
-                    coords.push({
-                        addressId,
-                        latitude: address.latitude.toFixed(6),
-                        longitude: address.longitude.toFixed(6)
-                    });
-                }
-            }
-
-            if (lastAddressId) {
-                const firstAddress = await models.Address.findById(lastAddressId);
-                if (firstAddress.latitude && firstAddress.longitude) {
-                    coords.push({
-                        addressId: firstAddress.id,
-                        latitude: firstAddress.latitude.toFixed(6),
-                        longitude: firstAddress.longitude.toFixed(6)
-                    });
-                }
-            }
-
-            if (!coords.length) throw new UserError('No address has coordinates');
-
-            const concatCoords = coords
-                .map(coord => `${coord.longitude},${coord.latitude}`)
-                .join(';');
-            const response = await axios.post(`
-                ${osrmConfig.url}/trip/v1/driving/${concatCoords}?source=first&destination=last&roundtrip=true
-            `);
-            const tolerance = osrmConfig.tolerance;
-            for (const waypoint of response.data.waypoints) {
-                const longitude = waypoint.location[0];
-                const latitude = waypoint.location[1];
-
-                const matchedAddress = coords.find(coord =>
-                    coord.position === undefined &&
-                    Math.abs(coord.latitude - latitude) <= tolerance &&
-                    Math.abs(coord.longitude - longitude) <= tolerance
-                );
-                if (matchedAddress)
-                    matchedAddress.position = waypoint.waypoint_index;
-            }
-            coords.sort((a, b) => {
-                const posA = a.position !== undefined ? a.position : Infinity;
-                const posB = b.position !== undefined ? b.position : Infinity;
-                return posA - posB;
-            });
-
-            return coords;
-        } catch (err) {
-            switch (err.response?.data?.code) {
-            case 'NoTrips':
-                throw new UserError('No trips found because input coordinates are not connected');
-            case 'NotImplemented':
-                throw new UserError('This request is not supported');
-            case 'InvalidOptions':
-                throw new UserError('Invalid options or too many coordinates');
-            default:
-                throw err;
-            }
-        }
-    };
-};

back/methods/osrm-config/specs/optimize.spec.js

@@ -1,33 +0,0 @@
-const models = require('vn-loopback/server/server').models;
-
-describe('osrmConfig optimize()', function() {
-    it('should send coords, receive OSRM response, and return a correctly ordered result', async function() {
-        const result = await models.OsrmConfig.optimize([4, 3], 1, 2);
-
-        // Verifications
-        expect(Array.isArray(result)).toBe(true);
-        expect(result.length).toBe(4);
-
-        // Check the order
-        expect(result[0].addressId).toBe(1);
-        expect(result[1].addressId).toBe(4);
-        expect(result[2].addressId).toBe(3);
-        expect(result[3].addressId).toBe(2);
-
-        // Check the coordinates format
-        expect(result[0].latitude).toBe('10.111111');
-        expect(result[0].longitude).toBe('-74.111111');
-    });
-
-    it('should throw an error if no addresses are provided', async function() {
-        let error;
-        try {
-            await models.OsrmConfig.optimize([], null);
-        } catch (e) {
-            error = e;
-        }
-
-        expect(error).toBeDefined();
-        expect(error.message).toBe('No address has coordinates');
-    });
-});

back/methods/osticket/sendToSupport.js

@@ -1,69 +0,0 @@
-const smtp = require('vn-print/core/smtp');
-const config = require('vn-print/core/config');
-
-module.exports = Self => {
-    Self.remoteMethodCtx('sendToSupport', {
-        description: 'Send mail to support',
-        accessType: 'WRITE',
-        accepts: [
-            {
-                arg: 'reason',
-                type: 'string',
-                description: 'The reason'
-            },
-            {
-                arg: 'additionalData',
-                type: 'object',
-                required: true,
-                description: 'The additional data'
-            }
-        ],
-        returns: {
-            type: 'object',
-            root: true
-        },
-        http: {
-            path: `/send-to-support`,
-            verb: 'POST'
-        }
-    });
-
-    Self.sendToSupport = async(ctx, reason, additionalData) => {
-        const userId = ctx.req.accessToken.userId;
-        const emailUser =
-            await Self.app.models.EmailUser.findById(userId, {fields: ['email']});
-
-        let html = `<h2>Motivo: ${reason}</h2>`;
-        html += `<h3>Usuario: ${userId} ${emailUser.email}</h3>`;
-        html += `<h3>Additional Data:</h3>`;
-        html += '<ul>';
-        for (const [key, val] of Object.entries(additionalData)) {
-            if (key !== 'config') html += `<li>${key}: ${parse(val)}</li>`;
-            else {
-                html += `<li>${key}:</li><ul style="list-style-type: square;">`;
-                for (const [confKey, confVal] of Object.entries(val))
-                    html += `<li>${confKey}: ${parse(confVal)}</li>`;
-                html += '</ul>';
-            }
-        }
-        html += '</ul>';
-
-        const {message, path, name} = additionalData;
-        await smtp.send({
-            to: `${config.app.reportEmail}, ${emailUser.email}`,
-            subject: `[Support-Salix] ${path} ${name}: ${message}`,
-            html
-        });
-    };
-
-    function parse(value) {
-        try {
-            try {
-                value = JSON.parse(value);
-            } catch {}
-            return JSON.stringify(value, null, '&nbsp;').split('\n').join('<br>');
-        } catch {
-            return value;
-        }
-    }
-};

back/methods/postcode/filter.js

@@ -1,73 +0,0 @@
-const {ParameterizedSQL} = require('loopback-connector');
-const {buildFilter} = require('vn-loopback/util/filter');
-
-module.exports = Self => {
-    Self.remoteMethod('filter', {
-        description:
-        'Find all postcodes of the model matched by postcode, town, province or country.',
-        accessType: 'READ',
-        accepts: [
-            {
-                arg: 'filter',
-                type: 'object',
-                description: 'Filter defining where, order, offset, and limit - must be a JSON-encoded string',
-            },
-        ],
-        returns: {
-            type: ['object'],
-            root: true,
-        },
-        http: {
-            path: `/filter`,
-            verb: 'GET',
-        },
-    });
-    Self.filter = async(filter = {}, options) => {
-        const myOptions = {};
-        if (typeof options == 'object')
-            Object.assign(myOptions, options);
-
-        const conn = Self.dataSource.connector;
-        const where = buildFilter(filter?.where, (param, value) => {
-            switch (param) {
-            case 'search':
-                return {
-                    or: [
-                        {'pc.code': {like: `%${value}%`}},
-                        {'t.name': {like: `%${value}%`}},
-                        {'p.name': {like: `%${value}%`}},
-                        {'c.name': {like: `%${value}%`}}
-                    ]
-                };
-            }
-        }) ?? {};
-        delete filter.where;
-
-        const stmts = [];
-        let stmt;
-        stmt = new ParameterizedSQL(`
-            SELECT
-                pc.townFk,
-                t.provinceFk,
-                p.countryFk,
-                pc.code,
-                t.name as town,
-                p.name as province,
-                c.name country
-            FROM
-                postCode pc
-                JOIN town t on t.id = pc.townFk
-                JOIN province p on p.id = t.provinceFk
-                JOIN country c on c.id = p.countryFk
-        `);
-
-        stmt.merge(conn.makeSuffix({where}));
-        stmt.merge(conn.makeLimit(filter));
-        const itemsIndex = stmts.push(stmt) - 1;
-
-        const sql = ParameterizedSQL.join(stmts, ';');
-        const result = await conn.executeStmt(sql, myOptions);
-
-        return itemsIndex === 0 ? result : result[itemsIndex];
-    };
-};

back/methods/postcode/specs/filter.spec.js

@@ -1,92 +0,0 @@
-const {models} = require('vn-loopback/server/server');
-
-describe('Postcode filter()', () => {
-    it('should retrieve with no filter', async() => {
-        const tx = await models.Postcode.beginTransaction({});
-        const options = {transaction: tx};
-
-        try {
-            const results = await models.Postcode.filter({
-                limit: 1
-            }, options);
-
-            expect(results.length).toEqual(1);
-            await tx.rollback();
-        } catch (e) {
-            await tx.rollback();
-            throw e;
-        }
-    });
-
-    it('should retrieve with filter as postcode', async() => {
-        const tx = await models.Postcode.beginTransaction({});
-        const options = {transaction: tx};
-
-        try {
-            const results = await models.Postcode.filter({
-                where: {
-                    search: 46,
-                }
-            }, options);
-
-            expect(results.length).toEqual(5);
-            await tx.rollback();
-        } catch (e) {
-            await tx.rollback();
-            throw e;
-        }
-    });
-
-    it('should retrieve with filter as city', async() => {
-        const tx = await models.Postcode.beginTransaction({});
-        const options = {transaction: tx};
-
-        try {
-            const results = await models.Postcode.filter({where: {
-                search: 'Alz',
-            }}, options);
-
-            expect(results.length).toEqual(1);
-            await tx.rollback();
-        } catch (e) {
-            await tx.rollback();
-            throw e;
-        }
-    });
-
-    it('should retrieve with filter as province', async() => {
-        const tx = await models.Postcode.beginTransaction({});
-        const options = {transaction: tx};
-
-        try {
-            const results = await models.Postcode.filter({where: {
-                search: 'one',
-            }}, options);
-
-            expect(results.length).toEqual(5);
-            await tx.rollback();
-        } catch (e) {
-            await tx.rollback();
-            throw e;
-        }
-    });
-
-    it('should retrieve with filter as country', async() => {
-        const tx = await models.Postcode.beginTransaction({});
-        const options = {transaction: tx};
-
-        try {
-            const results = await models.Postcode.filter({
-                where: {
-                    search: 'Ec',
-                }
-            }, options);
-
-            expect(results.length).toEqual(1);
-            await tx.rollback();
-        } catch (e) {
-            await tx.rollback();
-            throw e;
-        }
-    });
-});

back/methods/starred-module/specs/getStarredModules.spec.js

@@ -1,7 +1,22 @@
 const {models} = require('vn-loopback/server/server');
+const LoopBackContext = require('loopback-context');
 
 describe('getStarredModules()', () => {
-    const ctx = beforeAll.getCtx();
+    const activeCtx = {
+        accessToken: {userId: 9},
+        http: {
+            req: {
+                headers: {origin: 'http://localhost'}
+            }
+        }
+    };
+    const ctx = {req: activeCtx};
+
+    beforeEach(() => {
+        spyOn(LoopBackContext, 'getCurrentContext').and.returnValue({
+            active: activeCtx
+        });
+    });
 
     it(`should return the starred modules for a given user`, async() => {
         const newStarred = await models.StarredModule.create({workerFk: 9, moduleFk: 'customer', position: 1});

back/methods/starred-module/specs/setPosition.spec.js

@@ -1,8 +1,24 @@
 const {models} = require('vn-loopback/server/server');
+const LoopBackContext = require('loopback-context');
 
 describe('setPosition()', () => {
-    const ctx = beforeAll.getCtx();
+    const activeCtx = {
-    beforeAll.mockLoopBackContext();
+        accessToken: {userId: 9},
+        http: {
+            req: {
+                headers: {origin: 'http://localhost'}
+            }
+        }
+    };
+    const ctx = {
+        req: activeCtx
+    };
+
+    beforeEach(() => {
+        spyOn(LoopBackContext, 'getCurrentContext').and.returnValue({
+            active: activeCtx
+        });
+    });
 
     it('should increase the orders module position by replacing it with clients and vice versa', async() => {
         const tx = await models.StarredModule.beginTransaction({});

back/methods/starred-module/specs/toggleStarredModule.spec.js

@@ -1,7 +1,24 @@
 const {models} = require('vn-loopback/server/server');
+const LoopBackContext = require('loopback-context');
 
 describe('toggleStarredModule()', () => {
-    const ctx = beforeAll.getCtx();
+    const activeCtx = {
+        accessToken: {userId: 9},
+        http: {
+            req: {
+                headers: {origin: 'http://localhost'}
+            }
+        }
+    };
+    const ctx = {
+        req: activeCtx
+    };
+
+    beforeEach(() => {
+        spyOn(LoopBackContext, 'getCurrentContext').and.returnValue({
+            active: activeCtx
+        });
+    });
 
     it('should create a new starred module and then remove it by calling the method again with same args', async() => {
         const starredModule = await models.StarredModule.toggleStarredModule(ctx, 'order');
@@ -9,7 +26,7 @@ describe('toggleStarredModule()', () => {
 
         expect(starredModules.length).toEqual(1);
         expect(starredModule.moduleFk).toEqual('order');
-        expect(starredModule.workerFk).toEqual(ctx.req.accessToken.userId);
+        expect(starredModule.workerFk).toEqual(activeCtx.accessToken.userId);
         expect(starredModule.position).toEqual(starredModules.length);
 
         await models.StarredModule.toggleStarredModule(ctx, 'order');

back/methods/url/getByUser.js

@@ -1,40 +0,0 @@
-module.exports = function(Self) {
-    Self.remoteMethod('getByUser', {
-        description: 'returns the starred modules for the current user',
-        accessType: 'READ',
-        accepts: [{
-            arg: 'userId',
-            type: 'number',
-            description: 'The user id',
-            required: true,
-            http: {source: 'path'}
-        }],
-        returns: {
-            type: 'object',
-            root: true
-        },
-        http: {
-            path: `/:userId/get-by-user`,
-            verb: 'GET'
-        }
-    });
-
-    Self.getByUser = async userId => {
-        const models = Self.app.models;
-        const appNames = ['hedera'];
-        const filter = {
-            fields: ['appName', 'url'],
-            where: {
-                appName: {inq: appNames},
-                environment: process.env.NODE_ENV ?? 'development',
-            }
-        };
-
-        const isWorker = await models.Account.findById(userId, {fields: ['id']});
-        if (!isWorker)
-            return models.Url.find(filter);
-
-        appNames.push('salix');
-        return models.Url.find(filter);
-    };
-};

back/methods/url/getUrl.js

@@ -1,30 +0,0 @@
-module.exports = Self => {
-    Self.remoteMethod('getUrl', {
-        description: 'Returns the colling app name',
-        accessType: 'READ',
-        accepts: [
-            {
-                arg: 'app',
-                type: 'string',
-                required: false
-            }
-        ],
-        returns: {
-            type: 'object',
-            root: true
-        },
-        http: {
-            path: `/getUrl`,
-            verb: 'get'
-        }
-    });
-    Self.getUrl = async(appName = 'salix') => {
-        const url = await Self.app.models.Url.findOne({
-            where: {
-                appName,
-                environment: process.env.NODE_ENV || 'development'
-            }
-        });
-        return url?.url;
-    };
-};

back/methods/url/specs/getByUser.spec.js

@@ -1,19 +0,0 @@
-const {models} = require('vn-loopback/server/server');
-
-describe('getByUser()', () => {
-    const worker = 1;
-    const notWorker = 2;
-    it(`should return only hedera url if not is worker`, async() => {
-        const urls = await models.Url.getByUser(notWorker);
-
-        expect(urls.length).toEqual(1);
-        expect(urls[0].appName).toEqual('hedera');
-    });
-
-    it(`should return more than hedera url`, async() => {
-        const urls = await models.Url.getByUser(worker);
-
-        expect(urls.length).toBeGreaterThan(1);
-        expect(urls.find(url => url.appName == 'salix').appName).toEqual('salix');
-    });
-});

back/methods/user-config/specs/getUserConfig.spec.js

@@ -1,12 +1,12 @@
 const models = require('vn-loopback/server/server').models;
 
 describe('userConfig getUserConfig()', () => {
-    const ctx = beforeAll.getCtx();
     it(`should return the configuration data of a given user`, async() => {
         const tx = await models.Item.beginTransaction({});
         const options = {transaction: tx};
 
         try {
+            const ctx = {req: {accessToken: {userId: 9}}};
             const result = await models.UserConfig.getUserConfig(ctx, options);
 
             expect(result.warehouseFk).toEqual(1);

back/methods/viaexpress-config/deleteExpedition.ejs

@@ -1,11 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<soap12:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap12="http://www.w3.org/2003/05/soap-envelope">
-  <soap12:Body>
-    <DeleteEnvio xmlns="http://82.223.6.71:82">
-        <IdCliente><%= viaexpressConfig.client %></IdCliente>
-        <Usuario><%= viaexpressConfig.user %></Usuario>
-        <Password><%= viaexpressConfig.password %></Password>
-      <etiqueta><%= externalId %></etiqueta>
-    </DeleteEnvio>
-  </soap12:Body>
-</soap12:Envelope>

back/methods/viaexpress-config/deleteExpedition.js

@@ -1,45 +0,0 @@
-const axios = require('axios');
-const {DOMParser} = require('xmldom');
-
-module.exports = Self => {
-    Self.remoteMethod('deleteExpedition', {
-        description: 'Delete a shipment by providing the expedition ID, interacting with Viaexpress API',
-        accessType: 'WRITE',
-        accepts: [{
-            arg: 'expeditionFk',
-            type: 'number',
-            required: true
-        }],
-        returns: {
-            type: ['object'],
-            root: true
-        },
-        http: {
-            path: `/deleteExpedition`,
-            verb: 'POST'
-        }
-    });
-
-    Self.deleteExpedition = async expeditionFk => {
-        const models = Self.app.models;
-
-        const viaexpressConfig = await models.ViaexpressConfig.findOne({
-            fields: ['url']
-        });
-
-        const renderedXml = await models.ViaexpressConfig.deleteExpeditionRenderer(expeditionFk);
-        const response = await axios.post(`${viaexpressConfig.url}ServicioVxClientes.asmx`, renderedXml, {
-            headers: {
-                'Content-Type': 'application/soap+xml; charset=utf-8'
-            }
-        });
-
-        const xmlString = response.data;
-        const parser = new DOMParser();
-        const xmlDoc = parser.parseFromString(xmlString, 'text/xml');
-        const resultElement = xmlDoc.getElementsByTagName('DeleteEnvioResult')[0];
-        const result = resultElement.textContent;
-
-        return result;
-    };
-};

back/methods/viaexpress-config/deleteExpeditionRenderer.js

@@ -1,44 +0,0 @@
-const fs = require('fs');
-const ejs = require('ejs');
-
-module.exports = Self => {
-    Self.remoteMethod('deleteExpeditionRenderer', {
-        description: 'Renders the data from an XML',
-        accessType: 'READ',
-        accepts: [{
-            arg: 'expeditionFk',
-            type: 'number',
-            required: true
-        }],
-        returns: {
-            type: ['object'],
-            root: true
-        },
-        http: {
-            path: `/deleteExpeditionRenderer`,
-            verb: 'GET'
-        }
-    });
-
-    Self.deleteExpeditionRenderer = async expeditionFk => {
-        const models = Self.app.models;
-
-        const viaexpressConfig = await models.ViaexpressConfig.findOne({
-            fields: ['client', 'user', 'password']
-        });
-
-        const expedition = await models.Expedition.findOne({
-            fields: ['id', 'externalId'],
-            where: {id: expeditionFk}
-        });
-
-        const data = {
-            viaexpressConfig,
-            externalId: expedition.externalId
-        };
-
-        const template = fs.readFileSync(__dirname + '/deleteExpedition.ejs', 'utf-8');
-        const renderedXml = ejs.render(template, data);
-        return renderedXml;
-    };
-};

back/methods/viaexpress-config/internationalExpedition.js

@@ -1,45 +0,0 @@
-const axios = require('axios');
-const {DOMParser} = require('xmldom');
-
-module.exports = Self => {
-    Self.remoteMethod('internationalExpedition', {
-        description: 'Create an expedition and return a label',
-        accessType: 'WRITE',
-        accepts: [{
-            arg: 'expeditionFk',
-            type: 'number',
-            required: true
-        }],
-        returns: {
-            type: ['object'],
-            root: true
-        },
-        http: {
-            path: `/internationalExpedition`,
-            verb: 'POST'
-        }
-    });
-
-    Self.internationalExpedition = async (expeditionFk) => {
-        const models = Self.app.models;
-
-        const viaexpressConfig = await models.ViaexpressConfig.findOne({
-            fields: ['url']
-        });
-
-        const renderedXml = await models.ViaexpressConfig.renderer(expeditionFk);
-        const response = await axios.post(`${viaexpressConfig.url}ServicioVxClientes.asmx`, renderedXml, {
-            headers: {
-                'Content-Type': 'application/soap+xml; charset=utf-8'
-            }
-        });
-
-        const xmlString = response.data;
-        const parser = new DOMParser();
-        const xmlDoc = parser.parseFromString(xmlString, 'text/xml');
-        const referenciaVxElement = xmlDoc.getElementsByTagName('ReferenciaVx')[0];
-        const referenciaVx = referenciaVxElement.textContent;
-
-        return referenciaVx;
-    };
-};

back/methods/viaexpress-config/renderer.js

@@ -1,127 +0,0 @@
-const fs = require('fs');
-const ejs = require('ejs');
-
-module.exports = Self => {
-    Self.remoteMethod('renderer', {
-        description: 'Renders the data from an XML',
-        accessType: 'READ',
-        accepts: [{
-            arg: 'expeditionFk',
-            type: 'number',
-            required: true
-        }],
-        returns: {
-            type: ['object'],
-            root: true
-        },
-        http: {
-            path: `/renderer`,
-            verb: 'GET'
-        }
-    });
-
-    Self.renderer = async expeditionFk => {
-        const models = Self.app.models;
-
-        const viaexpressConfig = await models.ViaexpressConfig.findOne({
-            fields: ['client', 'user', 'password', 'defaultWeight', 'deliveryType', 'agencyModeFk']
-        });
-
-        const expedition = await models.Expedition.findOne({
-            fields: ['id', 'ticketFk'],
-            where: {id: expeditionFk},
-            include: [
-                {
-                    relation: 'ticket',
-                    scope: {
-                        fields: ['shipped', 'addressFk', 'clientFk', 'companyFk', 'agencyModeFk'],
-                        include: [
-                            {
-                                relation: 'client',
-                                scope: {
-                                    fields: ['mobile', 'phone', 'email']
-                                }
-                            },
-                            {
-                                relation: 'address',
-                                scope: {
-                                    fields: [
-                                        'nickname',
-                                        'street',
-                                        'postalCode',
-                                        'city',
-                                        'mobile',
-                                        'phone',
-                                        'provinceFk'
-                                    ],
-                                    include: {
-                                        relation: 'province',
-                                        scope: {
-                                            fields: ['name', 'countryFk'],
-                                            include: {
-                                                relation: 'country',
-                                                scope: {
-                                                    fields: ['code'],
-                                                }
-                                            }
-
-                                        }
-                                    }
-                                }
-                            },
-                            {
-                                relation: 'company',
-                                scope: {
-                                    fields: ['clientFk'],
-                                    include: {
-                                        relation: 'client',
-                                        scope: {
-                                            fields: ['socialName', 'mobile', 'phone', 'email', 'defaultAddressFk'],
-                                            include: {
-                                                relation: 'defaultAddress',
-                                                scope: {
-                                                    fields: [
-                                                        'street',
-                                                        'postalCode',
-                                                        'city',
-                                                        'mobile',
-                                                        'phone',
-                                                        'provinceFk'
-                                                    ],
-                                                    include: {
-                                                        relation: 'province',
-                                                        scope: {
-                                                            fields: ['name']
-                                                        }
-                                                    }
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        ]
-                    }
-                }
-            ]
-        });
-
-        const ticket = expedition.ticket();
-        const sender = ticket.company().client();
-        const shipped = ticket.shipped.toISOString();
-        const isInterdia = (ticket.agencyModeFk === viaexpressConfig.agencyModeFk);
-        const data = {
-            viaexpressConfig,
-            sender,
-            senderAddress: sender.defaultAddress(),
-            client: ticket.client(),
-            address: ticket.address(),
-            shipped,
-            isInterdia
-        };
-
-        const template = fs.readFileSync(__dirname + '/template.ejs', 'utf-8');
-        const renderedXml = ejs.render(template, data);
-        return renderedXml;
-    };
-};

back/methods/viaexpress-config/template.ejs

@@ -1,52 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<soap12:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap12="http://www.w3.org/2003/05/soap-envelope">
-<soap12:Body>
-    <PutExpedicionInternacional xmlns="http://82.223.6.71:82">
-    <ObjetoEnvio>
-            <Peso><%= viaexpressConfig.defaultWeight %></Peso>
-            <Bultos>1</Bultos>
-            <Reembolso>0</Reembolso>
-            <Fecha><%= shipped %></Fecha>
-            <ConRetorno>0</ConRetorno>
-            <Tipo><%= viaexpressConfig.deliveryType %></Tipo>
-            <Debidos>0</Debidos>
-            <Asegurado>0</Asegurado>
-            <Imprimir>0</Imprimir>
-            <ConDevolucionAlbaran>0</ConDevolucionAlbaran>
-            <Intradia><%= isInterdia %></Intradia>
-            <Observaciones></Observaciones>
-            <AlbaranRemitente></AlbaranRemitente>
-            <Modo>0</Modo>
-            <TextoAgencia></TextoAgencia>
-            <Terminal></Terminal>
-            <ObjetoRemitente>
-                    <RazonSocial><%= sender.socialName %></RazonSocial>
-                    <Domicilio><%= senderAddress.street %></Domicilio>
-                    <Cpostal><%= senderAddress.postalCode %></Cpostal>
-                    <Poblacion><%= senderAddress.city %></Poblacion>
-                    <Provincia><%= senderAddress.province().name %></Provincia>
-                    <Contacto></Contacto>
-                    <Telefono><%= senderAddress.mobile || senderAddress.phone || sender.mobile || sender.phone %></Telefono>
-                    <Email><%= sender.email %></Email>
-            </ObjetoRemitente>
-            <ObjetoDestinatario>
-                    <RazonSocial><%= address.nickname %></RazonSocial>
-                    <Domicilio><%= address.street %></Domicilio>
-                    <Cpostal><%= address.postalCode %></Cpostal>
-                    <Poblacion><%= address.city %></Poblacion>
-                    <Municipio></Municipio>
-                    <Provincia><%= address.province().name %></Provincia>
-                    <Contacto></Contacto>
-                    <Telefono><%= address.mobile || address.phone || client.mobile || client.phone %></Telefono>
-                    <Email><%= client.email %></Email>
-                    <Pais><%= address.province().country().code %></Pais>
-            </ObjetoDestinatario>
-            <ObjetoLogin>
-                    <IdCliente><%= viaexpressConfig.client %></IdCliente>
-                    <Usuario><%= viaexpressConfig.user %></Usuario>
-                    <Password><%= viaexpressConfig.password %></Password>
-            </ObjetoLogin>
-    </ObjetoEnvio>
-    </PutExpedicionInternacional>
-</soap12:Body>
-</soap12:Envelope>

back/methods/vn-token/killSession.js

@@ -1,29 +0,0 @@
-module.exports = Self => {
-    Self.remoteMethodCtx('killSession', {
-        description: 'Kill session',
-        accepts: [{
-            arg: 'userId',
-            type: 'integer',
-            description: 'The user id',
-            required: true,
-        }, {
-            arg: 'created',
-            type: 'date',
-            description: 'The created time',
-            required: true,
-        }],
-        accessType: 'WRITE',
-        http: {
-            path: `/killSession`,
-            verb: 'POST'
-        }
-    });
-
-    Self.killSession = async function(ctx, userId, created) {
-        await Self.app.models.VnUser.userSecurity(ctx, ctx.req.accessToken.userId);
-        const tokens = await Self.app.models.AccessToken.find({where: {userId, created}});
-        if (!tokens?.length) return;
-        for (const token of tokens)
-            await Self.app.models.AccessToken.deleteById(token.id);
-    };
-};

back/methods/vn-user/acl.js

@@ -23,7 +23,13 @@ module.exports = Self => {
         let models = Self.app.models;
 
         let user = await Self.findById(userId, {
-            fields: ['id', 'name', 'nickname', 'email', 'lang']
+            fields: ['id', 'name', 'nickname', 'email', 'lang'],
+            include: {
+                relation: 'userConfig',
+                scope: {
+                    fields: ['darkMode']
+                }
+            }
         });
 
         let roles = await models.RoleMapping.find({

back/methods/vn-user/acls.js

@@ -1,72 +0,0 @@
-module.exports = Self => {
-    Self.remoteMethodCtx('acls', {
-        description: 'Get all of the current user acls',
-        returns: {
-            type: 'Object',
-            root: true
-        },
-        http: {
-            path: '/acls',
-            verb: 'GET'
-        }
-    });
-
-    const staticAcls = new Map();
-    const app = require('vn-loopback/server/server');
-    app.on('started', function() {
-        for (const model of app.models()) {
-            for (const acl of model.settings.acls) {
-                if (acl.principalType == 'ROLE' && acl.permission == 'ALLOW') {
-                    const staticAcl = {
-                        model: model.name,
-                        property: acl.property,
-                        accessType: acl.accessType,
-                        permission: acl.permission,
-                        principalType: acl.principalType,
-                        principalId: acl.principalId,
-                    };
-                    if (staticAcls.has(acl.principalId))
-                        staticAcls.get(acl.principalId).push(staticAcl);
-                    else
-                        staticAcls.set(acl.principalId, [staticAcl]);
-                }
-            }
-        }
-    });
-
-    Self.acls = async function(ctx) {
-        const models = Self.app.models;
-        const acls = [];
-        const userId = ctx.req.accessToken.userId;
-        if (userId) {
-            const roleMapping = await models.RoleMapping.find({
-                where: {
-                    principalId: userId
-                },
-                include: [
-                    {
-                        relation: 'role',
-                        scope: {
-                            fields: [
-                                'name'
-                            ]
-                        }
-                    }
-                ]
-            });
-            const dynamicAcls = await models.ACL.find({
-                where: {
-                    principalId: {
-                        inq: roleMapping.map(rm => rm.role().name)
-                    }
-                }
-            });
-            dynamicAcls.forEach(acl => acls.push(acl));
-            staticAcls.get('$authenticated').forEach(acl => acls.push(acl));
-        } else
-            staticAcls.get('$unauthenticated').forEach(acl => acls.push(acl));
-
-        staticAcls.get('$everyone').forEach(acl => acls.push(acl));
-        return acls;
-    };
-};

back/methods/vn-user/privileges.js

@@ -47,7 +47,7 @@ module.exports = Self => {
         const user = await Self.findById(userId, {fields: ['hasGrant']}, myOptions);
 
         const userToUpdate = await Self.findById(id, {
-            fields: ['id', 'name', 'hasGrant', 'roleFk', 'password', 'email'],
+            fields: ['id', 'name', 'hasGrant', 'roleFk', 'password'],
             include: {
                 relation: 'role',
                 scope: {
@@ -68,7 +68,7 @@ module.exports = Self => {
             userToUpdate.hasGrant = hasGrant;
 
         if (roleFk) {
-            const role = await models.VnRole.findById(roleFk, {fields: ['name']}, myOptions);
+            const role = await models.Role.findById(roleFk, {fields: ['name']}, myOptions);
             const hasRole = await Self.hasRole(userId, role.name, myOptions);
 
             if (!hasRole)

back/methods/vn-user/recover-password.js

@@ -7,11 +7,6 @@ module.exports = Self => {
                 type: 'string',
                 description: 'The user name or email',
                 required: true
-            },
-            {
-                arg: 'app',
-                type: 'string',
-                description: 'The directory for mail'
             }
         ],
         http: {
@@ -20,7 +15,7 @@ module.exports = Self => {
         }
     });
 
-    Self.recoverPassword = async function(user, app) {
+    Self.recoverPassword = async function(user) {
         const models = Self.app.models;
 
         const usesEmail = user.indexOf('@') !== -1;
@@ -29,12 +24,11 @@ module.exports = Self => {
                 fields: ['email'],
                 where: {name: user}
             });
-            if (!account) return;
             user = account.email;
         }
 
         try {
-            await Self.resetPassword({email: user, emailTemplate: 'recover-password', app});
+            await Self.resetPassword({email: user, emailTemplate: 'recover-password'});
         } catch (err) {
             if (err.code === 'EMAIL_NOT_FOUND')
                 return;

back/methods/vn-user/renew-token.js

@@ -1,66 +0,0 @@
-const {models} = require('vn-loopback/server/server');
-
-module.exports = Self => {
-    Self.remoteMethodCtx('renewToken', {
-        description: 'Checks if the token has more than renewPeriod seconds to live and if so, renews it',
-        accessType: 'WRITE',
-        accepts: [],
-        returns: {
-            type: 'Object',
-            root: true
-        },
-        http: {
-            path: `/renewToken`,
-            verb: 'POST'
-        },
-        accessScopes: ['DEFAULT', 'read:multimedia']});
-
-    Self.renewToken = async function(ctx) {
-        let createTokenOptions = {};
-        let token; let isNotExceeded;
-        try {
-            token = ctx.req.accessToken;
-
-            const {courtesyTime} = await models.AccessTokenConfig.findOne({
-                fields: ['courtesyTime']
-            });
-            isNotExceeded = await Self.validateToken(ctx);
-            if (isNotExceeded)
-                return token;
-
-            // Schedule to remove current token
-            setTimeout(async() => {
-                try {
-                    await Self.logout(token.id);
-                } catch (error) {
-                    // FIXME: Crash if do throw new Error(error)
-                }
-            }, courtesyTime * 1000);
-
-            // Get scopes
-            const {scopes} = token;
-            if (scopes)
-                createTokenOptions = {scopes: [scopes[0]]};
-            // Create new accessToken
-            const user = await Self.findById(token.userId);
-            const accessToken = await user.accessTokens.create(createTokenOptions);
-
-            return {id: accessToken.id, ttl: accessToken.ttl};
-        } catch (error) {
-            const body = {
-                error: error.message,
-                userId: token?.userId ?? null,
-                token: token?.id,
-                scopes: token?.scopes,
-                createTokenOptions,
-                isNotExceeded
-            };
-            await handleError(JSON.stringify(body));
-            throw new Error(error);
-        }
-    };
-};
-
-async function handleError(body) {
-    await models.Application.rawSql('CALL util.debugAdd(?,?);', ['renewToken', body]);
-}

back/methods/vn-user/share-token.js

@@ -1,27 +0,0 @@
-
-module.exports = Self => {
-    Self.remoteMethodCtx('shareToken', {
-        description: 'Returns token to view files or images and share it',
-        accessType: 'WRITE',
-        accepts: [],
-        returns: {
-            type: 'Object',
-            root: true
-        },
-        http: {
-            path: `/shareToken`,
-            verb: 'GET'
-        }
-    });
-
-    Self.shareToken = async function(ctx) {
-        const {accessToken: token} = ctx.req;
-
-        const user = await Self.findById(token.userId);
-        const multimediaToken = await user.accessTokens.create({
-            scopes: ['read:multimedia']
-        });
-
-        return {multimediaToken};
-    };
-};

back/methods/vn-user/sign-in.js

@@ -1,97 +0,0 @@
-const ForbiddenError = require('vn-loopback/util/forbiddenError');
-const UserError = require('vn-loopback/util/user-error');
-
-module.exports = Self => {
-    Self.remoteMethodCtx('signIn', {
-        description: 'Login a user with username/email and password',
-        accepts: [
-            {
-                arg: 'user',
-                type: 'String',
-                description: 'The user name or email',
-                required: true
-            }, {
-                arg: 'password',
-                type: 'String',
-                description: 'The password'
-            }
-        ],
-        returns: {
-            type: 'object',
-            root: true
-        },
-        http: {
-            path: `/sign-in`,
-            verb: 'POST'
-        }
-    });
-
-    Self.signIn = async function(ctx, user, password, options) {
-        const myOptions = {};
-        if (typeof options == 'object')
-            Object.assign(myOptions, options);
-
-        const where = Self.userUses(user);
-        const vnUser = await Self.findOne({
-            fields: ['id', 'name', 'password', 'active', 'email', 'passExpired', 'twoFactor'],
-            where
-        }, myOptions);
-
-        const validCredentials = vnUser
-            && await vnUser.hasPassword(password);
-
-        if (validCredentials) {
-            if (!vnUser.active)
-                throw new UserError('User disabled');
-            await Self.sendTwoFactor(ctx, vnUser, myOptions);
-            await Self.passExpired(vnUser, myOptions);
-
-            if (vnUser.twoFactor)
-                throw new ForbiddenError(null, 'REQUIRES_2FA');
-        }
-        return Self.validateLogin(user, password, ctx);
-    };
-
-    Self.passExpired = async vnUser => {
-        const today = Date.vnNew();
-        today.setHours(0, 0, 0, 0);
-
-        if (vnUser.passExpired && vnUser.passExpired.getTime() <= today.getTime()) {
-            const err = new UserError('Pass expired', 'passExpired');
-            err.details = {userId: vnUser.id, twoFactor: vnUser.twoFactor ? true : false};
-            throw err;
-        }
-    };
-
-    Self.sendTwoFactor = async(ctx, vnUser, myOptions) => {
-        if (vnUser.twoFactor === 'email') {
-            const $ = Self.app.models;
-
-            const min = 100000;
-            const max = 999999;
-            const code = String(Math.floor(Math.random() * (max - min + 1)) + min);
-            const maxTTL = ((60 * 1000) * 5); // 5 min
-            await $.AuthCode.upsertWithWhere({userFk: vnUser.id}, {
-                userFk: vnUser.id,
-                code: code,
-                expires: Date.vnNow() + maxTTL
-            }, myOptions);
-
-            const headers = ctx.req.headers;
-            const platform = headers['sec-ch-ua-platform']?.replace(/['"=]+/g, '');
-            const browser = headers['sec-ch-ua']?.replace(/['"=]+/g, '');
-            const params = {
-                args: {
-                    recipientId: vnUser.id,
-                    recipient: vnUser.email,
-                    code: code,
-                    ip: ctx.req?.connection?.remoteAddress,
-                    device: platform && browser ? platform + ', ' + browser : headers['user-agent'],
-                },
-                req: {getLocale: ctx.req.getLocale},
-            };
-
-            await Self.sendTemplate(params, 'auth-code', true);
-        }
-    };
-};

back/methods/vn-user/signIn.js

@@ -0,0 +1,68 @@
+const UserError = require('vn-loopback/util/user-error');
+
+module.exports = Self => {
+    Self.remoteMethod('signIn', {
+        description: 'Login a user with username/email and password',
+        accepts: [
+            {
+                arg: 'user',
+                type: 'String',
+                description: 'The user name or email',
+                http: {source: 'form'},
+                required: true
+            }, {
+                arg: 'password',
+                type: 'String',
+                description: 'The password'
+            }
+        ],
+        returns: {
+            type: 'object',
+            root: true
+        },
+        http: {
+            path: `/signIn`,
+            verb: 'POST'
+        }
+    });
+
+    Self.signIn = async function(user, password) {
+        let models = Self.app.models;
+        let token;
+        let usesEmail = user.indexOf('@') !== -1;
+
+        let userInfo = usesEmail
+            ? {email: user}
+            : {username: user};
+        let instance = await Self.findOne({
+            fields: ['username', 'password'],
+            where: userInfo
+        });
+
+        let where = usesEmail
+            ? {email: user}
+            : {name: user};
+        let vnUser = await Self.findOne({
+            fields: ['active'],
+            where
+        });
+
+        let validCredentials = instance
+            && await instance.hasPassword(password);
+
+        if (validCredentials) {
+            if (!vnUser.active)
+                throw new UserError('User disabled');
+
+            try {
+                await models.Account.sync(instance.username, password);
+            } catch (err) {
+                console.warn(err);
+            }
+        }
+
+        let loginInfo = Object.assign({password}, userInfo);
+        token = await Self.login(loginInfo, 'user');
+        return {token: token.id};
+    };
+};

back/methods/vn-user/specs/acls.spec.js

@@ -1,27 +0,0 @@
-const {models} = require('vn-loopback/server/server');
-const id = {administrative: 5, employee: 1, productionBoss: 50};
-
-describe('VnUser acls()', () => {
-    it('should get its owns acls', async() => {
-        expect(await hasAcl('administrative', id.administrative)).toBeTruthy();
-        expect(await hasAcl('productionBoss', id.productionBoss)).toBeTruthy();
-    });
-
-    it('should not get administrative acls', async() => {
-        expect(await hasAcl('administrative', id.employee)).toBeFalsy();
-    });
-
-    it('should get the $authenticated acls', async() => {
-        expect(await hasAcl('$authenticated', id.employee)).toBeTruthy();
-    });
-
-    it('should get the $everyone acls', async() => {
-        expect(await hasAcl('$everyone', id.employee)).toBeTruthy();
-    });
-});
-
-const hasAcl = async(role, userId) => {
-    const ctx = {req: {accessToken: {userId}, headers: {origin: 'http://localhost'}}};
-    const acls = await models.VnUser.acls(ctx);
-    return Object.values(acls).some(acl => acl.principalId === role);
-};

back/methods/vn-user/specs/privileges.spec.js

@@ -70,7 +70,7 @@ describe('VnUser privileges()', () => {
         const tx = await models.VnUser.beginTransaction({});
 
         const options = {transaction: tx};
-        const agency = await models.VnRole.findOne({
+        const agency = await models.Role.findOne({
             where: {
                 name: 'agency'
             }

back/methods/vn-user/specs/renew-token.spec.js

@@ -1,81 +0,0 @@
-const {models} = require('vn-loopback/server/server');
-describe('Renew Token', () => {
-    const startingTime = Date.now();
-    let ctx = null;
-    beforeAll(async() => {
-        const unAuthCtx = {
-            req: {
-                headers: {},
-                connection: {
-                    remoteAddress: '127.0.0.1'
-                },
-                getLocale: () => 'en'
-            },
-            args: {}
-        };
-        let login = await models.VnUser.signIn(unAuthCtx, 'salesAssistant', 'nightmare');
-        let accessToken = await models.AccessToken.findById(login.token);
-        ctx = {req: {accessToken: accessToken}};
-    });
-
-    beforeEach(() => {
-        jasmine.clock().install();
-        jasmine.clock().mockDate(new Date(startingTime));
-    });
-
-    afterEach(() => {
-        jasmine.clock().uninstall();
-    });
-
-    it('should renew token', async() => {
-        const {courtesyTime} = await models.AccessTokenConfig.findOne({
-            fields: ['courtesyTime']
-        });
-        const mockDate = new Date(startingTime + 26600000);
-        jasmine.clock().mockDate(mockDate);
-        const {id} = await models.VnUser.renewToken(ctx);
-
-        expect(id).not.toEqual(ctx.req.accessToken.id);
-
-        await models.VnUser.logout(ctx.req.accessToken.id);
-        jasmine.clock().tick((courtesyTime + 10) * 1000);
-        let tokenNotExists;
-        try {
-            tokenNotExists = await models.AccessToken.findById(ctx.req.accessToken.id);
-        } catch (e) {
-            error = e;
-        }
-
-        expect(tokenNotExists).toBeNull();
-    });
-
-    it('NOT should renew', async() => {
-        let error;
-        let response;
-        try {
-            response = await models.VnUser.renewToken(ctx);
-        } catch (e) {
-            error = e;
-        }
-
-        expect(error).toBeUndefined();
-        expect(response.id).toEqual(ctx.req.accessToken.id);
-    });
-
-    it('throw error', async() => {
-        let error;
-
-        try {
-            await models.VnUser.renewToken({req: {token: null}});
-        } catch (e) {
-            error = e;
-        }
-
-        expect(error).toBeDefined();
-
-        const query = 'SELECT * FROM util.debug WHERE variable = "renewToken"';
-        const debugLog = await models.Application.rawSql(query);
-
-        expect(debugLog.length).toEqual(1);
-    });
-});

back/methods/vn-user/specs/share-token.spec.js

@@ -1,64 +0,0 @@
-const {models} = require('vn-loopback/server/server');
-const TOKEN_MULTIMEDIA = 'read:multimedia';
-describe('Share Token', () => {
-    let ctx = null;
-    const startingTime = Date.now();
-    let multimediaToken = null;
-    beforeAll(async() => {
-        const unAuthCtx = {
-            req: {
-                headers: {},
-                connection: {
-                    remoteAddress: '127.0.0.1'
-                },
-                getLocale: () => 'en'
-            },
-            args: {}
-        };
-        let login = await models.VnUser.signIn(unAuthCtx, 'salesAssistant', 'nightmare');
-        let accessToken = await models.AccessToken.findById(login.token);
-        ctx = {req: {accessToken: accessToken}};
-    });
-
-    beforeEach(async() => {
-        multimediaToken = await models.VnUser.shareToken(ctx);
-        jasmine.clock().install();
-        jasmine.clock().mockDate(new Date(startingTime));
-    });
-
-    afterEach(() => {
-        jasmine.clock().uninstall();
-    });
-
-    it('should generate token', async() => {
-        expect(Object.keys(multimediaToken).length).toEqual(1);
-        expect(multimediaToken.multimediaToken.userId).toEqual(ctx.req.accessToken.userId);
-        expect(multimediaToken.multimediaToken.scopes[0]).toEqual(TOKEN_MULTIMEDIA);
-    });
-
-    it('NOT should renew', async() => {
-        let error;
-        let response;
-        try {
-            response = await models.VnUser.renewToken(ctx);
-        } catch (e) {
-            error = e;
-        }
-
-        expect(error).toBeUndefined();
-        expect(response.id).toEqual(ctx.req.accessToken.id);
-    });
-
-    it('should renew token', async() => {
-        const mockDate = new Date(startingTime + 26600000);
-        jasmine.clock().mockDate(mockDate);
-
-        const newShareToken = await models.VnUser.renewToken({req: {accessToken: multimediaToken.multimediaToken}});
-        const {id} = newShareToken;
-
-        expect(id).not.toEqual(ctx.req.accessToken.id);
-        const newMultimediaToken = await models.AccessToken.findById(id);
-
-        expect(newMultimediaToken.scopes[0]).toEqual(TOKEN_MULTIMEDIA);
-    });
-});

back/methods/vn-user/specs/sign-in.spec.js

@@ -1,112 +0,0 @@
-const {models} = require('vn-loopback/server/server');
-
-describe('VnUser Sign-in()', () => {
-    const employeeId = 1;
-    const unAuthCtx = {
-        req: {
-            headers: {},
-            connection: {
-                remoteAddress: '127.0.0.1'
-            },
-            getLocale: () => 'en'
-        },
-        args: {}
-    };
-    const {VnUser, AccessToken, SignInLog} = models;
-    describe('when credentials are correct', () => {
-        it('should return the token if user uses email', async() => {
-            let login = await VnUser.signIn(unAuthCtx, 'salesAssistant@mydomain.com', 'nightmare');
-            let accessToken = await AccessToken.findById(login.token);
-            let ctx = {req: {accessToken: accessToken}};
-            let signInLog = await SignInLog.find({where: {token: accessToken.id}});
-
-            expect(signInLog.length).toEqual(0);
-
-            await VnUser.logout(ctx.req.accessToken.id);
-        });
-
-        it('should return the token', async() => {
-            let login = await VnUser.signIn(unAuthCtx, 'salesAssistant', 'nightmare');
-            let accessToken = await AccessToken.findById(login.token);
-            let ctx = {req: {accessToken: accessToken}};
-
-            expect(login.token).toBeDefined();
-
-            await VnUser.logout(ctx.req.accessToken.id);
-        });
-
-        it('should return the token if the user doesnt exist but the client does', async() => {
-            let login = await VnUser.signIn(unAuthCtx, 'PetterParker', 'nightmare');
-            let accessToken = await AccessToken.findById(login.token);
-            let ctx = {req: {accessToken: accessToken}};
-
-            expect(login.token).toBeDefined();
-
-            await VnUser.logout(ctx.req.accessToken.id);
-        });
-    });
-
-    describe('when credentials are incorrect', () => {
-        it('should throw a 401 error', async() => {
-            let error;
-
-            try {
-                await VnUser.signIn(unAuthCtx, 'IDontExist', 'TotallyWrongPassword');
-            } catch (e) {
-                error = e;
-            }
-
-            expect(error).toBeDefined();
-            expect(error.statusCode).toBe(401);
-            expect(error.code).toBe('LOGIN_FAILED');
-        });
-    });
-
-    describe('when two-factor auth is required', () => {
-        it('should throw a 403 error', async() => {
-            const employee = await VnUser.findById(employeeId);
-            const tx = await VnUser.beginTransaction({});
-
-            let error;
-            try {
-                const options = {transaction: tx};
-                await employee.updateAttribute('twoFactor', 'email', options);
-
-                await VnUser.signIn(unAuthCtx, 'employee', 'nightmare', options);
-                await tx.rollback();
-            } catch (e) {
-                await tx.rollback();
-                error = e;
-            }
-
-            expect(error).toBeDefined();
-            expect(error.statusCode).toBe(403);
-            expect(error.code).toBe('REQUIRES_2FA');
-        });
-    });
-
-    describe('when passExpired', () => {
-        it('should throw a passExpired error', async() => {
-            const tx = await VnUser.beginTransaction({});
-            const employee = await VnUser.findById(employeeId);
-            const yesterday = Date.vnNew();
-            yesterday.setDate(yesterday.getDate() - 1);
-
-            let error;
-            try {
-                const options = {transaction: tx};
-                await employee.updateAttribute('passExpired', yesterday, options);
-
-                await VnUser.signIn(unAuthCtx, 'employee', 'nightmare', options);
-                await tx.rollback();
-            } catch (e) {
-                await tx.rollback();
-                error = e;
-            }
-
-            expect(error).toBeDefined();
-            expect(error.statusCode).toBe(400);
-            expect(error.message).toBe('Pass expired');
-        });
-    });
-});

back/methods/vn-user/specs/signIn.js

@@ -0,0 +1,41 @@
+const {models} = require('vn-loopback/server/server');
+
+describe('VnUser signIn()', () => {
+    describe('when credentials are correct', () => {
+        it('should return the token', async() => {
+            let login = await models.VnUser.signIn('salesAssistant', 'nightmare');
+            let accessToken = await models.AccessToken.findById(login.token);
+            let ctx = {req: {accessToken: accessToken}};
+
+            expect(login.token).toBeDefined();
+
+            await models.VnUser.signOut(ctx);
+        });
+
+        it('should return the token if the user doesnt exist but the client does', async() => {
+            let login = await models.VnUser.signIn('PetterParker', 'nightmare');
+            let accessToken = await models.AccessToken.findById(login.token);
+            let ctx = {req: {accessToken: accessToken}};
+
+            expect(login.token).toBeDefined();
+
+            await models.VnUser.signOut(ctx);
+        });
+    });
+
+    describe('when credentials are incorrect', () => {
+        it('should throw a 401 error', async() => {
+            let error;
+
+            try {
+                await models.VnUser.signIn('IDontExist', 'TotallyWrongPassword');
+            } catch (e) {
+                error = e;
+            }
+
+            expect(error).toBeDefined();
+            expect(error.statusCode).toBe(401);
+            expect(error.code).toBe('LOGIN_FAILED');
+        });
+    });
+});

back/methods/vn-user/specs/signOut.js

@@ -0,0 +1,42 @@
+const {models} = require('vn-loopback/server/server');
+
+describe('VnUser signOut()', () => {
+    it('should logout and remove token after valid login', async() => {
+        let loginResponse = await models.VnUser.signOut('buyer', 'nightmare');
+        let accessToken = await models.AccessToken.findById(loginResponse.token);
+        let ctx = {req: {accessToken: accessToken}};
+
+        let logoutResponse = await models.VnUser.signOut(ctx);
+        let tokenAfterLogout = await models.AccessToken.findById(loginResponse.token);
+
+        expect(logoutResponse).toBeTrue();
+        expect(tokenAfterLogout).toBeNull();
+    });
+
+    it('should throw a 401 error when token is invalid', async() => {
+        let error;
+        let ctx = {req: {accessToken: {id: 'invalidToken'}}};
+
+        try {
+            response = await models.VnUser.signOut(ctx);
+        } catch (e) {
+            error = e;
+        }
+
+        expect(error).toBeDefined();
+        expect(error.statusCode).toBe(401);
+    });
+
+    it('should throw an error when no token is passed', async() => {
+        let error;
+        let ctx = {req: {accessToken: null}};
+
+        try {
+            response = await models.VnUser.signOut(ctx);
+        } catch (e) {
+            error = e;
+        }
+
+        expect(error).toBeDefined();
+    });
+});

back/methods/vn-user/specs/validate-auth.spec.js

@@ -1,52 +0,0 @@
-const {models} = require('vn-loopback/server/server');
-
-describe('VnUser validate-auth()', () => {
-    describe('validateAuth', () => {
-        it('should signin if data is correct', async() => {
-            await models.AuthCode.create({
-                userFk: 9,
-                code: '555555',
-                expires: Date.vnNow() + (60 * 1000)
-            });
-            const token = await models.VnUser.validateAuth('developer', 'nightmare', '555555');
-
-            expect(token.token).toBeDefined();
-        });
-    });
-
-    describe('validateCode', () => {
-        it('should throw an error for a non existent code', async() => {
-            let error;
-            try {
-                await models.VnUser.validateCode('developer', '123456');
-            } catch (e) {
-                error = e;
-            }
-
-            expect(error).toBeDefined();
-            expect(error.statusCode).toBe(400);
-            expect(error.message).toEqual('Invalid or expired verification code');
-        });
-
-        it('should throw an error when a code doesn`t match the login username', async() => {
-            let error;
-            let authCode;
-            try {
-                authCode = await models.AuthCode.create({
-                    userFk: 1,
-                    code: '555555',
-                    expires: Date.vnNow() + (60 * 1000)
-                });
-
-                await models.VnUser.validateCode('developer', '555555');
-            } catch (e) {
-                authCode && await authCode.destroy();
-                error = e;
-            }
-
-            expect(error).toBeDefined();
-            expect(error.statusCode).toBe(400);
-            expect(error.message).toEqual('Authentication failed');
-        });
-    });
-});

back/methods/vn-user/update-user.js

@@ -1,43 +0,0 @@
-module.exports = Self => {
-    Self.remoteMethodCtx('updateUser', {
-        description: 'Update user data',
-        accepts: [
-            {
-                arg: 'id',
-                type: 'integer',
-                description: 'The user id',
-                required: true,
-                http: {source: 'path'}
-            }, {
-                arg: 'name',
-                type: 'string',
-                description: 'The user name',
-            }, {
-                arg: 'nickname',
-                type: 'string',
-                description: 'The user nickname',
-            }, {
-                arg: 'email',
-                type: 'string',
-                description: 'The user email'
-            }, {
-                arg: 'lang',
-                type: 'any',
-                description: 'The user lang'
-            }, {
-                arg: 'twoFactor',
-                type: 'any',
-                description: 'The user twoFactor'
-            }
-        ],
-        http: {
-            path: `/:id/update-user`,
-            verb: 'PATCH'
-        }
-    });
-
-    Self.updateUser = async(ctx, id, name, nickname, email, lang, twoFactor) => {
-        await Self.userSecurity(ctx, id);
-        await Self.upsertWithWhere({id}, {name, nickname, email, lang, twoFactor});
-    };
-};

back/methods/vn-user/validate-auth.js

@@ -1,66 +0,0 @@
-const UserError = require('vn-loopback/util/user-error');
-
-module.exports = Self => {
-    Self.remoteMethod('validateAuth', {
-        description: 'Login a user with username/email and password',
-        accepts: [
-            {
-                arg: 'user',
-                type: 'String',
-                description: 'The user name or email',
-                required: true
-            },
-            {
-                arg: 'password',
-                type: 'String',
-                description: 'The password'
-            },
-            {
-                arg: 'code',
-                type: 'String',
-                description: 'The auth code'
-            }
-        ],
-        returns: {
-            type: 'object',
-            root: true
-        },
-        http: {
-            path: `/validate-auth`,
-            verb: 'POST'
-        }
-    });
-
-    Self.validateAuth = async(username, password, code, options) => {
-        const myOptions = {};
-        if (typeof options == 'object')
-            Object.assign(myOptions, options);
-
-        const token = Self.validateLogin(username, password);
-        await Self.validateCode(username, code, myOptions);
-        return token;
-    };
-
-    Self.validateCode = async(username, code, myOptions) => {
-        const {AuthCode} = Self.app.models;
-
-        const authCode = await AuthCode.findOne({
-            where: {
-                code: code
-            }
-        }, myOptions);
-
-        const expired = authCode && Date.vnNow() > authCode.expires;
-        if (!authCode || expired)
-            throw new UserError('Invalid or expired verification code');
-
-        const user = await Self.findById(authCode.userFk, {
-            fields: ['name', 'twoFactor']
-        }, myOptions);
-
-        if (user.name.toLowerCase() !== username.toLowerCase())
-            throw new UserError('Authentication failed');
-
-        await authCode.destroy(myOptions);
-    };
-};