no message

.editorconfig

+# EditorConfig helps developers define and maintain consistent
+# coding styles between different editors and IDEs
+# editorconfig.org
+
+root = true
+
+
+[*]
+
+# Change these settings to your own preference
+indent_style = space
+indent_size = 4
+
+# We recommend you to keep these unchanged
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[Makefile]
+indent_style = tab
+
+[*.md]
+trim_trailing_whitespace = false
+

.gitignore

+
+# Created by https://www.gitignore.io/api/node
+
+### Node ###
+# Logs
+logs
+*.log
+npm-debug.log*
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+
+# nyc test coverage
+.nyc_output
+
+# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (http://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+node_modules
+jspm_packages
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+local
+.idea
+build
+src/**/*.yaml
+!src/configs/template.yaml
+
+# Firebase
+*firebase*.json
+
+# IDE - VSCode
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+
+
+.DS_Store

.gitlab-ci.yml

+# Required
+image: docker:17.03.0-ce
+services:
+    - docker:17.03.0-ce-dind
+# --------
+
+stages:
+    - build
+    - release
+    - deploy
+
+.build: &build_template
+    stage: build
+    image: vothanhkiet/alpine-node-builder:latest
+    script:
+        - npm install --quiet
+        - gulp build:staging
+    cache:
+        untracked: true
+        key: "$CI_JOB_STAGE/$CI_COMMIT_REF_NAME"
+        paths:
+            - node_modules/
+    artifacts:
+        name: archive
+        expire_in: 1 week
+        paths:
+            - release/
+
+.release: &release_template
+    stage: release
+    before_script:
+        - docker login -u gitlab-ci-token -p $CI_BUILD_TOKEN registry.ventuso.net
+    script:
+        - cd release
+        - docker build -t $CI_REGISTRY_IMAGE:$CI_BUILD_REF_NAME --rm=true .
+        - docker push $CI_REGISTRY_IMAGE:$CI_BUILD_REF_NAME
+
+.deploy: &deploy_template
+    stage: deploy
+    image: vothanhkiet/alpine-node:7.2.1
+    before_script:
+        - eval $(ssh-agent -s)
+        - mkdir -p ~/.ssh
+        - echo "$SSH_ID_KEY" >> ~/.ssh/id_rsa
+        - chmod 400 ~/.ssh/id_rsa
+        - echo -e "Host *\n\tStrictHostKeyChecking no\n\n" > ~/.ssh/config
+    script:
+        - echo "Deploy to staging server"
+        - ssh $USER@$HOST "mkdir -p $DEPLOY_FOLDER && cd $DEPLOY_FOLDER && curl $DEPLOY_PLAN > docker-compose.yaml && docker-compose pull && docker-compose down && docker-compose up -d"
+
+build:
+    <<: *build_template
+    only:
+        - develop
+        - test
+        - staging
+        - master
+        - tags
+
+release:
+    <<: *release_template
+    only:
+        - develop
+        - test
+        - staging
+        - master
+        - tags
+
+deploy_dev:
+    <<: *deploy_template
+    variables:
+        DEPLOY_FOLDER: ~/projects/$CI_PROJECT_NAMESPACE/$CI_PROJECT_NAME-$CI_COMMIT_REF_NAME
+        DEPLOY_PLAN: $DEV_DEPLOY_PLAN
+        USER: $VENTUSO_PC3_USER
+        HOST: $VENTUSO_PC3_IP
+        SSH_ID_KEY: $SSH_PRIVATE_KEY
+    only:
+        - develop
+
+deploy_staging:
+    <<: *deploy_template
+    variables:
+        DEPLOY_FOLDER: ~/projects/$CI_PROJECT_NAMESPACE/$CI_PROJECT_NAME-$CI_COMMIT_REF_NAME
+        DEPLOY_PLAN: $STAGING_DEPLOY_PLAN
+        USER: $VENTUSO_PC3_USER
+        HOST: $VENTUSO_PC3_IP
+        SSH_ID_KEY: $SSH_PRIVATE_KEY
+    only:
+        - staging

.nycrc

+{
+    "include": [
+        "src/**/*.ts"
+    ],
+    "exclude": [
+        "node_modules/",
+        "build/"
+    ],
+    "extension": [
+        ".ts"
+    ],
+    "require": [
+        "ts-node/register --project ./"
+    ],
+    "reporter": [
+        "text-summary",
+        "html"
+    ],
+    "sourceMap": true,
+    "instrument": true
+}

.vscode/launch.json

+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "node",
+            "request": "launch",
+            "protocol": "inspector",
+            "name": "Debug server.ts",
+            "stopOnEntry": false,
+            "program": "${workspaceRoot}/src/server.ts",
+            "cwd": "${workspaceRoot}",
+            "sourceMaps": true,
+            "preLaunchTask": null,
+            "runtimeExecutable": null,
+            "runtimeArgs": [
+                "--nolazy"
+            ],
+            "console": "integratedTerminal",
+            "outFiles": [
+                "${workspaceRoot}/build/**/*.js"
+            ],
+            "env": {
+                "NODE_ENV": "development",
+                "TZ" : "UTC"
+            }
+        },
+        {
+            "type": "node",
+            "request": "launch",
+            "protocol": "inspector",
+            "name": "Profile server.ts",
+            "stopOnEntry": false,
+            "program": "${workspaceRoot}/src/server.ts",
+            "cwd": "${workspaceRoot}",
+            "sourceMaps": true,
+            "preLaunchTask": null,
+            "runtimeExecutable": null,
+            "runtimeArgs": [
+                "--nolazy",
+                "--prof"
+            ],
+            "console": "integratedTerminal",
+            "outFiles": [
+                "${workspaceRoot}/build/**/*.js"
+            ],
+            "env": {
+                "NODE_ENV": "development",
+                "TZ" : "UTC"
+            }
+        },
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "Debug mocha",
+            "protocol": "auto",
+            "program": "${workspaceRoot}/node_modules/mocha/bin/_mocha",
+            "stopOnEntry": false,
+            "args": ["test/**/*.ts", "--no-timeouts"],
+            "cwd": "${workspaceRoot}",
+            "runtimeExecutable": null,
+            "env": {
+                "NODE_ENV": "test"
+            }
+        },
+        {
+            "type": "node",
+            "request": "attach",
+            "protocol": "auto",
+            "name": "Attach to Process",
+            "sourceMaps": true,
+            "port": 5858,
+            "outFiles": ["${workspaceRoot}/build/**/*.js"]
+        }
+    ]
+}
\ No newline at end of file

.vscode/tasks.json

+{
+    // See https://go.microsoft.com/fwlink/?LinkId=733558
+    // for the documentation about the tasks.json format
+    "version": "0.1.0",
+    "command": "gulp",
+    "isShellCommand": true,
+    "showOutput": "always",
+    "args": [
+        "--no-color"
+    ],
+    "tasks": [
+        {
+            "taskName": "watch",
+            "args": [],
+            "isBuildCommand": true,
+            "isBackground": false,
+            "problemMatcher": [
+                "$lessCompile",
+                "$tsc",
+                "$jshint"
+            ]
+        },
+        {
+            "taskName": "test",
+            "args": [],
+            "isTestCommand": true
+        }
+    ]
+}
\ No newline at end of file

.yarnclean

+#ignore specific files for tslint
+!lines.js
+!parse.js
+!lintError.js
+#ignore specific files for clean-css
+!url-rewriter.js
+!url-rebase.js
+#ignore specific files for braintree
+!credit_card_defaults.js
+!credit_card_numbers.js
+!merchant_account.js
+!nonces.js
+!transaction_amounts.js
+!venmo_sdk.js
+!test.js
+
+# test directories
+__tests__
+test
+tests
+powered-test
+
+# asset directories
+docs
+doc
+website
+images
+assets
+
+# examples
+example
+examples
+
+# code coverage directories
+coverage
+.nyc_output
+
+# build scripts
+Makefile
+Gulpfile.js
+Gruntfile.js
+
+# configs
+.tern-project
+.gitattributes
+.editorconfig
+.*ignore
+.eslintrc
+.jshintrc
+.flowconfig
+.documentup.json
+.yarn-metadata.json
+.*.yml
+*.yml
+
+# misc
+*.gz
+*.md
+*.markdown
+LICENSE
+LICENSE.BSD
+LICENSE.DOCS
+AUTHORS

Makefile

+install:
+	npm install --silent -g npm
+	npm install --silent -g gulp-cli
+	npm install --silent -g tsc
+	npm install --silent
+
+build: install
+	gulp clean
+	gulp build
+
+release: install
+	gulp clean
+	gulp build:release
+
+clean:
+	gulp clean
+
+docker-up:
+	docker-compose up -d
+
+docker-down:
+	docker-compose down
\ No newline at end of file

README.md

+Ventuso's Visis Service

docker-compose.yml

+version: '2.1'
+services:
+    postgres:
+        image: postgres:9.6.2-alpine
+        ports:
+            - 5432:5432
+        networks:
+            - internal
+        environment:
+            - POSTGRES_PASSWORD=postgres
+            - POSTGRES_USER=postgres
+            - POSTGRES_DB=vivis
+        volumes:
+            - ${PWD}/local/postgres:/var/lib/postgresql/data
+            - ${PWD}/docker/development/postgres/initdb.d:/docker-entrypoint-initdb.d
+    redis:
+        image: redis:3.2.8-alpine
+        ports:
+            - 6379:6379
+        networks:
+            - internal
+        volumes:
+            - ${PWD}/local/redis:/data
+    redis-ui:
+        image: diyan/redis-commander
+        networks:
+            - internal
+        ports:
+            - 3010:8081
+        command: --redis-host redis
+    minio:
+        image: minio/minio:RELEASE.2017-09-29T19-16-56Z
+        networks:
+            - internal
+        ports:
+            - 9000:9000
+        environment:
+            - MINIO_ACCESS_KEY=access_key
+            - MINIO_SECRET_KEY=secret_key
+        command: server /export
+        volumes:
+            - $PWD/local/minio/export:/export
+            - $PWD/local/minio/config:/root/.minio
+    astray:
+        image: registry.ventuso.net/rd/astray:staging
+        networks:
+            - internal
+        ports:
+            - 3005:3000
+        environment:
+            - AWS_ACCESS_KEY_ID=access_key
+            - AWS_SECRET_ACCESS_KEY=secret_key
+            - S3_BUCKET=docker
+            - S3_ENDPOINT=http://minio:9000/
+            - DRIVERS=minio
+    create_bucket:
+        image: garland/aws-cli-docker
+        networks:
+            - internal
+        depends_on:
+            - minio
+        environment:
+            - AWS_ACCESS_KEY_ID=access_key
+            - AWS_SECRET_ACCESS_KEY=secret_key
+            - AWS_DEFAULT_REGION=us-east-1
+        command: >
+            /bin/sh -c "
+            while ! nc -vz minio 9000; do sleep 1; done;
+            echo Connected!;
+            date;
+            aws configure set default.s3.signature_version s3v4;
+            aws configure set default.region us-east-1;
+            aws s3api create-bucket \
+                --bucket docker \
+                --endpoint-url=http://minio:9000;"
+        # Note: https://docs.docker.com/docker-for-mac/networking/
+    # rabbitmq:
+    #     image: rabbitmq:3.6.8-alpine
+    #     container_name: rabbitmq
+    #     ports:
+    #         - 5672:5672
+    #     networks:
+    #         - internal
+    #     volumes:
+    #         - ${PWD}/local/rabbitmq:/var/lib/rabbitmq
+    # elastic:
+    #     image: elasticsearch:5.1.1-alpine
+    #     container_name: elastic
+    #     ports:
+    #         - 9200:9200
+    #     networks:
+    #         - internal
+    # kibana:
+    #     image: kibana:5.1.1
+    #     container_name: kibana
+    #     ports:
+    #         - 3003:5601
+    #     networks:
+    #         - internal
+    #     environment:
+    #         - ELASTICSEARCH_URL=http://elastic:9200
+    #     depends_on:
+    #         - elastic
+    #         - logstash
+    # logstash:
+    #     image: logstash:5.1.1
+    #     container_name: logstash
+    #     networks:
+    #         - internal
+    #     volumes:
+    #         - ./build/logs:/home/logstash/logs
+    #         - ./docker/development/logstash:/logstash
+    #     command: logstash -f /logstash/log.conf
+    #     depends_on:
+    #         - elastic
+
+networks:
+    internal:

docker/development/logstash/log.conf

+input {
+  file {
+    path => "/home/logstash/logs/process.log"
+    type=> "process"
+    start_position => "beginning"
+    codec => "json"
+  }
+}
+filter {
+    date {
+        match => [ "timestamp", "yyyy-MM-dd'T'HH:mm:ss.SSSZ"]
+    }
+}
+output {
+  elasticsearch {
+    hosts => ["elastic:9200"]
+  }
+}

docker/development/postgres/initdb.d/enable_uuid.sql

+CREATE EXTENSION IF NOT EXISTS "uuid-ossp";

docker/production/Dockerfile

+FROM vothanhkiet/alpine-s6-node-native:8.7.0
+WORKDIR /app
+COPY ./app /app
+ADD ./root /
+
+RUN cd /app && \
+    npm install --quiet
+RUN npm rebuild bcrypt --build-from-source
+RUN npm rebuild grpc --build-from-source
+RUN rm -rf /var/cache/apk/* /root/.npm /root/.node-gyp /tmp/* /var/tmp/*
+
+EXPOSE 3000

docker/production/root/etc/services.d/template-service/run

+#!/usr/bin/with-contenv sh
+echo "Download setting from ${CONFIG_URL}"
+curl ${CONFIG_URL} > /app/configs/configuration.yaml
+
+if [ -n "$FIREBASE_URL" ]; then
+    curl ${FIREBASE_URL} > /app/configs/firebase.json
+else
+    echo "Firebase key's URL was not found. Skip"
+fi
+
+cd /app && node server.js

gulpfile.js

+/**
+ * Created by kiettv on 12/16/16.
+ */
+'use strict';
+const argv = require('yargs').argv;
+const path = require('path');
+const gulp = require('gulp');
+const file = require('gulp-file');
+const ts = require('gulp-typescript');
+const clean = require('gulp-clean');
+const server = require('gulp-develop-server');
+const sourcemaps = require('gulp-sourcemaps');
+const uglify = require('gulp-uglify');
+const tslint = require('gulp-tslint');
+const plumber = require('gulp-plumber');
+const zip = require('gulp-zip');
+const jEditor = require('gulp-json-editor');
+const runSequence = require('run-sequence');
+const mocha = require('gulp-spawn-mocha');
+const gUtil = require('gulp-util');
+const istanbul = require('gulp-istanbul');
+const merge = require('merge2');
+const tsProject = ts.createProject('tsconfig.json');
+
+const projects = {
+    bootstrap: 'server.js',
+    folders: {
+        src: 'src',
+        docker: 'docker',
+        build: 'build',
+        dist: 'release',
+        logs: 'logs',
+        coverage: 'coverage',
+        nyc: '.nyc_output',
+        migration: 'src/data/sql/migrations'
+    },
+    files: {
+        tsFiles: ['src/**/*.ts'],
+        nonTsFiles: ['src/**/*.*', 'src/**/*.**', '!src/**/*.ts'],
+        artifact: 'archive.zip',
+        configFiles: ['src/configs/*.yaml', '!src/configs/template.yaml']
+    }
+};
+
+
+const padDate = (segment) => {
+    segment = segment.toString();
+    return segment[1] ? segment : '0' + segment;
+}
+
+const yyyymmddhhmmss = () => {
+    var d = new Date();
+    return d.getFullYear().toString() + padDate(d.getMonth() + 1) + padDate(d.getDate()) + padDate(d.getHours()) + padDate(d.getMinutes()) + padDate(d.getSeconds());
+}
+
+gulp.task('clean', () => {
+    return gulp
+        .src([
+            projects.folders.build,
+            projects.folders.logs,
+            projects.folders.dist,
+            projects.folders.coverage,
+            projects.folders.nyc
+        ], {
+            read: false
+        })
+        .pipe(clean());
+});
+
+gulp.task('files:copy', () => {
+    return gulp.src(projects.files.nonTsFiles)
+        .pipe(plumber())
+        .pipe(gulp.dest(projects.folders.build));
+});
+
+gulp.task('ts:lint', () =>
+    gulp.src(projects.files.tsFiles)
+    .pipe(tslint({
+        configuration: 'tslint.json'
+    }))
+    .pipe(tslint.report({
+        emitError: false
+    }))
+);
+
+gulp.task('ts:lint:release', () =>
+    gulp.src(projects.files.tsFiles)
+    .pipe(tslint({
+        configuration: 'tslint.json'
+    }))
+    .pipe(tslint.report({
+        emitError: true
+    }))
+    .on('error', (error) => {
+        process.exit(1);
+    })
+);
+
+gulp.task('ts:compile', () => {
+    let tsResult = gulp.src(projects.files.tsFiles, {
+            base: projects.folders.src
+        })
+        .pipe(plumber())
+        .pipe(sourcemaps.init())
+        .pipe(tsProject());
+
+    return merge([
+        tsResult.js.pipe(sourcemaps.write('.', {
+            includeContent: false,
+            sourceRoot: () => {
+                return path.join(__dirname, projects.folders.src);
+            }
+        }))
+        .pipe(gulp.dest(projects.folders.build))
+    ]);
+
+});
+
+gulp.task('ts:compile:release', () => {
+    let tsResult = gulp.src(projects.files.tsFiles, {
+            base: projects.folders.src
+        })
+        .pipe(plumber())
+        .pipe(sourcemaps.init())
+        .pipe(tsProject());
+        // .on('error', function (error) {
+        //     process.exit(1);
+        // });
+
+    return merge([
+        tsResult.js.pipe(sourcemaps.write('.', {
+            includeContent: false,
+            sourceRoot: () => {
+                return path.join(__dirname, projects.folders.src);
+            }
+        }))
+        .pipe(gulp.dest(projects.folders.build))
+    ]);
+});
+
+gulp.task('files:copy:package.json', () => {
+    return gulp.src('package.json')
+        .pipe(jEditor(json => {
+            json.devDependencies = {};
+            return json;
+        }))
+        .pipe(gulp.dest(projects.folders.build));
+});
+
+gulp.task('zip', () => {
+    return gulp.src(projects.folders.build + '/**/*', {
+            dot: true
+        })
+        .pipe(zip(projects.files.artifact))
+        .pipe(gulp.dest(projects.folders.dist));
+});
+
+gulp.task('build', (cb) => {
+    runSequence('clean', 'ts:lint', 'files:copy', 'ts:compile', cb);
+});
+
+gulp.task('files:copy:docker', () => {
+    gulp.src(projects.folders.build + '/**')
+        .pipe(gulp.dest(projects.folders.dist + '/app'));
+    gulp.src(projects.folders.docker + '/production/**')
+        .pipe(gulp.dest(projects.folders.dist));
+});
+
+gulp.task('build:production', (cb) => {
+    runSequence('clean', 'ts:lint:release', 'files:copy', 'ts:compile:release', 'files:copy:package.json', 'files:copy:docker', cb)
+});
+
+gulp.task('build:staging', (cb) => {
+    runSequence('clean', 'ts:lint:release', 'files:copy', 'ts:compile:release', 'files:copy:package.json', 'files:copy:docker', cb)
+});
+
+gulp.task('build:release', (cb) => {
+    runSequence('clean', 'ts:lint:release', 'files:copy', 'ts:compile:release', 'files:copy:package.json', cb);
+});
+
+gulp.task('release', (cb) => {
+    runSequence('build:release', 'zip', cb);
+});
+
+gulp.task('test', () => {
+    return gulp.src(['test/*.ts'], {
+            read: false
+        })
+        .pipe(mocha({
+            reporter: 'spec',
+            compilers: 'ts:ts-node/register'
+        }))
+        .on('error', gUtil.log);
+});
+
+gulp.task('watch', ['build'], (cb) => {
+    gulp.watch(projects.files.tsFiles, ['ts:lint', 'ts:compile']);
+    gulp.watch(projects.files.nonTsFiles, ['files:copy']);
+});
+
+gulp.task('server:start', (cb) => {
+    runSequence('files:copy', 'ts:compile', cb);
+    server.listen({
+        path: `${projects.folders.build}/${projects.bootstrap}`
+    }, (error) => {
+        console.log(error);
+    });
+});
+
+gulp.task('server:restart', ['ts:compile'], () => {
+    server.restart();
+});
+
+gulp.task('default', ['server:start'], () => {
+    gulp.watch(projects.files.tsFiles, ['server:restart']);
+});
+
+gulp.task('migrate:compile:knex', () => {
+    return gulp.src(`${projects.folders.src}/knexfile.ts`, {
+            base: projects.folders.src
+        })
+        .pipe(plumber())
+        .pipe(sourcemaps.init())
+        .pipe(tsProject())
+        .pipe(sourcemaps.write('.', {
+            includeContent: false,
+            sourceRoot: () => {
+                return path.join(__dirname, projects.folders.src);
+            }
+        }))
+        .pipe(gulp.dest(projects.folders.build));
+});
+
+gulp.task('migrate:compile:config', () => {
+    return gulp.src(projects.files.configFiles)
+        .pipe(plumber())
+        .pipe(gulp.dest(`${projects.folders.build}/configs`));
+});
+
+gulp.task('migrate:compile:script', () => {
+    return gulp.src([`${projects.folders.migration}/*.ts`, `${projects.folders.src}/libs/constants.ts`, `${projects.folders.src}/data/sql/schema.ts`], {
+            base: projects.folders.src
+        })
+        .pipe(plumber())
+        .pipe(sourcemaps.init())
+        .pipe(tsProject())
+        .pipe(sourcemaps.write('.', {
+            includeContent: false,
+            sourceRoot: () => {
+                return path.join(__dirname, projects.folders.migration);
+            }
+        }))
+        .pipe(gulp.dest(projects.folders.build));
+});
+
+gulp.task('migrate:compile', (cb) => {
+    runSequence('clean', 'migrate:compile:knex', 'migrate:compile:script', 'migrate:compile:config', 'files:copy', cb);
+});
+
+
+gulp.task('migrate:new', () => {
+    if (argv.name != null) {
+        return file(`${yyyymmddhhmmss()}_${argv.name}.ts`,
+            `import * as Bluebird from "bluebird";
+import * as Knex from "knex";
+
+export const up = (knex: Knex, promise: typeof Bluebird): Bluebird<any> => {
+    return promise.resolve();
+};
+
+export const down = (knex: Knex, promise: typeof Bluebird): Bluebird<any> => {
+    return promise.resolve();
+};`).pipe(gulp.dest(projects.folders.migration));
+    }
+});
+
+gulp.task('migrate:latest', () => {
+    return;
+});
+
+gulp.task('migrate:rollback', () => {
+    return;
+});

package.json

+{
+  "name": "template-service",
+  "version": "1.0.0",
+  "description": "template's backend",
+  "main": "build/server.js",
+  "scripts": {
+    "test": "NODE_ENV=test mocha",
+    "coverage": "NODE_ENV=test nyc  --require ts-node/register ./node_modules/.bin/_mocha",
+    "migrate": "gulp migrate:new --name",
+    "prerollback": "gulp migrate:compile",
+    "prelatest": "gulp migrate:compile",
+    "rollback": "cd build && ../node_modules/.bin/knex --knexfile knexfile.js migrate:rollback",
+    "latest": "cd build && ../node_modules/.bin/knex --knexfile knexfile.js migrate:latest",
+    "clean": "gulp clean"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@gitlab.ventuso.net:template/template-service.git"
+  },
+  "keywords": [
+    "rest",
+    "api"
+  ],
+  "author": "Bao Nguyen <baond@ventuso.net>",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/bcrypt": "1.0.0",
+    "@types/bluebird": "3.5.16",
+    "@types/body-parser": "1.16.5",
+    "@types/bookshelf": "0.9.1",
+    "@types/chai": "4.0.4",
+    "@types/chai-http": "3.0.3",
+    "@types/compression": "0.0.34",
+    "@types/dotenv": "4.0.1",
+    "@types/express": "4.0.37",
+    "@types/formidable": "1.0.29",
+    "@types/helmet": "0.0.36",
+    "@types/js-yaml": "3.9.1",
+    "@types/jsonwebtoken": "7.2.3",
+    "@types/knex": "0.0.62",
+    "@types/kue": "0.11.7",
+    "@types/lodash": "4.14.77",
+    "@types/mkdirp": "0.5.1",
+    "@types/mocha": "2.2.43",
+    "@types/moment-timezone": "0.5.0",
+    "@types/node": "8.0.34",
+    "@types/nodemailer": "3.1.3",
+    "@types/nodemailer-direct-transport": "1.0.30",
+    "@types/redis": "2.6.1",
+    "@types/stack-trace": "0.0.28",
+    "@types/twilio": "0.0.9",
+    "@types/uuid": "3.4.2",
+    "@types/winston": "2.3.6",
+    "chai": "4.1.2",
+    "chai-http": "3.0.0",
+    "gulp": "3.9.1",
+    "gulp-clean": "0.3.2",
+    "gulp-develop-server": "0.5.2",
+    "gulp-file": "0.3.0",
+    "gulp-istanbul": "1.1.2",
+    "gulp-json-editor": "2.2.1",
+    "gulp-plumber": "1.1.0",
+    "gulp-sourcemaps": "2.6.1",
+    "gulp-spawn-mocha": "4.0.1",
+    "gulp-tslint": "8.1.2",
+    "gulp-typescript": "3.2.2",
+    "gulp-uglify": "3.0.0",
+    "gulp-util": "latest",
+    "gulp-zip": "4.0.0",
+    "istanbul": "0.4.5",
+    "mocha": "4.0.1",
+    "nyc": "11.2.1",
+    "run-sequence": "2.2.0",
+    "ts-node": "3.3.0",
+    "tslint": "5.7.0",
+    "typescript": "2.5.3"
+  },
+  "dependencies": {
+    "bcrypt": "1.0.3",
+    "bluebird": "3.5.1",
+    "body-parser": "1.18.2",
+    "bookshelf": "0.10.4",
+    "cities": "1.1.2",
+    "compression": "1.7.1",
+    "countryjs": "1.8.0",
+    "dotenv": "4.0.0",
+    "express": "4.16.2",
+    "fcm-node": "1.2.0",
+    "firebase-admin": "5.4.2",
+    "formidable": "1.1.1",
+    "helmet": "3.9.0",
+    "html-to-text": "3.3.0",
+    "inversify": "4.3.0",
+    "js-yaml": "3.10.0",
+    "jsonwebtoken": "8.1.0",
+    "knex": "0.13.0",
+    "kue": "0.11.6",
+    "kue-scheduler": "0.7.4",
+    "le_node": "1.7.1",
+    "lodash": "4.17.4",
+    "mailgen": "2.0.2",
+    "mailgun-js": "0.13.1",
+    "merge2": "1.2.0",
+    "mkdirp": "0.5.1",
+    "moment-range": "3.0.3",
+    "moment-timezone": "0.5.13",
+    "pg": "7.1.2",
+    "redis": "2.8.0",
+    "reflect-metadata": "0.1.10",
+    "s3-uploader": "2.0.3",
+    "source-map-support": "0.5.0",
+    "stack-trace": "0.0.10",
+    "string-format": "0.5.0",
+    "stripe": "5.1.1",
+    "twilio": "3.8.1",
+    "uuid": "3.1.0",
+    "wait-on": "2.0.2",
+    "winston": "2.4.0"
+  }
+}

src/app.ts

+/**
+ * Created by phuongho on 15/08/17.
+ */
+import * as compression from "compression";
+import * as express from "express";
+import * as helmet from "helmet";
+import * as http from "http";
+import * as Bluebird from "bluebird";
+import * as _ from "lodash";
+import Router from "./routes";
+import { ExceptionModel } from "./models";
+import { ErrorCode, HttpStatus, scheduler as Scheduler } from "./libs";
+import { BaseDto } from "./data/sql/models";
+import { Database } from "./data/sql/connection";
+import { Redis } from "./data/redis/redis";
+import { cors, httpError, httpLogger, notFound, recover } from "./middlewares";
+import { json, urlencoded } from "body-parser";
+
+interface Log {
+    error(message: string, meta?: any): void;
+    warn(message: string, meta?: any): void;
+    info(message: string, meta?: any): void;
+    debug(message: string, meta?: any): void;
+}
+export class Application {
+    private app: express.Express;
+    private bind: number;
+    private server: http.Server;
+    private logger: Log;
+    private transportLogger: Log;
+
+    constructor(processLogger?: Log, transportLogger?: Log) {
+        this.logger = processLogger || {
+            error: (message: string, meta?: any): void => { },
+            warn: (message: string, meta?: any): void => { },
+            info: (message: string, meta?: any): void => { },
+            debug: (message: string, meta?: any): void => { },
+        };
+        this.transportLogger = transportLogger || {
+            error: (message: string, meta?: any): void => { },
+            warn: (message: string, meta?: any): void => { },
+            info: (message: string, meta?: any): void => { },
+            debug: (message: string, meta?: any): void => { },
+        };
+
+        this.app = express();
+        this.app.locals.title = "iCondo";
+        this.app.enable("case sensitive routing");
+        this.app.enable("trust proxy");
+        this.app.disable("x-powered-by");
+        this.app.disable("etag");
+
+        this.app.use(json());
+        this.app.use(urlencoded({ extended: false }));
+        this.app.use(helmet());
+        this.app.use(compression());
+        this.app.use(cors());
+        this.app.use(httpLogger(this.transportLogger));
+        this.app.use("/", Router);
+        this.app.use(notFound());
+        this.app.use(httpError(this.logger));
+        this.app.use(recover((error: any, res: express.Response): void => {
+
+            let err: ExceptionModel;
+            if (error.httpStatus != null) {
+                err = error as ExceptionModel;
+            } else if (error instanceof BaseDto.NotFoundError || BaseDto.NoRowsDeletedError || BaseDto.NoRowsUpdatedError) {
+                // DB error: BaseDto.NotFoundError, BaseDto.NoRowsDeletedError, BaseDto.NoRowsUpdatedError
+                err = new ExceptionModel(
+                    ErrorCode.RESOURCE.NOT_FOUND.CODE,
+                    ErrorCode.RESOURCE.NOT_FOUND.MESSAGE,
+                    false,
+                    HttpStatus.NOT_FOUND,
+                );
+            } else {
+                err = ExceptionModel.fromError(ErrorCode.UNKNOWN.GENERIC.CODE, err, true);
+            }
+
+            res.status(err.httpStatus);
+            err.name = undefined;
+            err.httpStatus = undefined;
+            res.json(err);
+        }));
+        process.on("unhandledRejection", (reason: any): void => {
+            this.logger.error("unhandledRejection: " + reason);
+        });
+        process.on("uncaughtException", (err: Error): void => {
+            this.logger.error(err.message, err);
+            // Note: When this happen, the process should be terminated
+            // process.exit(1);
+        });
+    }
+
+    public listen(port: number) {
+        this.logger.info("Wait for others components become available");
+        Bluebird.all([
+            Database.migration(),
+            // Redis.initWithWaiting(),
+            // Scheduler.initWithWaiting(),
+        ]).then(() => {
+            if (process.env.PORT != null) {
+                this.bind = Application.normalizePort(process.env.PORT);
+            } else if (port != null) {
+                this.bind = Application.normalizePort(port);
+            } else {
+                this.bind = 3000;
+            }
+            this.app.set("port", this.bind);
+            this.server = http.createServer(this.app);
+            this.server.on("error", this.onError.bind(this));
+            this.server.on("listening", this.onListening.bind(this));
+            this.server.listen(this.bind);
+        }).catch(err => {
+            this.logger.error(err.message, err);
+        });
+    }
+
+    public getExpressInstance(): express.Express {
+        return this.app;
+    }
+
+    private onListening() {
+        let addr = this.server.address();
+        let bind = typeof addr === "string" ? "pipe " + addr : "port " + addr.port;
+        this.logger.info("Listening on " + bind);
+    }
+
+    private onError(error: any) {
+        if (error.syscall !== "listen") {
+            throw error;
+        }
+
+        // handle specific listen errors with friendly messages
+        switch (error.code) {
+            case "EACCES":
+                this.logger.error(this.bind + " requires elevated privileges");
+                process.exit(1);
+                break;
+            case "EADDRINUSE":
+                this.logger.error(this.bind + " is already in use");
+                process.exit(1);
+                break;
+            default:
+                throw error;
+        }
+    }
+
+    private static normalizePort(val: any) {
+        let port = parseInt(val, 10);
+        if (isNaN(port)) {
+            return val;
+        }
+        if (port >= 0) {
+            return port;
+        }
+        return false;
+    }
+}
+
+export default Application;

src/configs/template.yaml

+port: 3000
+
+database:
+    postgres:
+        host: 127.0.0.1
+        port: 5432
+        user: postgres
+        password: postgres
+        database: vivis
+        charset: utf8mb4
+        debug: false
+    redis:
+        host: redis
+        port: 6379
+        db: "0"
+        prefix: dev
+    firebase:
+        file: firebase.json
+        database: https://vivis-dev.firebaseio.com
+
+scheduler:
+    debug: false
+    prefix: "dev:vivis:scheduler:"
+    skipConfig: false
+    restore: true
+    redis:
+        host: localhost
+        port: 6379
+        db: "0"
+
+mailer:
+    # Mailgun option
+    mailGun:
+        apiKey: <your api key>
+        domain: <your domain>
+        sender: <your marketing email>
+    generator:
+        name: foobar
+        link: www.foobar.com
+        logo: foobar
+        iOSAppUrl: <your iOS app url>
+        androidAppUrl: <your andoird app url>
+        privacyPolicyUrl: <your privacy policy app url>
+        contactEmail: <your contact email>
+
+session:
+    expire: 30 # days
+    whiteList:
+        - test
+
+log:
+    # If false, prevent application from exist when something odd happen.
+    exitOnError: false
+    # Console logging, use in development only.
+    console:
+        level: debug
+        handleExceptions: true
+        timestamp: true
+        json: false
+        colorize: true
+    # File logging, file will be put in "logs" folder.
+    file:
+        process:
+            level: debug # Minimum log level which will be appear, Note: error > info > verbose > debug.
+            name: process.log
+            maxsize: 5242880
+            maxFiles: 1
+            handleExceptions: true
+            humanReadableUnhandledException: false
+            json: true
+            colorize: true
+        transport:
+            level: debug # Minimum log level which will be appear, Note: error > info > verbose > debug.
+            name: transport.log
+            maxsize: 5242880
+            maxFiles: 1
+            handleExceptions: true
+            humanReadableUnhandledException: false
+            json: true
+            colorize: true
+    logentries:
+        processToken:
+        transportToken:
+
+sms:
+    accountSid: <your sid>
+    authToken: <your token>
+    area: "+84"
+    sender: <your sender>
+    force: false
+    sandbox: false
+    sendEmail: false # if sendEmail == true ==> send email and don't send sms. Server dev will return code for value
+
+payment:
+    brainTree:
+        merchantID: <your Merchant ID:>
+        publicKey: <your public key>
+        privateKey: <your private Key>
+
+storage:
+    awsBucketName: ventuso
+    opts:
+        aws:
+            path: images/
+            region: us-west-2
+            acl: public-read
+            accessKeyId: <Your access key here>
+            secretAccessKey: <Your secret key here>
+
+fcm:
+    serverKey: <Your FCM key here>
+
+
+
+
+

src/data/application.repository.ts

+/**
+ * Created by phuongho on 15/08/17.
+ */
+import * as Promise from "bluebird";
+import * as Schema from "../data/sql/schema";
+import { ApplicationDto } from "./sql/models";
+import { ApplicationModel } from "../models";
+import { BaseRepository, Log } from "./base.repository";
+import { injectable, inject } from "inversify";
+
+@injectable()
+export class ApplicationRepository extends BaseRepository<ApplicationDto, ApplicationModel> {
+    constructor( @inject("Logger") log?: Log) {
+        super(ApplicationDto, ApplicationModel, log);
+    }
+}
+
+export default ApplicationRepository;

src/data/articles.respository.ts

+/**
+ * Created by Anh Nga on 13/10/2017.
+ */
+import * as Promise from "bluebird";
+import * as Schema from "../data/sql/schema";
+import { BaseRepository, Log } from "./base.repository";
+import { CollectionWrap, LanguageModel } from "./../models";
+import { ARTICLES_TABLE_SCHEMA } from "./sql/schema";
+import { ArticlesDto } from "./sql/models";
+import { injectable, inject } from "inversify";
+
+@injectable()
+export class ArticlesRepository extends BaseRepository<ArticlesDto, LanguageModel> {
+    constructor( @inject("Logger") log?: Log) {
+        super(ArticlesDto, LanguageModel, log);
+    }
+
+    /**
+    * search language
+    * @param searchParams
+    * @param offset
+    * @param limit
+    * @param related
+    * @param filters
+    * @returns {Promise<any[]>}
+    */
+    public search(searchParams: any = {}, offset: number, limit: number, related = [], filters = []): Promise<CollectionWrap<LanguageModel>> {
+        let keyword = searchParams.key || null;
+        limit = limit || null;
+        offset = offset || null;
+
+        let query = () => {
+            return (q): void => {
+                q.where(`${Schema.LANGUAGE_TABLE_SCHEMA.TABLE_NAME}.${Schema.LANGUAGE_TABLE_SCHEMA.FIELDS.IS_DELETED}`, false);
+                if (searchParams.key) {
+                    q.where(q1 => {
+                        q1.where(`${Schema.LANGUAGE_TABLE_SCHEMA.TABLE_NAME}.${Schema.LANGUAGE_TABLE_SCHEMA.FIELDS.NAME}`, "ILIKE", `%${keyword}%`);
+                    });
+                }
+                let orderBy = searchParams.orderBy || `${Schema.LANGUAGE_TABLE_SCHEMA.TABLE_NAME}.${Schema.LANGUAGE_TABLE_SCHEMA.FIELDS.PRIORITY}`;
+                let orderType = searchParams.orderType || "DESC";
+                q.orderBy(orderBy, orderType);
+            };
+        };
+        return this.queryByPage(query(), offset, limit, related, filters);
+    }
+
+}
+export default ArticlesRepository;

src/data/assign_presentation.repository.ts

+import { Log } from "./../libs/logger";
+import { ASSIGN_PRESENTATION_TABLE_SCHEMA } from "./sql/schema";
+import { CollectionWrap } from "./../models/collections";
+import { BaseRepository } from "./base.repository";
+import { AssignPresentationDto } from "./sql/models";
+import { AssignPresentationModel } from "../models";
+import * as Schema from "../data/sql/schema";
+import * as Promise from "bluebird";
+import { injectable, inject } from "inversify";
+
+@injectable()
+export class AssignPresentationRepository extends BaseRepository<AssignPresentationDto, AssignPresentationModel> {
+    constructor( @inject("Logger") log?: Log) {
+        super(AssignPresentationDto, AssignPresentationModel, log);
+    }
+}
+export default AssignPresentationRepository;

src/data/category.respository.ts

+/**
+ * Created by Anh Nga on 13/10/2017.
+ */
+import * as Promise from "bluebird";
+import * as Schema from "../data/sql/schema";
+import { BaseRepository, Log } from "./base.repository";
+import { CollectionWrap, CategoryModel } from "./../models";
+import { CATEGORY_TABLE_SCHEMA } from "./sql/schema";
+import { CategoryDto } from "./sql/models";
+import { injectable, inject } from "inversify";
+
+@injectable()
+export class CategoryRepository extends BaseRepository<CategoryDto, CategoryModel> {
+    constructor( @inject("Logger") log?: Log) {
+        super(CategoryDto, CategoryModel, log);
+    }
+
+    /**
+    * search category
+    * @param searchParams
+    * @param offset
+    * @param limit
+    * @param related
+    * @param filters
+    * @returns {Promise<any[]>}
+    */
+    public search(searchParams: any = {}, offset: number, limit: number, related = [], filters = []): Promise<CollectionWrap<CategoryModel>> {
+        let keyword = searchParams.key || null;
+        limit = limit || null;
+        offset = offset || null;
+
+        let query = () => {
+            return (q): void => {
+                q.where(`${Schema.CATEGORY_TABLE_SCHEMA.TABLE_NAME}.${Schema.CATEGORY_TABLE_SCHEMA.FIELDS.IS_DELETED}`, false);
+                if (searchParams.key) {
+                    q.where(q1 => {
+                        q1.where(`${Schema.CATEGORY_TABLE_SCHEMA.TABLE_NAME}.${Schema.CATEGORY_TABLE_SCHEMA.FIELDS.NAME}`, "ILIKE", `%${keyword}%`);
+                    });
+                }
+                let orderBy = searchParams.orderBy || `${Schema.CATEGORY_TABLE_SCHEMA.TABLE_NAME}.${Schema.CATEGORY_TABLE_SCHEMA.FIELDS.ID}`;
+                let orderType = searchParams.orderType || "DESC";
+                q.orderBy(orderBy, orderType);
+            };
+        };
+        return this.queryByPage(query(), offset, limit, related, filters);
+    }
+
+}
+export default CategoryRepository;

src/data/device.repository.ts

+/**
+ * Created by phuongho on 15/08/17.
+ */
+import * as Promise from "bluebird";
+import * as Schema from "../data/sql/schema";
+import { BaseRepository, Log } from "./base.repository";
+import { DeviceDto } from "./sql/models";
+import { DeviceModel } from "../models";
+import { injectable, inject } from "inversify";
+
+@injectable()
+export class DeviceRepository extends BaseRepository<DeviceDto, DeviceModel> {
+    constructor( @inject("Logger") log?: Log) {
+        super(DeviceDto, DeviceModel, log);
+    }
+
+    public findByUserId(userId: string, related = [], filters = []): Promise<DeviceModel> {
+        return this.findOneByQuery(q => {
+            q.where(Schema.DEVICE_TABLE_SCHEMA.FIELDS.USER_ID, userId);
+        }, related, filters);
+    }
+
+    public findByDeviceId(deviceId: string, related = [], filters = []): Promise<DeviceModel> {
+        return this.findOneByQuery(q => {
+            q.where(Schema.DEVICE_TABLE_SCHEMA.FIELDS.DEVICE_ID, deviceId);
+        }, related, filters);
+    }
+
+    public getDevicesByUserId(userId: string): Promise<DeviceModel[]> {
+        if (userId == null || userId === "") {
+            return Promise.resolve([]);
+        }
+        return this.findByQuery(q => {
+            q.where(Schema.DEVICE_TABLE_SCHEMA.FIELDS.USER_ID, userId);
+        }, ["user"]);
+    }
+}
+export default DeviceRepository;

src/data/index.ts

+/**
+ * Created by phuongho on 15/08/17.
+ */
+import { logger } from "../libs";
+
+import { ApplicationRepository } from "./application.repository";
+import { DeviceRepository } from "./device.repository";
+import { MediaRepository } from "./media.repository";
+import { PackageRepository } from "./package.repository";
+import { PresentationRepository } from "./presentation.repository";
+import { RoleRepository } from "./role.repository";
+import { SessionRepository } from "./session.repository";
+import { SettingRepository } from "./setting.repository";
+import { TagRepository } from "./tag.repository";
+import { UserPackageRepository } from "./user_package.repository";
+import { UserPresentationRepository } from "./user_presentation.repository";
+import { AssignPresentationRepository } from "./assign_presentation.repository";
+import { UserCodeRepository } from "./user_code.repository";
+import { UserRepository } from "./user.repository";
+import { UserTagRepository } from "./user_tag.repository";
+import { LanguageRepository } from "./language.respository";
+import { CategoryRepository } from "./category.respository";
+import { ArticlesRepository } from "./articles.respository";
+
+export { ApplicationRepository } from "./application.repository";
+export { BaseRepository } from "./base.repository";
+export { DeviceRepository } from "./device.repository";
+export { MediaRepository } from "./media.repository";
+export { PackageRepository } from "./package.repository";
+export { PresentationRepository } from "./presentation.repository";
+export { RoleRepository } from "./role.repository";
+export { SessionRepository } from "./session.repository";
+export { SettingRepository } from "./setting.repository";
+export { TagRepository } from "./tag.repository";
+export { UserPackageRepository } from "./user_package.repository";
+export { UserPresentationRepository } from "./user_presentation.repository";
+export { AssignPresentationRepository } from "./assign_presentation.repository";
+export { UserCodeRepository } from "./user_code.repository";
+export { UserRepository } from "./user.repository";
+export { UserTagRepository } from "./user_tag.repository";
+export { LanguageRepository } from "./language.respository";
+export { CategoryRepository } from "./category.respository";
+export { ArticlesRepository } from "./articles.respository";
+
+

src/data/language.respository.ts

+/**
+ * Created by Anh Nga on 13/10/2017.
+ */
+import * as Promise from "bluebird";
+import * as Schema from "../data/sql/schema";
+import { BaseRepository, Log } from "./base.repository";
+import { CollectionWrap, LanguageModel } from "./../models";
+import { LANGUAGE_TABLE_SCHEMA } from "./sql/schema";
+import { LanguageDto } from "./sql/models";
+import { injectable, inject } from "inversify";
+
+@injectable()
+export class LanguageRepository extends BaseRepository<LanguageDto, LanguageModel> {
+    constructor( @inject("Logger") log?: Log) {
+        super(LanguageDto, LanguageModel, log);
+    }
+
+    /**
+    * search language
+    * @param searchParams
+    * @param offset
+    * @param limit
+    * @param related
+    * @param filters
+    * @returns {Promise<any[]>}
+    */
+    public search(searchParams: any = {}, offset: number, limit: number, related = [], filters = []): Promise<CollectionWrap<LanguageModel>> {
+        let keyword = searchParams.key || null;
+        limit = limit || null;
+        offset = offset || null;
+
+        let query = () => {
+            return (q): void => {
+                q.where(`${Schema.LANGUAGE_TABLE_SCHEMA.TABLE_NAME}.${Schema.LANGUAGE_TABLE_SCHEMA.FIELDS.IS_DELETED}`, false);
+                if (searchParams.key) {
+                    q.where(q1 => {
+                        q1.where(`${Schema.LANGUAGE_TABLE_SCHEMA.TABLE_NAME}.${Schema.LANGUAGE_TABLE_SCHEMA.FIELDS.NAME}`, "ILIKE", `%${keyword}%`);
+                    });
+                }
+                let orderBy = searchParams.orderBy || `${Schema.LANGUAGE_TABLE_SCHEMA.TABLE_NAME}.${Schema.LANGUAGE_TABLE_SCHEMA.FIELDS.PRIORITY}`;
+                let orderType = searchParams.orderType || "DESC";
+                q.orderBy(orderBy, orderType);
+            };
+        };
+        return this.queryByPage(query(), offset, limit, related, filters);
+    }
+
+}
+export default LanguageRepository;

src/data/media.repository.ts

+/**
+ * Created by phuongho on 15/08/17.
+ */
+import { BaseRepository, Log } from "./base.repository";
+import { MediaDto } from "./sql/models";
+import { MediaModel } from "../models";
+import { injectable, inject } from "inversify";
+
+@injectable()
+export class MediaRepository extends BaseRepository<MediaDto, MediaModel> {
+    constructor( @inject("Logger") log?: Log) {
+        super(MediaDto, MediaModel, log);
+    }
+}
+export default MediaRepository;

src/data/package.repository.ts

+/**
+ * Created by phuongho on 15/08/17.
+ */
+import * as Promise from "bluebird";
+import * as Schema from "../data/sql/schema";
+import { BaseRepository, Log } from "./base.repository";
+import { CollectionWrap, PackageModel } from "./../models";
+import { PACKAGE_TABLE_SCHEMA } from "./sql/schema";
+import { PackageDto } from "./sql/models";
+import { injectable, inject } from "inversify";
+
+@injectable()
+export class PackageRepository extends BaseRepository<PackageDto, PackageModel> {
+    constructor( @inject("Logger") log?: Log) {
+        super(PackageDto, PackageModel, log);
+    }
+
+    /**
+    * search Package
+    * @param searchParams
+    * @param offset
+    * @param limit
+    * @param related
+    * @param filters
+    * @returns {Promise<any[]>}
+    */
+    public search(searchParams: any = {}, offset: number, limit: number, related = [], filters = []): Promise<CollectionWrap<PackageModel>> {
+        let keyword = searchParams.key || null;
+        limit = limit || null;
+        offset = offset || null;
+
+        let query = () => {
+            return (q): void => {
+                q.where(`${Schema.PACKAGE_TABLE_SCHEMA.TABLE_NAME}.${Schema.PACKAGE_TABLE_SCHEMA.FIELDS.IS_DELETED}`, false);
+                if (searchParams.key) {
+                    q.where(q1 => {
+                        q1.where(`${Schema.PACKAGE_TABLE_SCHEMA.TABLE_NAME}.${Schema.PACKAGE_TABLE_SCHEMA.FIELDS.NAME}`, "ILIKE", `%${keyword}%`);
+                    });
+                }
+                let orderBy = searchParams.orderBy || `${Schema.PACKAGE_TABLE_SCHEMA.TABLE_NAME}.${Schema.PACKAGE_TABLE_SCHEMA.FIELDS.PRIORITY}`;
+                let orderType = searchParams.orderType || "ASC";
+                q.orderBy(orderBy, orderType);
+            };
+        };
+        return this.queryByPage(query(), offset, limit, related, filters);
+    }
+
+}
+export default PackageRepository;

src/data/presentation.repository.ts

+/**
+ * Created by phuongho on 15/08/17.
+ */
+import * as Promise from "bluebird";
+import * as Schema from "../data/sql/schema";
+import { BaseRepository, Log } from "./base.repository";
+import { CollectionWrap, PresentationModel } from "./../models";
+import { PRESENTATION_TABLE_SCHEMA } from "./sql/schema";
+import { PresentationDto } from "./sql/models";
+import { ROLE } from "./../libs/constants";
+import { injectable, inject } from "inversify";
+
+@injectable()
+export class PresentationRepository extends BaseRepository<PresentationDto, PresentationModel> {
+    constructor( @inject("Logger") log?: Log) {
+        super(PresentationDto, PresentationModel, log);
+    }
+
+    /**
+    * search Presentation
+    * @param searchParams
+    * @param offset
+    * @param limit
+    * @param related
+    * @param filters
+    * @returns {Promise<any[]>}
+    */
+    public search(searchParams: any = {}, offset: number, limit: number, related = [], filters = []): Promise<CollectionWrap<PresentationModel>> {
+        let keyword = searchParams.key || null;
+        limit = limit || null;
+        offset = offset || null;
+
+        let query = () => {
+            return (q): void => {
+                if (searchParams.roleId === ROLE.PRESENTER) {
+                    q.leftJoin(`${Schema.USER_PRESENTATION_TABLE_SCHEMA.TABLE_NAME}`, `${Schema.USER_PRESENTATION_TABLE_SCHEMA.TABLE_NAME}.${Schema.USER_PRESENTATION_TABLE_SCHEMA.FIELDS.PRESENTATION_ID}`, `${Schema.PRESENTATION_TABLE_SCHEMA.TABLE_NAME}.${Schema.PRESENTATION_TABLE_SCHEMA.FIELDS.ID}`);
+                    q.where(`${Schema.USER_PRESENTATION_TABLE_SCHEMA.TABLE_NAME}.${Schema.USER_PRESENTATION_TABLE_SCHEMA.FIELDS.IS_DELETED}`, false);
+                    q.where(`${Schema.USER_PRESENTATION_TABLE_SCHEMA.TABLE_NAME}.${Schema.USER_PRESENTATION_TABLE_SCHEMA.FIELDS.USER_ID}`, searchParams.userId);
+                } else {
+                    if (searchParams.userId) {
+                        q.where(`${Schema.PRESENTATION_TABLE_SCHEMA.TABLE_NAME}.${Schema.PRESENTATION_TABLE_SCHEMA.FIELDS.USER_ID}`, searchParams.userId);
+                    }
+                }
+                q.where(`${Schema.PRESENTATION_TABLE_SCHEMA.TABLE_NAME}.${Schema.PRESENTATION_TABLE_SCHEMA.FIELDS.IS_DELETED}`, false);
+                if (searchParams.key) {
+                    q.where(q1 => {
+                        q1.where(`${Schema.PRESENTATION_TABLE_SCHEMA.TABLE_NAME}.${Schema.PRESENTATION_TABLE_SCHEMA.FIELDS.TITLE}`, "ILIKE", `%${keyword}%`);
+                    });
+                }
+                let orderBy = searchParams.orderBy || `${Schema.PRESENTATION_TABLE_SCHEMA.TABLE_NAME}.${Schema.PRESENTATION_TABLE_SCHEMA.FIELDS.PRIORITY}`;
+                let orderType = searchParams.orderType || "ASC";
+                q.orderBy(orderBy, orderType);
+            };
+        };
+        return this.queryByPage(query(), offset, limit, related, filters);
+    }
+
+}
+export default PresentationRepository;

src/data/redis/redis.ts

+import * as Bluebird from "bluebird";
+import {ClientOpts, Multi, RedisClient} from "redis";
+import * as _ from "lodash";
+import {config as Configuration, logger as Logger, Utils} from "../../libs";
+const waitOn = require("wait-on");
+const RedisLib = require("redis");
+Bluebird.promisifyAll(RedisLib.Multi.prototype);
+Bluebird.promisifyAll(RedisLib.RedisClient.prototype);
+
+declare module "redis" {
+    export interface Multi extends NodeJS.EventEmitter {
+        constructor();
+        execAsync(...args: any[]): Bluebird<any>;
+    }
+    export interface RedisClient extends NodeJS.EventEmitter {
+        decrAsync(...args: any[]): Bluebird<any>;
+        delAsync(...args: any[]): Bluebird<any>;
+        execAsync(...args: any[]): Bluebird<any>;
+        getAsync(...args: any[]): Bluebird<any>;
+        incrAsync(...args: any[]): Bluebird<any>;
+        expireAsync(...args: any[]): Bluebird<any>;
+        saddAsync(...args: any[]): Bluebird<any>;
+        scardAsync(...args: any[]): Bluebird<any>;
+        sdiffAsync(...args: any[]): Bluebird<any>;
+        sdiffstoreAsync(...args: any[]): Bluebird<any>;
+        setAsync(...args: any[]): Bluebird<any>;
+        sinterAsync(...args: any[]): Bluebird<any>;
+        sismemberAsync(...args: any[]): Bluebird<any>;
+        smembersAsync(...args: any[]): Bluebird<any>;
+        smoveAsync(...args: any[]): Bluebird<any>;
+        spopAsync(...args: any[]): Bluebird<any>;
+        srandmemeberAsync(...args: any[]): Bluebird<any>;
+        sremAsync(...args: any[]): Bluebird<any>;
+        sscanAsync(...args: any[]): Bluebird<any>;
+        sunionAsync(...args: any[]): Bluebird<any>;
+        sunionstoreAsync(...args: any[]): Bluebird<any>;
+    }
+}
+
+interface RedisOpts extends ClientOpts {
+    prefix: string;
+}
+
+
+export class RedisConnection {
+    private opts: RedisOpts;
+    private client: RedisClient;
+
+    constructor(opts?: any) {
+        opts = opts || {};
+        let defaultOpts: RedisOpts = {
+            host: "localhost",
+            port: 6379,
+            db: "1",
+            prefix: process.env.NODE_ENV + ":template:service:v1:",
+        };
+
+        this.opts = _.defaultsDeep(opts, defaultOpts) as RedisOpts;
+    }
+
+    public initWithWaiting(): Bluebird<boolean> {
+        if (process.env.NODE_ENV === "test") {
+            return Bluebird.resolve(true);
+        }
+        Logger.info("Wait for redis connection");
+
+        let isComplete = false;
+        return Utils.PromiseLoop(
+            () => {
+                return isComplete === true;
+            },
+            () => {
+                return new Bluebird((resolve, reject) => {
+                    waitOn({
+                        resources: [`tcp:${this.opts.host}:${this.opts.port}`]
+                    }, (err) => {
+                        if (err != null) {
+                            reject(err);
+                        } else {
+                            resolve();
+                        }
+                    });
+                }).then(() => {
+                    this.client = Bluebird.promisifyAll(RedisLib.createClient(this.opts)) as RedisClient;
+                    Logger.info("Redis connection is OK");
+                    isComplete = true;
+                }).catch((err) => {
+                    Logger.info("Connect to redis failed, try again");
+                    Logger.error(err.message);
+                    isComplete = false;
+                });
+            })
+            .then((object) => {
+                return isComplete;
+            });
+    }
+
+    /**
+     *
+     * @returns {RedisClient}
+     */
+    public getClient(): RedisClient {
+        return this.client;
+    }
+}
+
+export const Redis = new RedisConnection(Configuration.database != null ? Configuration.database.redis : null);
+export default Redis;

src/data/role.repository.ts

+/**
+ * Created by phuongho on 15/08/17.
+ */
+import * as Promise from "bluebird";
+import * as Schema from "../data/sql/schema";
+import { BaseRepository, Log } from "./base.repository";
+import { CollectionWrap, RoleModel } from "./../models";
+import { ROLE } from "./../libs/constants";
+import { RoleDto } from "./sql/models";
+import { injectable, inject } from "inversify";
+
+@injectable()
+export class RoleRepository extends BaseRepository<RoleDto, RoleModel> {
+    constructor( @inject("Logger") log?: Log) {
+        super(RoleDto, RoleModel, log);
+    }
+
+    /**
+    * search role
+    * @param searchParams
+    * @param offset
+    * @param limit
+    * @param related
+    * @param filters
+    * @returns {Promise<any[]>}
+    */
+    public search(searchParams: any = {}, offset: number, limit: number, related = [], filters = []): Promise<CollectionWrap<RoleModel>> {
+        let keyword = searchParams.key || null;
+        limit = limit || null;
+        offset = offset || null;
+
+        let query = () => {
+            return (q): void => {
+                q.where(`${Schema.ROLE_TABLE_SCHEMA.TABLE_NAME}.${Schema.ROLE_TABLE_SCHEMA.FIELDS.IS_DELETED}`, false);
+                if (searchParams.key) {
+                    q.where(q1 => {
+                        q1.where(`${Schema.ROLE_TABLE_SCHEMA.TABLE_NAME}.${Schema.ROLE_TABLE_SCHEMA.FIELDS.NAME}`, "ILIKE", `%${keyword}%`);
+                    });
+                }
+                if (searchParams.roleId === ROLE.MANAGER) {
+                    q.whereNotIn(`${Schema.ROLE_TABLE_SCHEMA.TABLE_NAME}.${Schema.ROLE_TABLE_SCHEMA.FIELDS.ID}`, [ROLE.SYSTEM_ADMIN, ROLE.MANAGER]);
+                }
+                if (searchParams.roleId === ROLE.COMPANY_ADMIN) {
+                    q.whereNotIn(`${Schema.ROLE_TABLE_SCHEMA.TABLE_NAME}.${Schema.ROLE_TABLE_SCHEMA.FIELDS.ID}`, [ROLE.SYSTEM_ADMIN, ROLE.MANAGER, ROLE.COMPANY_ADMIN]);
+                }
+                let orderBy = searchParams.orderBy || `${Schema.ROLE_TABLE_SCHEMA.TABLE_NAME}.${Schema.ROLE_TABLE_SCHEMA.FIELDS.CREATED_DATE}`;
+                let orderType = searchParams.orderType || "DESC";
+                q.orderBy(orderBy, orderType);
+            };
+        };
+        return this.queryByPage(query(), offset, limit, related, filters);
+    }
+
+}
+export default RoleRepository;

src/data/session.repository.ts

+/**
+ * Created by phuongho on 15/08/17.
+ */
+import { BaseRepository, Log } from "./base.repository";
+import { SessionDto } from "./sql/models";
+import { SessionModel } from "../models";
+import { injectable, inject } from "inversify";
+
+@injectable()
+export class SessionRepository extends BaseRepository<SessionDto, SessionModel> {
+    constructor( @inject("Logger") log?: Log) {
+        super(SessionDto, SessionModel, log);
+    }
+}
+export default SessionRepository;
+

src/data/setting.repository.ts

+/**
+ * Created by phuongho on 15/08/17.
+ */
+import * as Promise from "bluebird";
+import * as Schema from "../data/sql/schema";
+import { BaseRepository, Log } from "./base.repository";
+import { CollectionWrap, SettingModel } from "./../models";
+import { SETTING_TABLE_SCHEMA } from "./sql/schema";
+import { SettingDto } from "./sql/models";
+import { injectable, inject } from "inversify";
+
+@injectable()
+export class SettingRepository extends BaseRepository<SettingDto, SettingModel> {
+    constructor( @inject("Logger") log?: Log) {
+        super(SettingDto, SettingModel, log);
+    }
+
+    /**
+    * search Setting
+    * @param searchParams
+    * @param offset
+    * @param limit
+    * @param related
+    * @param filters
+    * @returns {Promise<any[]>}
+    */
+    public search(searchParams: any = {}, offset: number, limit: number, related = [], filters = []): Promise<CollectionWrap<SettingModel>> {
+        let keyword = searchParams.key || null;
+        limit = limit || null;
+        offset = offset || null;
+
+        let query = () => {
+            return (q): void => {
+                q.where(`${Schema.SETTING_TABLE_SCHEMA.TABLE_NAME}.${Schema.SETTING_TABLE_SCHEMA.FIELDS.IS_DELETED}`, false);
+                if (searchParams.key) {
+                    q.where(q1 => {
+                        q1.where(`${Schema.SETTING_TABLE_SCHEMA.TABLE_NAME}.${Schema.SETTING_TABLE_SCHEMA.FIELDS.KEYWORD}`, "ILIKE", `%${keyword}%`);
+                    });
+                }
+                let orderBy = searchParams.orderBy || `${Schema.SETTING_TABLE_SCHEMA.TABLE_NAME}.${Schema.SETTING_TABLE_SCHEMA.FIELDS.CREATED_DATE}`;
+                let orderType = searchParams.orderType || "DESC";
+                q.orderBy(orderBy, orderType);
+            };
+        };
+        return this.queryByPage(query(), offset, limit, related, filters);
+    }
+
+}
+export default SettingRepository;

src/data/sql/connection.ts

+/**
+ * Created by phuongho on 15/08/17.
+ */
+import * as Bluebird from "bluebird";
+import * as Bookshelf from "bookshelf";
+import * as Knex from "knex";
+import * as _ from "lodash";
+import * as waitOn from "wait-on";
+import { config, logger, Utils } from "../../libs";
+import { MySqlConnectionConfig } from "knex";
+
+declare module "bookshelf" {
+    interface Bookshelf extends Bookshelf.Events<any> {
+        model(name: String, model: Model<any>): Model<any>;
+    }
+    interface ModelBase<T extends Model<any>> extends IModelBase { }
+    interface Model<T extends Model<any>> extends ModelBase<T> {
+        // For pagination plugin
+        fetchPage(options?: { limit; number, offset: number, withRelated: WithRelatedQuery });
+        // For registry plugin
+        belongsTo<R extends Model<any>>(target: { new (...args: any[]): R } | String, foreignKey?: string, foreignKeyTarget?: string): R;
+        hasMany<R extends Model<any>>(target: { new (...args: any[]): R } | String, foreignKey?: string, foreignKeyTarget?: string): Collection<R>;
+        hasOne<R extends Model<any>>(target: { new (...args: any[]): R } | String, foreignKey?: string, foreignKeyTarget?: string): R;
+        belongsToMany<R extends Model<any>>(target: { new (...args: any[]): R } | String, table?: string, foreignKey?: string, otherKey?: string, foreignKeyTarget?: string, otherKeyTarget?: string): Collection<R>;
+    }
+}
+
+interface Log {
+    error(message: string, meta?: any): void;
+    warn(message: string, meta?: any): void;
+    info(message: string, meta?: any): void;
+    debug(message: string, meta?: any): void;
+}
+
+export class Connection {
+    private sql: MySqlConnectionConfig;
+    private instance: Bookshelf;
+
+    constructor(opts?: any, private logger?: Log) {
+        this.logger = logger || {
+            error: (message: string, meta?: any): void => { },
+            warn: (message: string, meta?: any): void => { },
+            info: (message: string, meta?: any): void => { },
+            debug: (message: string, meta?: any): void => { },
+        };
+
+        opts = opts || {};
+        let defaultConf: MySqlConnectionConfig = {
+            host: "127.0.0.1",
+            port: 5432,
+            user: "root",
+            password: "",
+            database: "test",
+            charset: "utf8mb4",
+            timezone: "UTC",
+        };
+
+        this.sql = _.defaultsDeep(opts, defaultConf) as MySqlConnectionConfig;
+        if (process.env.DB_HOST != null) {
+            this.sql.host = process.env.DB_HOST;
+        }
+        if (process.env.DB_PORT != null) {
+            this.sql.port = Number.parseInt(process.env.DB_PORT, 10);
+        }
+        if (process.env.DB_USER != null) {
+            this.sql.user = process.env.DB_USER;
+        }
+        if (process.env.DB_PASSWORD != null) {
+            this.sql.password = process.env.DB_PASSWORD;
+        }
+        if (process.env.DB_NAME != null) {
+            this.sql.database = process.env.DB_NAME;
+        }
+
+        let knex: Knex = Knex({
+            client: "postgresql",
+            connection: this.sql,
+            debug: this.sql.debug ? this.sql.debug : false,
+        });
+
+        this.instance = Bookshelf(knex);
+        this.instance.plugin("pagination");
+        this.instance.plugin("registry");
+    }
+
+    public migration(): Bluebird<boolean> {
+        this.logger.info("Wait for database connection");
+
+        let isComplete = false;
+        return Utils.PromiseLoop(
+            () => {
+                return isComplete === true;
+            },
+            () => {
+                return new Bluebird((resolve, reject) => {
+                    waitOn({
+                        resources: [`tcp:${this.sql.host}:${this.sql.port}`]
+                    }, (err) => {
+                        if (err != null) {
+                            reject(err);
+                        } else {
+                            resolve();
+                        }
+                    });
+                }).then(() => {
+                    return Bluebird.delay(1000);
+                }).then(() => {
+                    this.logger.info("Perform database migration");
+                    return this.instance.knex.migrate.latest({
+                        directory: __dirname + "/migrations",
+                    });
+                }).then((info) => {
+                    this.logger.info("All migrations were success");
+                    isComplete = true;
+                }).catch((err) => {
+                    this.logger.info("All migrations were failed, try again");
+                    this.logger.error(err.message);
+                    isComplete = false;
+                });
+            })
+            .then((object) => {
+                return isComplete;
+            });
+    }
+
+    public bookshelf(): Bookshelf {
+        return this.instance;
+    }
+}
+
+export const Database = new Connection(config.database ? config.database.postgres : {}, logger);
+export default Database;

src/data/sql/migrations/20171004142623_update_user.ts

+import * as Bluebird from "bluebird";
+import * as Knex from "knex";
+import * as UUID from "uuid";
+import * as Schema from "../schema";
+import { PLATFORM } from "../../../libs/constants";
+
+const user = (knex, Promise) => {
+    let SCHEMA = Schema.USER_TABLE_SCHEMA;
+    return Promise.resolve()
+        .then(() => {
+            return knex.schema.table(SCHEMA.TABLE_NAME, (table) => {
+                table.string(SCHEMA.FIELDS.PARENT_ID, 36).nullable().index()
+                    .references(Schema.USER_TABLE_SCHEMA.FIELDS.ID)
+                    .inTable(Schema.USER_TABLE_SCHEMA.TABLE_NAME)
+                    .onUpdate("CASCADE")
+                    .onDelete("CASCADE");
+                table.string(SCHEMA.FIELDS.COMPANY, 255).nullable();
+                table.string(SCHEMA.FIELDS.ADDRESS, 255).nullable();
+                table.string(SCHEMA.FIELDS.COUNTRY, 255).nullable();
+                table.string(SCHEMA.FIELDS.STATE, 255).nullable();
+                table.string(SCHEMA.FIELDS.PROVINCE, 255).nullable();
+            });
+        });
+};
+
+export const up = (knex, Promise) => {
+    return Promise.resolve()
+        .then(() => {
+            return user(knex, Promise);
+        });
+};
+
+export const down = (knex, Promise) => {
+    return Promise.all([
+        knex.schema.table(`${Schema.USER_TABLE_SCHEMA.TABLE_NAME}`, function (table) {
+            table.dropColumn(`${Schema.USER_TABLE_SCHEMA.FIELDS.PARENT_ID}`);
+            table.dropColumn(`${Schema.USER_TABLE_SCHEMA.FIELDS.COMPANY}`);
+            table.dropColumn(`${Schema.USER_TABLE_SCHEMA.FIELDS.ADDRESS}`);
+            table.dropColumn(`${Schema.USER_TABLE_SCHEMA.FIELDS.COUNTRY}`);
+            table.dropColumn(`${Schema.USER_TABLE_SCHEMA.FIELDS.STATE}`);
+            table.dropColumn(`${Schema.USER_TABLE_SCHEMA.FIELDS.PROVINCE}`);
+        }),
+    ]);
+};

src/data/sql/migrations/20171004144603_tag.ts

+import { TAG_TABLE_SCHEMA, USER_TABLE_SCHEMA } from "./../schema";
+import * as Bluebird from "bluebird";
+import * as Knex from "knex";
+import * as UUID from "uuid";
+import * as Schema from "../schema";
+import { PLATFORM } from "../../../libs/constants";
+
+/**
+ * Create tags table and its default data
+ * @param knex
+ * @param Promise
+ * @return {Promise<any>}
+ */
+
+const tag = (knex, Promise) => {
+    let SCHEMA = Schema.TAG_TABLE_SCHEMA;
+    return Promise.resolve()
+        .then(() => {
+            return knex.schema.createTable(SCHEMA.TABLE_NAME, (table) => {
+                table.string(SCHEMA.FIELDS.ID, 36).notNullable().primary();
+                table.boolean(SCHEMA.FIELDS.IS_DELETED).notNullable().defaultTo(0);
+                table.dateTime(SCHEMA.FIELDS.CREATED_DATE).defaultTo(knex.raw("current_timestamp"));
+                table.dateTime(SCHEMA.FIELDS.UPDATED_DATE).defaultTo(knex.raw("current_timestamp"));
+
+                table.string(SCHEMA.FIELDS.USER_ID, 36).notNullable().index()
+                    .references(Schema.USER_TABLE_SCHEMA.FIELDS.ID)
+                    .inTable(Schema.USER_TABLE_SCHEMA.TABLE_NAME)
+                    .onUpdate("CASCADE")
+                    .onDelete("CASCADE");
+
+                table.string(SCHEMA.FIELDS.NAME, 255).notNullable();
+                table.text(SCHEMA.FIELDS.DESCRIPTION).nullable();
+            });
+        });
+};
+
+const userTag = (knex, Promise) => {
+    let SCHEMA = Schema.USER_TAG_TABLE_SCHEMA;
+    return Promise.resolve()
+        .then(() => {
+            return knex.schema.createTable(SCHEMA.TABLE_NAME, (table) => {
+                table.string(SCHEMA.FIELDS.ID, 36).notNullable().primary();
+                table.boolean(SCHEMA.FIELDS.IS_DELETED).notNullable().defaultTo(0);
+                table.dateTime(SCHEMA.FIELDS.CREATED_DATE).defaultTo(knex.raw("current_timestamp"));
+                table.dateTime(SCHEMA.FIELDS.UPDATED_DATE).defaultTo(knex.raw("current_timestamp"));
+
+                table.string(SCHEMA.FIELDS.USER_ID, 36).notNullable().index()
+                    .references(Schema.USER_TABLE_SCHEMA.FIELDS.ID)
+                    .inTable(Schema.USER_TABLE_SCHEMA.TABLE_NAME)
+                    .onUpdate("CASCADE")
+                    .onDelete("CASCADE");
+
+                table.string(SCHEMA.FIELDS.TAG_ID, 36).notNullable().index()
+                    .references(Schema.TAG_TABLE_SCHEMA.FIELDS.ID)
+                    .inTable(Schema.TAG_TABLE_SCHEMA.TABLE_NAME)
+                    .onUpdate("CASCADE")
+                    .onDelete("CASCADE");
+            });
+        });
+};
+
+export const up = (knex, Promise) => {
+    return Promise.resolve()
+        .then(() => {
+            return tag(knex, Promise);
+        })
+        .then(() => {
+            return userTag(knex, Promise);
+        });
+};
+
+export const down = (knex, Promise) => {
+    return Promise.all([
+        knex.schema.raw(`DROP TABLE IF EXISTS ${Schema.TAG_TABLE_SCHEMA.TABLE_NAME} CASCADE`),
+        knex.schema.raw(`DROP TABLE IF EXISTS ${Schema.USER_TAG_TABLE_SCHEMA.TABLE_NAME} CASCADE`)
+    ]);
+};
\ No newline at end of file

src/data/sql/migrations/20171004150027_package.ts

+import { PACKAGE_TABLE_SCHEMA, USER_TABLE_SCHEMA } from "./../schema";
+import * as Bluebird from "bluebird";
+import * as Knex from "knex";
+import * as UUID from "uuid";
+import * as Schema from "../schema";
+import { PLATFORM } from "../../../libs/constants";
+
+/**
+ * Create packages table
+ * @param Promise
+ * @return {Promise<any>}
+ */
+
+const packages = (knex, Promise) => {
+    let SCHEMA = Schema.PACKAGE_TABLE_SCHEMA;
+    return Promise.resolve()
+        .then(() => {
+            return knex.schema.createTable(SCHEMA.TABLE_NAME, (table) => {
+                table.string(SCHEMA.FIELDS.ID, 36).notNullable().primary();
+                table.boolean(SCHEMA.FIELDS.IS_DELETED).notNullable().defaultTo(0);
+                table.dateTime(SCHEMA.FIELDS.CREATED_DATE).defaultTo(knex.raw("current_timestamp"));
+                table.dateTime(SCHEMA.FIELDS.UPDATED_DATE).defaultTo(knex.raw("current_timestamp"));
+
+                table.string(SCHEMA.FIELDS.NAME, 255).notNullable();
+                table.text(SCHEMA.FIELDS.DESCRIPTION).nullable();
+                table.float(SCHEMA.FIELDS.NUMBER_ACCOUNT).defaultTo(0.0);
+                table.float(SCHEMA.FIELDS.NUMBER_FILE).defaultTo(0.0);
+            });
+        });
+};
+
+const userPackage = (knex, Promise) => {
+    let SCHEMA = Schema.USER_PACKAGE_TABLE_SCHEMA;
+    return Promise.resolve()
+        .then(() => {
+            return knex.schema.createTable(SCHEMA.TABLE_NAME, (table) => {
+                table.string(SCHEMA.FIELDS.ID, 36).notNullable().primary();
+                table.boolean(SCHEMA.FIELDS.IS_DELETED).notNullable().defaultTo(0);
+                table.dateTime(SCHEMA.FIELDS.CREATED_DATE).defaultTo(knex.raw("current_timestamp"));
+                table.dateTime(SCHEMA.FIELDS.UPDATED_DATE).defaultTo(knex.raw("current_timestamp"));
+
+                table.string(SCHEMA.FIELDS.USER_ID, 36).notNullable().index()
+                    .references(Schema.USER_TABLE_SCHEMA.FIELDS.ID)
+                    .inTable(Schema.USER_TABLE_SCHEMA.TABLE_NAME)
+                    .onUpdate("CASCADE")
+                    .onDelete("CASCADE");
+
+                table.string(SCHEMA.FIELDS.PACKAGE_ID, 36).notNullable().index()
+                    .references(Schema.PACKAGE_TABLE_SCHEMA.FIELDS.ID)
+                    .inTable(Schema.PACKAGE_TABLE_SCHEMA.TABLE_NAME)
+                    .onUpdate("CASCADE")
+                    .onDelete("CASCADE");
+                table.float(SCHEMA.FIELDS.NUMBER_ACCOUNT).defaultTo(0.0);
+                table.float(SCHEMA.FIELDS.NUMBER_FILE).defaultTo(0.0);
+            });
+        });
+};
+
+export const up = (knex, Promise) => {
+    return Promise.resolve()
+        .then(() => {
+            return packages(knex, Promise);
+        })
+        .then(() => {
+            return userPackage(knex, Promise);
+        });
+};
+
+export const down = (knex, Promise) => {
+    return Promise.all([
+        knex.schema.raw(`DROP TABLE IF EXISTS ${Schema.PACKAGE_TABLE_SCHEMA.TABLE_NAME} CASCADE`),
+        knex.schema.raw(`DROP TABLE IF EXISTS ${Schema.USER_PACKAGE_TABLE_SCHEMA.TABLE_NAME} CASCADE`)
+    ]);
+};
\ No newline at end of file

src/data/sql/migrations/20171004151712_presentation.ts

+import { PRESENTATION_TABLE_SCHEMA, USER_TABLE_SCHEMA } from "./../schema";
+import * as Bluebird from "bluebird";
+import * as Knex from "knex";
+import * as UUID from "uuid";
+import * as Schema from "../schema";
+import { PLATFORM } from "../../../libs/constants";
+
+/**
+ * Create presentation table
+ * @param knex
+ * @param Promise
+ * @return {Promise<any>}
+ */
+
+const presentation = (knex, Promise) => {
+    let SCHEMA = Schema.PRESENTATION_TABLE_SCHEMA;
+    return Promise.resolve()
+        .then(() => {
+            return knex.schema.createTable(SCHEMA.TABLE_NAME, (table) => {
+                table.string(SCHEMA.FIELDS.ID, 36).notNullable().primary();
+                table.boolean(SCHEMA.FIELDS.IS_ENABLE).notNullable().defaultTo(1);
+                table.boolean(SCHEMA.FIELDS.IS_DELETED).notNullable().defaultTo(0);
+                table.dateTime(SCHEMA.FIELDS.CREATED_DATE).defaultTo(knex.raw("current_timestamp"));
+                table.dateTime(SCHEMA.FIELDS.UPDATED_DATE).defaultTo(knex.raw("current_timestamp"));
+
+                table.string(SCHEMA.FIELDS.USER_ID, 36).notNullable().index()
+                    .references(Schema.USER_TABLE_SCHEMA.FIELDS.ID)
+                    .inTable(Schema.USER_TABLE_SCHEMA.TABLE_NAME)
+                    .onUpdate("CASCADE")
+                    .onDelete("CASCADE");
+
+                table.string(SCHEMA.FIELDS.TITLE, 255).notNullable();
+                table.string(SCHEMA.FIELDS.LANGUAGE, 255).notNullable();
+                table.text(SCHEMA.FIELDS.DESCRIPTION).nullable();
+                table.text(SCHEMA.FIELDS.IMAGE_URL).nullable();
+                table.text(SCHEMA.FIELDS.PAGE_TIMING).notNullable();
+                table.float(SCHEMA.FIELDS.NUMBER_PAGE).notNullable().defaultTo(0.0);
+            });
+        });
+};
+
+const accountPresentation = (knex, Promise) => {
+    let SCHEMA = Schema.USER_PRESENTATION_TABLE_SCHEMA;
+    return Promise.resolve()
+        .then(() => {
+            return knex.schema.createTable(SCHEMA.TABLE_NAME, (table) => {
+                table.string(SCHEMA.FIELDS.ID, 36).notNullable().primary();
+                table.boolean(SCHEMA.FIELDS.IS_DELETED).notNullable().defaultTo(0);
+                table.dateTime(SCHEMA.FIELDS.CREATED_DATE).defaultTo(knex.raw("current_timestamp"));
+                table.dateTime(SCHEMA.FIELDS.UPDATED_DATE).defaultTo(knex.raw("current_timestamp"));
+
+                table.string(SCHEMA.FIELDS.USER_ID, 36).notNullable().index()
+                    .references(Schema.USER_TABLE_SCHEMA.FIELDS.ID)
+                    .inTable(Schema.USER_TABLE_SCHEMA.TABLE_NAME)
+                    .onUpdate("CASCADE")
+                    .onDelete("CASCADE");
+
+                table.string(SCHEMA.FIELDS.PRESENTATION_ID, 36).notNullable().index()
+                    .references(Schema.PRESENTATION_TABLE_SCHEMA.FIELDS.ID)
+                    .inTable(Schema.PRESENTATION_TABLE_SCHEMA.TABLE_NAME)
+                    .onUpdate("CASCADE")
+                    .onDelete("CASCADE");
+            });
+        });
+};
+
+export const up = (knex, Promise) => {
+    return Promise.resolve()
+        .then(() => {
+            return presentation(knex, Promise);
+        })
+        .then(() => {
+            return accountPresentation(knex, Promise);
+        });
+};
+
+export const down = (knex, Promise) => {
+    return Promise.all([
+        knex.schema.raw(`DROP TABLE IF EXISTS ${Schema.PRESENTATION_TABLE_SCHEMA.TABLE_NAME} CASCADE`),
+        knex.schema.raw(`DROP TABLE IF EXISTS ${Schema.USER_PRESENTATION_TABLE_SCHEMA.TABLE_NAME} CASCADE`)
+    ]);
+};
\ No newline at end of file

src/data/sql/migrations/20171004155401_presentation_report.ts

+import { PRESENTATION_TABLE_SCHEMA} from "./../schema";
+import * as Bluebird from "bluebird";
+import * as Knex from "knex";
+import * as UUID from "uuid";
+import * as Schema from "../schema";
+import { PLATFORM } from "../../../libs/constants";
+
+/**
+ * Create presentation report table
+ * @param knex
+ * @param Promise
+ * @return {Promise<any>}
+ */
+
+const presentationReport = (knex, Promise) => {
+    let SCHEMA = Schema.PRESENTATION_REPORT_TABLE_SCHEMA;
+    return Promise.resolve()
+        .then(() => {
+            return knex.schema.createTable(SCHEMA.TABLE_NAME, (table) => {
+                table.string(SCHEMA.FIELDS.ID, 36).notNullable().primary();
+                table.boolean(SCHEMA.FIELDS.IS_DELETED).notNullable().defaultTo(0);
+                table.dateTime(SCHEMA.FIELDS.CREATED_DATE).defaultTo(knex.raw("current_timestamp"));
+                table.dateTime(SCHEMA.FIELDS.UPDATED_DATE).defaultTo(knex.raw("current_timestamp"));
+
+                table.string(SCHEMA.FIELDS.USER_ID, 36).notNullable().index()
+                    .references(Schema.USER_TABLE_SCHEMA.FIELDS.ID)
+                    .inTable(Schema.USER_TABLE_SCHEMA.TABLE_NAME)
+                    .onUpdate("CASCADE")
+                    .onDelete("CASCADE");
+
+                table.string(SCHEMA.FIELDS.PRESENTATION_ID, 36).notNullable().index()
+                    .references(Schema.PRESENTATION_TABLE_SCHEMA.FIELDS.ID)
+                    .inTable(Schema.PRESENTATION_TABLE_SCHEMA.TABLE_NAME)
+                    .onUpdate("CASCADE")
+                    .onDelete("CASCADE");
+
+                table.text(SCHEMA.FIELDS.PAGE_TIMING).notNullable();
+                table.text(SCHEMA.FIELDS.NOTE).nullable();
+                table.text(SCHEMA.FIELDS.AUDIO_URL).notNullable();
+                table.double(SCHEMA.FIELDS.LATITUDE).notNullable().default(0);
+                table.double(SCHEMA.FIELDS.LONGITUDE).notNullable().default(0);
+                table.integer(SCHEMA.FIELDS.RATE).notNullable().default(0);
+                table.dateTime(SCHEMA.FIELDS.START_DATE).defaultTo(knex.raw("current_timestamp"));
+                table.dateTime(SCHEMA.FIELDS.END_DATE).defaultTo(knex.raw("current_timestamp"));
+            });
+        });
+};
+
+export const up = (knex, Promise) => {
+    return Promise.resolve()
+        .then(() => {
+            return presentationReport(knex, Promise);
+        });
+};
+
+export const down = (knex, Promise) => {
+    return Promise.all([
+        knex.schema.raw(`DROP TABLE IF EXISTS ${Schema.PRESENTATION_REPORT_TABLE_SCHEMA.TABLE_NAME} CASCADE`),
+    ]);
+};
\ No newline at end of file

src/data/sql/migrations/20171005111913_user_code.ts

+import { USER_TABLE_SCHEMA } from "./../schema";
+import * as Bluebird from "bluebird";
+import * as Knex from "knex";
+import * as UUID from "uuid";
+import * as Schema from "../schema";
+import { PLATFORM } from "../../../libs/constants";
+
+const userCode = (knex, Promise) => {
+    let SCHEMA = Schema.USER_CODE_TABLE_SCHEMA;
+    return Promise.resolve()
+        .then(() => {
+            return knex.schema.createTable(SCHEMA.TABLE_NAME, (table) => {
+                table.string(SCHEMA.FIELDS.ID, 36).notNullable().primary();
+                table.boolean(SCHEMA.FIELDS.IS_DELETED).notNullable().defaultTo(0);
+                table.dateTime(SCHEMA.FIELDS.CREATED_DATE).defaultTo(knex.raw("current_timestamp"));
+                table.dateTime(SCHEMA.FIELDS.UPDATED_DATE).defaultTo(knex.raw("current_timestamp"));
+
+                table.string(SCHEMA.FIELDS.USER_ID, 36).notNullable().index()
+                    .references(Schema.USER_TABLE_SCHEMA.FIELDS.ID)
+                    .inTable(Schema.USER_TABLE_SCHEMA.TABLE_NAME)
+                    .onUpdate("CASCADE")
+                    .onDelete("CASCADE");
+                table.string(SCHEMA.FIELDS.CODE, 255).notNullable();
+                table.boolean(SCHEMA.FIELDS.IS_USED).notNullable().defaultTo(0);
+            });
+        });
+};
+
+export const up = (knex, Promise) => {
+    return Promise.resolve()
+        .then(() => {
+            return userCode(knex, Promise);
+        });
+};
+
+export const down = (knex, Promise) => {
+    return Promise.all([
+        knex.schema.raw(`DROP TABLE IF EXISTS ${Schema.USER_CODE_TABLE_SCHEMA.TABLE_NAME} CASCADE`)
+    ]);
+};
\ No newline at end of file

src/data/sql/migrations/20171006135951_update_package.ts

+import { PACKAGE_TABLE_SCHEMA } from "./../schema";
+import { PRIORITY } from "./../../../libs/scheduler";
+import * as Bluebird from "bluebird";
+import * as Knex from "knex";
+import * as UUID from "uuid";
+import * as Schema from "../schema";
+import { PLATFORM } from "../../../libs/constants";
+
+const packages = (knex, Promise) => {
+    let SCHEMA = Schema.PACKAGE_TABLE_SCHEMA;
+    return Promise.resolve()
+        .then(() => {
+            return knex.schema.table(SCHEMA.TABLE_NAME, (table) => {
+                table.integer(SCHEMA.FIELDS.PRIORITY, 11).notNullable().default(0);
+            });
+        });
+};
+
+export const up = (knex, Promise) => {
+    return Promise.resolve()
+        .then(() => {
+            return packages(knex, Promise);
+        });
+};
+
+export const down = (knex, Promise) => {
+    return Promise.all([
+        knex.schema.table(`${Schema.PACKAGE_TABLE_SCHEMA.TABLE_NAME}`, function (table) {
+            table.dropColumn(`${Schema.PACKAGE_TABLE_SCHEMA.FIELDS.PRIORITY}`);
+        }),
+    ]);
+};

src/data/sql/migrations/20171010174709_update_user.ts

+import * as Bluebird from "bluebird";
+import * as Knex from "knex";
+import * as UUID from "uuid";
+import * as Schema from "../schema";
+import { PLATFORM } from "../../../libs/constants";
+
+const user = (knex, Promise) => {
+    let SCHEMA = Schema.USER_TABLE_SCHEMA;
+    return Promise.resolve()
+        .then(() => {
+            return knex.schema.table(SCHEMA.TABLE_NAME, (table) => {
+                table.string(SCHEMA.FIELDS.LANGUAGE, 255).nullable();
+            });
+        });
+};
+
+export const up = (knex, Promise) => {
+    return Promise.resolve()
+        .then(() => {
+            return user(knex, Promise);
+        });
+};
+
+export const down = (knex, Promise) => {
+    return Promise.all([
+        knex.schema.table(`${Schema.USER_TABLE_SCHEMA.TABLE_NAME}`, function (table) {
+            table.dropColumn(`${Schema.USER_TABLE_SCHEMA.FIELDS.LANGUAGE}`);
+        }),
+    ]);
+};

src/data/sql/migrations/20171011105743_update_package.ts

+import * as Bluebird from "bluebird";
+import * as Knex from "knex";
+import * as UUID from "uuid";
+import * as Schema from "../schema";
+import { PLATFORM } from "../../../libs/constants";
+
+const packages = (knex, Promise) => {
+    let SCHEMA = Schema.PACKAGE_TABLE_SCHEMA;
+    return Promise.resolve()
+        .then(() => {
+            return knex.schema.table(SCHEMA.TABLE_NAME, (table) => {
+                table.double(SCHEMA.FIELDS.PRICE).notNullable().default(0);
+            });
+        });
+};
+
+const userPackage = (knex, Promise) => {
+    let SCHEMA = Schema.USER_PACKAGE_TABLE_SCHEMA;
+    return Promise.resolve()
+        .then(() => {
+            return knex.schema.table(SCHEMA.TABLE_NAME, (table) => {
+                table.double(SCHEMA.FIELDS.PRICE).notNullable().default(0);
+            });
+        });
+};
+
+export const up = (knex, Promise) => {
+    return Promise.resolve()
+        .then(() => {
+            return packages(knex, Promise);
+        })
+        .then(() => {
+            return userPackage(knex, Promise);
+        });
+};
+
+export const down = (knex, Promise) => {
+    return Promise.all([
+        knex.schema.table(`${Schema.PACKAGE_TABLE_SCHEMA.TABLE_NAME}`, function (table) {
+            table.dropColumn(`${Schema.PACKAGE_TABLE_SCHEMA.FIELDS.PRICE}`);
+        }),
+        knex.schema.table(`${Schema.USER_PACKAGE_TABLE_SCHEMA.TABLE_NAME}`, function (table) {
+            table.dropColumn(`${Schema.USER_PACKAGE_TABLE_SCHEMA.FIELDS.PRICE}`);
+        }),
+    ]);
+};

src/data/sql/migrations/20171011120804_update_presentation.ts

+import * as Bluebird from "bluebird";
+import * as Knex from "knex";
+import * as UUID from "uuid";
+import * as Schema from "../schema";
+import { PLATFORM } from "../../../libs/constants";
+
+const presentation = (knex, Promise) => {
+    let SCHEMA = Schema.PRESENTATION_TABLE_SCHEMA;
+    return Promise.resolve()
+        .then(() => {
+            return knex.schema.table(SCHEMA.TABLE_NAME, (table) => {
+                table.text(SCHEMA.FIELDS.FILE_URL).notNullable();
+            });
+        });
+};
+
+export const up = (knex, Promise) => {
+    return Promise.resolve()
+        .then(() => {
+            return presentation(knex, Promise);
+        });
+};
+
+export const down = (knex, Promise) => {
+    return Promise.all([
+        knex.schema.table(`${Schema.PRESENTATION_TABLE_SCHEMA.TABLE_NAME}`, function (table) {
+            table.dropColumn(`${Schema.PRESENTATION_TABLE_SCHEMA.FIELDS.FILE_URL}`);
+        })
+    ]);
+};

src/data/sql/migrations/20171011193658_assign_presentation.ts

+import * as Bluebird from "bluebird";
+import * as Knex from "knex";
+import * as UUID from "uuid";
+import * as Schema from "../schema";
+import { PLATFORM } from "../../../libs/constants";
+
+const presentation = (knex, Promise) => {
+    let SCHEMA = Schema.PRESENTATION_TABLE_SCHEMA;
+    return Promise.resolve()
+        .then(() => {
+            return knex.schema.table(SCHEMA.TABLE_NAME, (table) => {
+                table.integer(SCHEMA.FIELDS.PRIORITY).notNullable().default(0);
+                table.string(SCHEMA.FIELDS.USER_CODE, 255).nullable();
+            });
+        });
+};
+
+const userCode = (knex, Promise) => {
+    let SCHEMA = Schema.USER_CODE_TABLE_SCHEMA;
+    return Promise.resolve()
+        .then(() => {
+            return knex.schema.table(SCHEMA.TABLE_NAME, (table) => {
+                table.string(SCHEMA.FIELDS.NAME, 255).nullable();
+            });
+        });
+};
+
+const assignPresentation = (knex, Promise) => {
+    let SCHEMA = Schema.ASSIGN_PRESENTATION_TABLE_SCHEMA;
+    return Promise.resolve()
+        .then(() => {
+            return knex.schema.createTable(SCHEMA.TABLE_NAME, (table) => {
+                table.string(SCHEMA.FIELDS.ID, 36).notNullable().primary();
+                table.boolean(SCHEMA.FIELDS.IS_DELETED).notNullable().defaultTo(0);
+                table.dateTime(SCHEMA.FIELDS.CREATED_DATE).defaultTo(knex.raw("current_timestamp"));
+                table.dateTime(SCHEMA.FIELDS.UPDATED_DATE).defaultTo(knex.raw("current_timestamp"));
+
+                table.string(SCHEMA.FIELDS.PRESENTATION_ID, 36).notNullable().index()
+                    .references(Schema.PRESENTATION_TABLE_SCHEMA.FIELDS.ID)
+                    .inTable(Schema.PRESENTATION_TABLE_SCHEMA.TABLE_NAME)
+                    .onUpdate("CASCADE")
+                    .onDelete("CASCADE");
+
+                table.string(SCHEMA.FIELDS.COUNTRY, 255).nullable();
+                table.string(SCHEMA.FIELDS.STATE, 255).nullable();
+                table.string(SCHEMA.FIELDS.PROVINCE, 255).nullable();
+                table.text(SCHEMA.FIELDS.TAG).nullable();
+                table.text(SCHEMA.FIELDS.USER).nullable();
+            });
+        });
+};
+
+
+export const up = (knex, Promise) => {
+    return Promise.resolve()
+        .then(() => {
+            return presentation(knex, Promise);
+        })
+        .then(() => {
+            return userCode(knex, Promise);
+        })
+        .then(() => {
+            return assignPresentation(knex, Promise);
+        });
+};
+
+export const down = (knex, Promise) => {
+    return Promise.all([
+        knex.schema.table(`${Schema.PRESENTATION_TABLE_SCHEMA.TABLE_NAME}`, function (table) {
+            table.dropColumn(`${Schema.PRESENTATION_TABLE_SCHEMA.FIELDS.PRIORITY}`);
+            table.dropColumn(`${Schema.PRESENTATION_TABLE_SCHEMA.FIELDS.USER_CODE}`);
+        }),
+        knex.schema.table(`${Schema.USER_CODE_TABLE_SCHEMA.TABLE_NAME}`, function (table) {
+            table.dropColumn(`${Schema.USER_CODE_TABLE_SCHEMA.FIELDS.NAME}`);
+        }),
+        knex.schema.raw(`DROP TABLE IF EXISTS ${Schema.ASSIGN_PRESENTATION_TABLE_SCHEMA.TABLE_NAME} CASCADE`),
+    ]);
+};
\ No newline at end of file

src/data/sql/migrations/20171013163009_add_language_table.ts

+import * as Bluebird from "bluebird";
+import * as Knex from "knex";
+import * as Schema from "../schema";
+import { LANGUAGE_TABLE_SCHEMA } from "./../schema";
+
+
+
+/**
+ * Create tags table and its default data
+ * @param knex
+ * @param Promise
+ * @return {Promise<any>}
+ */
+
+const language = (knex, Promise) => {
+    let SCHEMA = LANGUAGE_TABLE_SCHEMA;
+    return Promise.resolve()
+        .then(() => {
+            return knex.schema.createTable(SCHEMA.TABLE_NAME, (table) => {
+                table.boolean(SCHEMA.FIELDS.IS_DELETED).notNullable().defaultTo(0);
+                table.dateTime(SCHEMA.FIELDS.CREATED_DATE).defaultTo(knex.raw("current_timestamp"));
+                table.dateTime(SCHEMA.FIELDS.UPDATED_DATE).defaultTo(knex.raw("current_timestamp"));
+                table.string(SCHEMA.FIELDS.CODE, 36).notNullable();
+                table.string(SCHEMA.FIELDS.NAME, 36).notNullable();
+                table.string(SCHEMA.FIELDS.ID, 36).notNullable().primary();
+                table.integer(SCHEMA.FIELDS.PRIORITY, 6);
+            });
+        });
+};
+
+export const up = (knex, Promise) => {
+    return Promise.resolve()
+        .then(() => {
+            return language(knex, Promise);
+        });
+
+};
+
+export const down = (knex: Knex, promise: typeof Bluebird): Bluebird<any> => {
+    return promise.resolve();
+};

src/data/sql/migrations/20171017100317_media.ts

+import * as Bluebird from "bluebird";
+import * as Knex from "knex";
+import * as UUID from "uuid";
+import * as Schema from "../schema";
+import { PLATFORM } from "../../../libs/constants";
+
+/**
+ * Create media table and its default data
+ *
+ * @param knex
+ * @param Promise
+ * @returns {Promise<R>|Created|Promise<TResult>|PromiseLike<TResult>|Promise.<TResult>|Promise<R2|R1>}
+ */
+const media = (knex, Promise) => {
+    // create setting table;
+    let SCHEMA = Schema.MEDIA_TABLE_SCHEMA;
+    return Promise.resolve()
+        .then(() => {
+            return knex.schema.createTable(SCHEMA.TABLE_NAME, (table) => {
+                table.string(SCHEMA.FIELDS.ID, 36).notNullable().primary();
+                table.boolean(SCHEMA.FIELDS.IS_DELETED).notNullable().defaultTo(0);
+                table.boolean(SCHEMA.FIELDS.IS_ENABLE).notNullable().defaultTo(1);
+                table.dateTime(SCHEMA.FIELDS.CREATED_DATE).defaultTo(knex.raw("current_timestamp"));
+                table.dateTime(SCHEMA.FIELDS.UPDATED_DATE).defaultTo(knex.raw("current_timestamp"));
+
+                table.text(SCHEMA.FIELDS.PATH).notNullable();
+                table.text(SCHEMA.FIELDS.URL).notNullable();
+                table.string(SCHEMA.FIELDS.HASH, 16).nullable();
+            });
+        });
+};
+
+export const up = (knex, Promise) => {
+    return Promise.resolve()
+        .then(() => {
+            return media(knex, Promise);
+        });
+};
+
+export const down = (knex, Promise) => {
+    return Promise.all([
+        knex.schema.raw(`DROP TABLE IF EXISTS ${Schema.MEDIA_TABLE_SCHEMA.TABLE_NAME} CASCADE`),
+    ]);
+};
\ No newline at end of file

src/data/sql/migrations/20171101113839_category.ts

+import * as Bluebird from "bluebird";
+import * as Knex from "knex";
+
+export const up = (knex: Knex, promise: typeof Bluebird): Bluebird<any> => {
+    return promise.resolve();
+};
+
+export const down = (knex: Knex, promise: typeof Bluebird): Bluebird<any> => {
+    return promise.resolve();
+};
\ No newline at end of file

src/data/sql/migrations/20171101164122_category.ts

+import * as Bluebird from "bluebird";
+import * as Knex from "knex";
+
+export const up = (knex: Knex, promise: typeof Bluebird): Bluebird<any> => {
+    return promise.resolve();
+};
+
+export const down = (knex: Knex, promise: typeof Bluebird): Bluebird<any> => {
+    return promise.resolve();
+};
\ No newline at end of file

src/data/sql/models/application.dto.ts

+import * as Schema from "../schema";
+import { BaseDto } from "./base.dto";
+import { Database } from "../connection";
+
+export class ApplicationDto extends BaseDto<ApplicationDto> {
+    get tableName(): string {
+        return Schema.APPLICATION_TABLE_SCHEMA.TABLE_NAME;
+    }
+}
+
+export default ApplicationDto;
+Database.bookshelf()["model"](Schema.APPLICATION_TABLE_SCHEMA.TABLE_NAME, ApplicationDto);

src/data/sql/models/articles.dto.ts

+import * as Schema from "../schema";
+import { BaseDto } from "./base.dto";
+import { Database } from "../connection";
+
+// create by Nga
+export class ArticlesDto extends BaseDto<ArticlesDto> {
+    get tableName(): string {
+        return Schema.ARTICLES_TABLE_SCHEMA.TABLE_NAME;
+    }
+}
+
+export default ArticlesDto;
+Database.bookshelf()["model"](Schema.ARTICLES_TABLE_SCHEMA.TABLE_NAME, ArticlesDto);

src/data/sql/models/assign_presentation.dto.ts

+import * as Schema from "../schema";
+import { BaseDto } from "./base.dto";
+import { Database } from "../connection";
+
+export class AssignPresentationDto extends BaseDto<AssignPresentationDto> {
+    get tableName(): string {
+        return Schema.ASSIGN_PRESENTATION_TABLE_SCHEMA.TABLE_NAME;
+    }
+    public presentation(): any {
+        return this.belongsTo(Schema.PRESENTATION_TABLE_SCHEMA.TABLE_NAME, Schema.USER_PRESENTATION_TABLE_SCHEMA.FIELDS.PRESENTATION_ID);
+    }
+}
+
+export default AssignPresentationDto;
+Database.bookshelf()["model"](Schema.ASSIGN_PRESENTATION_TABLE_SCHEMA.TABLE_NAME, AssignPresentationDto);

src/data/sql/models/base.dto.ts

+import * as UUID from "uuid";
+import { Database } from "../connection";
+export class BaseDto<T> extends Database.bookshelf().Model<any> {
+
+    public static knex() {
+        return Database.bookshelf().knex;
+    }
+
+    public static register(name: string, model: any): void {
+        Database.bookshelf()["model"](model);
+    }
+
+    private static generateUuid(model: any): void {
+        if (model.isNew()) {
+            model.set(model.idAttribute, UUID.v4());
+        }
+    }
+
+    constructor(attributes?: any, isNew?: boolean) {
+        super(attributes);
+        if (isNew != null) {
+            this.isNew = () => {
+                return isNew;
+            };
+        }
+    }
+
+    // noinspection JSMethodCanBeStatic
+    get idAttribute(): string {
+        return "id";
+    }
+
+    get isDelete(): string {
+        return "is_deleted";
+    }
+
+    get hasTimestamps(): string[] {
+        return ["created_date", "updated_date"];
+    }
+
+    public initialize(): void {
+        this.on("saving", BaseDto.generateUuid);
+    }
+}

src/data/sql/models/category.dto.ts

+import * as Schema from "../schema";
+import { BaseDto } from "./base.dto";
+import { Database } from "../connection";
+
+// create by Nga
+export class CategoryDto extends BaseDto<CategoryDto> {
+    get tableName(): string {
+        return Schema.CATEGORY_TABLE_SCHEMA.TABLE_NAME;
+    }
+}
+
+export default CategoryDto;
+Database.bookshelf()["model"](Schema.CATEGORY_TABLE_SCHEMA.TABLE_NAME, CategoryDto);

src/data/sql/models/device.dto.ts

+import * as Schema from "../schema";
+import { BaseDto } from "./base.dto";
+import { Database } from "../connection";
+
+export class DeviceDto extends BaseDto<DeviceDto> {
+    get tableName() {
+        return Schema.DEVICE_TABLE_SCHEMA.TABLE_NAME;
+    }
+
+    public user(): any {
+        return this.belongsTo(Schema.USER_TABLE_SCHEMA.TABLE_NAME, Schema.DEVICE_TABLE_SCHEMA.FIELDS.USER_ID);
+    }
+}
+
+export default DeviceDto;
+// this fucking line of code just for bypass typescript compiler
+Database.bookshelf()["model"](Schema.DEVICE_TABLE_SCHEMA.TABLE_NAME, DeviceDto);

src/data/sql/models/index.ts

+export * from "./application.dto";
+export * from "./assign_presentation.dto";
+export * from "./base.dto";
+export * from "./device.dto";
+export * from "./language.dto";
+export * from "./language.dto";
+export * from "./media.dto";
+export * from "./package.dto";
+export * from "./presentation.dto";
+export * from "./presentation_report.dto";
+export * from "./role.dto";
+export * from "./session.dto";
+export * from "./setting.dto";
+export * from "./tag.dto";
+export * from "./user.dto";
+export * from "./user_code.dto";
+export * from "./user_package.dto";
+export * from "./user_presentation.dto";
+export * from "./user_tag.dto";
+export * from "./category.dto";
+export * from "./articles.dto";

src/data/sql/models/language.dto.ts

+import * as Schema from "../schema";
+import { BaseDto } from "./base.dto";
+import { Database } from "../connection";
+
+// create by Nga
+export class LanguageDto extends BaseDto<LanguageDto> {
+    get tableName(): string {
+        return Schema.LANGUAGE_TABLE_SCHEMA.TABLE_NAME;
+    }
+}
+
+export default LanguageDto;
+Database.bookshelf()["model"](Schema.LANGUAGE_TABLE_SCHEMA.TABLE_NAME, LanguageDto);

src/data/sql/models/media.dto.ts

+import * as Schema from "../schema";
+import { BaseDto } from "./base.dto";
+import { Database } from "../connection";
+
+export class MediaDto extends BaseDto<MediaDto> {
+    get tableName(): string {
+        return Schema.MEDIA_TABLE_SCHEMA.TABLE_NAME;
+    }
+}
+
+export default MediaDto;
+Database.bookshelf()["model"](Schema.MEDIA_TABLE_SCHEMA.TABLE_NAME, MediaDto);

src/data/sql/models/package.dto.ts

+import * as Schema from "../schema";
+import { BaseDto } from "./base.dto";
+import { Database } from "../connection";
+
+export class PackageDto extends BaseDto<PackageDto> {
+    get tableName(): string {
+        return Schema.PACKAGE_TABLE_SCHEMA.TABLE_NAME;
+    }
+}
+
+export default PackageDto;
+Database.bookshelf()["model"](Schema.PACKAGE_TABLE_SCHEMA.TABLE_NAME, PackageDto);

src/data/sql/models/presentation.dto.ts

+import * as Schema from "../schema";
+import { BaseDto } from "./base.dto";
+import { Database } from "../connection";
+
+export class PresentationDto extends BaseDto<PresentationDto> {
+    get tableName(): string {
+        return Schema.PRESENTATION_TABLE_SCHEMA.TABLE_NAME;
+    }
+    public user(): any {
+        return this.belongsTo(Schema.USER_TABLE_SCHEMA.TABLE_NAME, Schema.PRESENTATION_TABLE_SCHEMA.FIELDS.USER_ID);
+    }
+    public assignPresentation(): any {
+        return this.belongsTo(Schema.ASSIGN_PRESENTATION_TABLE_SCHEMA.TABLE_NAME, Schema.ASSIGN_PRESENTATION_TABLE_SCHEMA.FIELDS.PRESENTATION_ID);
+    }
+}
+
+export default PresentationDto;
+Database.bookshelf()["model"](Schema.PRESENTATION_TABLE_SCHEMA.TABLE_NAME, PresentationDto);

src/data/sql/models/presentation_report.dto.ts

+import * as Schema from "../schema";
+import { BaseDto } from "./base.dto";
+import { Database } from "../connection";
+
+export class PresentationReportDto extends BaseDto<PresentationReportDto> {
+    get tableName(): string {
+        return Schema.PRESENTATION_REPORT_TABLE_SCHEMA.TABLE_NAME;
+    }
+    public user(): any {
+        return this.belongsTo(Schema.USER_TABLE_SCHEMA.TABLE_NAME, Schema.PRESENTATION_REPORT_TABLE_SCHEMA.FIELDS.USER_ID);
+    }
+    public presentation(): any {
+        return this.belongsTo(Schema.PRESENTATION_TABLE_SCHEMA.TABLE_NAME, Schema.PRESENTATION_REPORT_TABLE_SCHEMA.FIELDS.PRESENTATION_ID);
+    }
+}
+
+export default PresentationReportDto;
+Database.bookshelf()["model"](Schema.PRESENTATION_REPORT_TABLE_SCHEMA.TABLE_NAME, PresentationReportDto);

src/data/sql/models/role.dto.ts

+import { BaseDto } from "./base.dto";
+import { ROLE_TABLE_SCHEMA } from "../schema";
+import { Database } from "../connection";
+
+export class RoleDto extends BaseDto<RoleDto> {
+    get tableName(): string {
+        return ROLE_TABLE_SCHEMA.TABLE_NAME;
+    }
+}
+export default RoleDto;
+Database.bookshelf()["model"]("roles", RoleDto);

src/data/sql/models/session.dto.ts

+import { BaseDto } from "./base.dto";
+import { SESSION_TABLE_SCHEMA , USER_TABLE_SCHEMA} from "./../schema";
+import { Database } from "../connection";
+
+export class SessionDto extends BaseDto<SessionDto> {
+    get tableName(): string {
+        return SESSION_TABLE_SCHEMA.TABLE_NAME;
+    }
+
+    public user(): any {
+        return this.belongsTo(USER_TABLE_SCHEMA.TABLE_NAME, SESSION_TABLE_SCHEMA.FIELDS.USER_ID);
+    }
+}
+
+export default SessionDto;
+Database.bookshelf()["model"](SESSION_TABLE_SCHEMA.TABLE_NAME, SessionDto);

src/data/sql/models/setting.dto.ts

+import { BaseDto } from "./base.dto";
+import { SETTING_TABLE_SCHEMA } from "./../schema";
+import { Database } from "../connection";
+
+export class SettingDto extends BaseDto<SettingDto> {
+    get tableName(): string {
+        return SETTING_TABLE_SCHEMA.TABLE_NAME;
+    }
+}
+
+export default SettingDto;
+Database.bookshelf()["model"](SETTING_TABLE_SCHEMA.TABLE_NAME, SettingDto);

src/data/sql/models/tag.dto.ts

+import { BaseDto } from "./base.dto";
+import { Database } from "../connection";
+import * as Schema from "../schema";
+
+export class TagDto extends BaseDto<TagDto> {
+    get tableName(): string {
+        return Schema.TAG_TABLE_SCHEMA.TABLE_NAME;
+    }
+
+    public user(): any {
+        return this.belongsTo(Schema.USER_TABLE_SCHEMA.TABLE_NAME, Schema.TAG_TABLE_SCHEMA.FIELDS.USER_ID);
+    }
+}
+
+export default TagDto;
+Database.bookshelf()["model"](Schema.TAG_TABLE_SCHEMA.TABLE_NAME, TagDto);

src/data/sql/models/user.dto.ts

+import * as Schema from "../schema";
+import { BaseDto } from "./base.dto";
+import { Database } from "../connection";
+
+export class UserDto extends BaseDto<UserDto> {
+    get tableName(): string {
+        return Schema.USER_TABLE_SCHEMA.TABLE_NAME;
+    }
+    public role(): any {
+        return this.belongsTo(Schema.ROLE_TABLE_SCHEMA.TABLE_NAME, Schema.USER_TABLE_SCHEMA.FIELDS.ROLE_ID);
+    }
+    public account(): any {
+        return this.hasMany(UserDto, Schema.USER_TABLE_SCHEMA.FIELDS.PARENT_ID).query(q => {
+            q.where(`${Schema.USER_TABLE_SCHEMA.TABLE_NAME}.${Schema.USER_TABLE_SCHEMA.FIELDS.IS_DELETED}`, false);
+        });
+    }
+    public tag(): any {
+        return this.hasMany(Schema.TAG_TABLE_SCHEMA.TABLE_NAME, Schema.TAG_TABLE_SCHEMA.FIELDS.USER_ID).query(q => {
+            q.where(`${Schema.TAG_TABLE_SCHEMA.TABLE_NAME}.${Schema.TAG_TABLE_SCHEMA.FIELDS.IS_DELETED}`, false);
+        });
+    }
+    public userTag(): any {
+        return this.hasMany(Schema.USER_TAG_TABLE_SCHEMA.TABLE_NAME).query(q => {
+            q.where(`${Schema.USER_TAG_TABLE_SCHEMA.TABLE_NAME}.${Schema.USER_TAG_TABLE_SCHEMA.FIELDS.IS_DELETED}`, false);
+        });
+    }
+    public userPackage(): any {
+        return this.hasMany(Schema.USER_PACKAGE_TABLE_SCHEMA.TABLE_NAME).query(q => {
+            q.where(`${Schema.USER_PACKAGE_TABLE_SCHEMA.TABLE_NAME}.${Schema.USER_PACKAGE_TABLE_SCHEMA.FIELDS.IS_DELETED}`, false);
+        });
+    }
+    public presentation(): any {
+        return this.hasMany(Schema.PRESENTATION_TABLE_SCHEMA.TABLE_NAME, Schema.PRESENTATION_TABLE_SCHEMA.FIELDS.USER_ID).query(q => {
+            q.where(`${Schema.PRESENTATION_TABLE_SCHEMA.TABLE_NAME}.${Schema.PRESENTATION_TABLE_SCHEMA.FIELDS.IS_DELETED}`, false);
+        });
+    }
+    public userPresentation(): any {
+        return this.hasMany(Schema.USER_PRESENTATION_TABLE_SCHEMA.TABLE_NAME).query(q => {
+            q.where(`${Schema.USER_PRESENTATION_TABLE_SCHEMA.TABLE_NAME}.${Schema.USER_PRESENTATION_TABLE_SCHEMA.FIELDS.IS_DELETED}`, false);
+        });
+    }
+}
+
+export default UserDto;
+Database.bookshelf()["model"](Schema.USER_TABLE_SCHEMA.TABLE_NAME, UserDto);

src/data/sql/models/user_code.dto.ts

+import * as Schema from "../schema";
+import { BaseDto } from "./base.dto";
+import { Database } from "../connection";
+
+export class UserCodeDto extends BaseDto<UserCodeDto> {
+    get tableName(): string {
+        return Schema.USER_CODE_TABLE_SCHEMA.TABLE_NAME;
+    }
+    public user(): any {
+        return this.belongsTo(Schema.USER_TABLE_SCHEMA.TABLE_NAME, Schema.USER_CODE_TABLE_SCHEMA.FIELDS.USER_ID);
+    }
+}
+
+export default UserCodeDto;
+Database.bookshelf()["model"](Schema.USER_CODE_TABLE_SCHEMA.TABLE_NAME, UserCodeDto);

src/data/sql/models/user_package.dto.ts

+import * as Schema from "../schema";
+import { BaseDto } from "./base.dto";
+import { Database } from "../connection";
+
+export class UserPackageDto extends BaseDto<UserPackageDto> {
+    get tableName(): string {
+        return Schema.USER_PACKAGE_TABLE_SCHEMA.TABLE_NAME;
+    }
+    public user(): any {
+        return this.belongsTo(Schema.USER_TABLE_SCHEMA.TABLE_NAME, Schema.USER_PACKAGE_TABLE_SCHEMA.FIELDS.USER_ID);
+    }
+    public package(): any {
+        return this.belongsTo(Schema.PACKAGE_TABLE_SCHEMA.TABLE_NAME, Schema.USER_PACKAGE_TABLE_SCHEMA.FIELDS.PACKAGE_ID);
+    }
+}
+
+export default UserPackageDto;
+Database.bookshelf()["model"](Schema.USER_PACKAGE_TABLE_SCHEMA.TABLE_NAME, UserPackageDto);

src/data/sql/models/user_presentation.dto.ts

+import * as Schema from "../schema";
+import { BaseDto } from "./base.dto";
+import { Database } from "../connection";
+
+export class UserPresentationDto extends BaseDto<UserPresentationDto> {
+    get tableName(): string {
+        return Schema.USER_PRESENTATION_TABLE_SCHEMA.TABLE_NAME;
+    }
+    public user(): any {
+        return this.belongsTo(Schema.USER_TABLE_SCHEMA.TABLE_NAME, Schema.USER_PRESENTATION_TABLE_SCHEMA.FIELDS.USER_ID);
+    }
+    public presentation(): any {
+        return this.belongsTo(Schema.PRESENTATION_TABLE_SCHEMA.TABLE_NAME, Schema.USER_PRESENTATION_TABLE_SCHEMA.FIELDS.PRESENTATION_ID);
+    }
+}
+
+export default UserPresentationDto;
+Database.bookshelf()["model"](Schema.USER_PRESENTATION_TABLE_SCHEMA.TABLE_NAME, UserPresentationDto);

src/data/sql/models/user_tag.dto.ts

+import * as Schema from "../schema";
+import { BaseDto } from "./base.dto";
+import { Database } from "../connection";
+
+export class UserTagDto extends BaseDto<UserTagDto> {
+    get tableName(): string {
+        return Schema.USER_TAG_TABLE_SCHEMA.TABLE_NAME;
+    }
+    public user(): any {
+        return this.belongsTo(Schema.USER_TABLE_SCHEMA.TABLE_NAME, Schema.USER_TAG_TABLE_SCHEMA.FIELDS.USER_ID);
+    }
+    public tag(): any {
+        return this.belongsTo(Schema.TAG_TABLE_SCHEMA.TABLE_NAME, Schema.USER_TAG_TABLE_SCHEMA.FIELDS.TAG_ID);
+    }
+}
+
+export default UserTagDto;
+Database.bookshelf()["model"](Schema.USER_TAG_TABLE_SCHEMA.TABLE_NAME, UserTagDto);

src/data/sql/schema.ts

+/**
+ * Created by phuongho on 15/08/17.
+ */
+
+export const HEALTH_TABLE_SCHEMA = {
+    TABLE_NAME: "health",
+    FIELDS: {
+        ID: "id"
+    }
+};
+
+export const APPLICATION_TABLE_SCHEMA = {
+    TABLE_NAME: "application",
+    FIELDS: {
+        ID: "id",
+        IS_DELETED: "is_deleted",
+        CREATED_DATE: "created_date",
+        UPDATED_DATE: "updated_date",
+        PLATFORM: "platform",
+        VERSION: "version",
+        IS_LATEST: "is_latest",
+        FORCE_UPDATE: "force_update"
+    }
+};
+
+export const SESSION_TABLE_SCHEMA = {
+    TABLE_NAME: "sessions",
+    FIELDS: {
+        ID: "id",
+        CREATED_DATE: "created_date",
+        UPDATED_DATE: "updated_date",
+        IS_DELETED: "is_deleted",
+        USER_ID: "user_id",
+        TOKEN: "token",
+        EXPIRE: "expire",
+        HASH: "hash"
+    },
+};
+
+export const ROLE_TABLE_SCHEMA = {
+    TABLE_NAME: "roles",
+    FIELDS: {
+        ID: "id",
+        IS_DELETED: "is_deleted",
+        CREATED_DATE: "created_date",
+        UPDATED_DATE: "updated_date",
+        NAME: "name",
+        KEYWORD: "keyword",
+        DESCRIPTION: "description"
+    },
+};
+
+export const DEVICE_TABLE_SCHEMA = {
+    TABLE_NAME: "devices",
+    FIELDS: {
+        ID: "id",
+        IS_DELETED: "is_deleted",
+        CREATED_DATE: "created_date",
+        UPDATED_DATE: "updated_date",
+        USER_ID: "user_id",
+        DEVICE_ID: "device_id",
+        REGISTRAR_ID: "registrar_id",
+        DEVICE_OS: "device_os",
+        DEVICE_MODEL: "device_model",
+        DEVICE_NAME: "device_name",
+        OS_VERSION: "os_version",
+        APP_VERSION: "app_version",
+        BUILD_VERSION: "build_version",
+        IS_SANDBOX: "is_sandbox"
+    },
+};
+
+export const USER_TABLE_SCHEMA = {
+    TABLE_NAME: "users",
+    FIELDS: {
+        ID: "id",
+        IS_DELETED: "is_deleted",
+        IS_ENABLE: "is_enable",
+        CREATED_DATE: "created_date",
+        UPDATED_DATE: "updated_date",
+        FIRST_NAME: "first_name",
+        LAST_NAME: "last_name",
+        PHONE_NUMBER: "phone_number",
+        EMAIL: "email",
+        PASSWORD: "password",
+        ROLE_ID: "role_id",
+        AVATAR_URL: "avatar_url",
+        PARENT_ID: "parent_id",
+        COMPANY: "company",
+        ADDRESS: "address",
+        COUNTRY: "country",
+        STATE: "state",
+        PROVINCE: "province",
+        TAG: "tag",
+        LANGUAGE: "language",
+    },
+};
+
+export const MEDIA_TABLE_SCHEMA = {
+    TABLE_NAME: "media",
+    FIELDS: {
+        ID: "id",
+        IS_ENABLE: "is_enable",
+        IS_DELETED: "is_deleted",
+        CREATED_DATE: "created_date",
+        UPDATED_DATE: "updated_date",
+        PATH: "path",
+        URL: "url",
+        HASH: "hash",
+    },
+};
+
+export const TAG_TABLE_SCHEMA = {
+    TABLE_NAME: "tags",
+    FIELDS: {
+        ID: "id",
+        IS_DELETED: "is_deleted",
+        IS_ENABLE: "is_enable",
+        CREATED_DATE: "created_date",
+        UPDATED_DATE: "updated_date",
+        USER_ID: "user_id",
+        NAME: "name",
+        DESCRIPTION: "description"
+    },
+};
+
+export const USER_TAG_TABLE_SCHEMA = {
+    TABLE_NAME: "user_tags",
+    FIELDS: {
+        ID: "id",
+        IS_DELETED: "is_deleted",
+        CREATED_DATE: "created_date",
+        UPDATED_DATE: "updated_date",
+        USER_ID: "user_id",
+        TAG_ID: "tag_id"
+    },
+};
+
+export const PACKAGE_TABLE_SCHEMA = {
+    TABLE_NAME: "packages",
+    FIELDS: {
+        ID: "id",
+        IS_DELETED: "is_deleted",
+        IS_ENABLE: "is_enable",
+        CREATED_DATE: "created_date",
+        UPDATED_DATE: "updated_date",
+        NAME: "name",
+        DESCRIPTION: "description",
+        NUMBER_ACCOUNT: "number_account",
+        NUMBER_FILE: "number_file",
+        PRICE: "price",
+        PRIORITY: "priority"
+    },
+};
+
+export const USER_PACKAGE_TABLE_SCHEMA = {
+    TABLE_NAME: "user_packages",
+    FIELDS: {
+        ID: "id",
+        IS_DELETED: "is_deleted",
+        CREATED_DATE: "created_date",
+        UPDATED_DATE: "updated_date",
+        USER_ID: "user_id",
+        PACKAGE_ID: "package_id",
+        NUMBER_ACCOUNT: "number_account",
+        NUMBER_FILE: "number_file",
+        PRICE: "price"
+    },
+};
+
+export const PRESENTATION_TABLE_SCHEMA = {
+    TABLE_NAME: "presentation",
+    FIELDS: {
+        ID: "id",
+        IS_DELETED: "is_deleted",
+        IS_ENABLE: "is_enable",
+        CREATED_DATE: "created_date",
+        UPDATED_DATE: "updated_date",
+        USER_ID: "user_id",
+        USER_CODE: "user_code",
+        TITLE: "title",
+        DESCRIPTION: "description",
+        IMAGE_URL: "image_url",
+        NUMBER_PAGE: "number_page",
+        PAGE_TIMING: "page_timing",
+        FILE_URL: "file_url",
+        LANGUAGE: "language",
+        PRIORITY: "priority"
+    },
+};
+
+export const ASSIGN_PRESENTATION_TABLE_SCHEMA = {
+    TABLE_NAME: "assign_presentation",
+    FIELDS: {
+        ID: "id",
+        IS_DELETED: "is_deleted",
+        CREATED_DATE: "created_date",
+        UPDATED_DATE: "updated_date",
+        PRESENTATION_ID: "presentation_id",
+        COUNTRY: "country",
+        STATE: "state",
+        PROVINCE: "province",
+        TAG: "tags",
+        USER: "users"
+    },
+};
+
+export const USER_PRESENTATION_TABLE_SCHEMA = {
+    TABLE_NAME: "user_presentation",
+    FIELDS: {
+        ID: "id",
+        IS_DELETED: "is_deleted",
+        CREATED_DATE: "created_date",
+        UPDATED_DATE: "updated_date",
+        USER_ID: "user_id",
+        PRESENTATION_ID: "presentation_id"
+    },
+};
+
+export const PRESENTATION_REPORT_TABLE_SCHEMA = {
+    TABLE_NAME: "presentation_report",
+    FIELDS: {
+        ID: "id",
+        IS_DELETED: "is_deleted",
+        CREATED_DATE: "created_date",
+        UPDATED_DATE: "updated_date",
+        USER_ID: "user_id",
+        PRESENTATION_ID: "presentation_id",
+        START_DATE: "start_date",
+        END_DATE: "end_date",
+        PAGE_TIMING: "page_timing",
+        LATITUDE: "latitude",
+        LONGITUDE: "longitude",
+        NOTE: "note",
+        AUDIO_URL: "audio_url",
+        RATE: "rate",
+    }
+};
+
+export const USER_CODE_TABLE_SCHEMA = {
+    TABLE_NAME: "user_codes",
+    FIELDS: {
+        ID: "id",
+        IS_DELETED: "is_deleted",
+        CREATED_DATE: "created_date",
+        UPDATED_DATE: "updated_date",
+        USER_ID: "user_id",
+        NAME: "name",
+        CODE: "code",
+        IS_USED: "is_used"
+    },
+};
+
+export const SETTING_TABLE_SCHEMA = {
+    TABLE_NAME: "settings",
+    FIELDS: {
+        ID: "id",
+        CREATED_DATE: "created_date",
+        UPDATED_DATE: "updated_date",
+        IS_ENABLE: "is_enable",
+        IS_DELETED: "is_deleted",
+        KEYWORD: "key",
+        VALUE: "value",
+        DESC: "description",
+    },
+};
+
+export const LANGUAGE_TABLE_SCHEMA = {
+    TABLE_NAME: "languages",
+    FIELDS: {
+        ID: "id",
+        CREATED_DATE: "created_date",
+        UPDATED_DATE: "updated_date",
+        IS_DELETED: "is_deleted",
+        NAME: "name",
+        CODE: "code",
+        PRIORITY: "priority",
+    },
+};
+// create by Anh Nga 31-10-2017
+export const CATEGORY_TABLE_SCHEMA = {
+    TABLE_NAME: "category",
+    FIELDS: {
+        ID: "id",
+        CREATED_DATE: "created_date",
+        UPDATED_DATE: "updated_date",
+        IS_DELETED: "is_deleted",
+        NAME: "name",
+
+    },
+};
+
+export const ARTICLES_TABLE_SCHEMA = {
+    TABLE_NAME: "articles",
+    FIELDS: {
+        ID: "id",
+        CREATED_DATE: "created_date",
+        UPDATED_DATE: "updated_date",
+        IS_DELETED: "is_deleted",
+        TITLE: "title",
+        CATEGORY_ID: "category_id",
+    },
+};
+
+export const COMMENT_TABLE_SCHEMA = {
+    TABLE_NAME: "comment",
+    FIELDS: {
+        ID: "id",
+        CREATED_DATE: "created_date",
+        UPDATED_DATE: "updated_date",
+        IS_DELETED: "is_deleted",
+        NAME_FB: "name_fb",
+        ARTICLES_ID: "articles_id",
+        DETAIL_COMMENT: "detail_comment",
+    },
+};

src/data/tag.repository.ts

+/**
+ * Created by phuongho on 15/08/17.
+ */
+import * as Promise from "bluebird";
+import * as Schema from "../data/sql/schema";
+import { BaseRepository, Log } from "./base.repository";
+import { CollectionWrap, TagModel } from "./../models";
+import { TAG_TABLE_SCHEMA } from "./sql/schema";
+import { TagDto } from "./sql/models";
+import { injectable, inject } from "inversify";
+
+@injectable()
+export class TagRepository extends BaseRepository<TagDto, TagModel> {
+    constructor( @inject("Logger") log?: Log) {
+        super(TagDto, TagModel, log);
+    }
+
+    /**
+    * search Tag
+    * @param searchParams
+    * @param offset
+    * @param limit
+    * @param related
+    * @param filters
+    * @returns {Promise<any[]>}
+    */
+    public search(searchParams: any = {}, offset: number, limit: number, related = [], filters = []): Promise<CollectionWrap<TagModel>> {
+        let keyword = searchParams.key || null;
+        limit = limit || null;
+        offset = offset || null;
+
+        let query = () => {
+            return (q): void => {
+                q.where(`${Schema.TAG_TABLE_SCHEMA.TABLE_NAME}.${Schema.TAG_TABLE_SCHEMA.FIELDS.IS_DELETED}`, false);
+                if (searchParams.key) {
+                    q.where(q1 => {
+                        q1.where(`${Schema.TAG_TABLE_SCHEMA.TABLE_NAME}.${Schema.TAG_TABLE_SCHEMA.FIELDS.NAME}`, "ILIKE", `%${keyword}%`);
+                    });
+                }
+                if (searchParams.userId) {
+                    q.where(`${Schema.TAG_TABLE_SCHEMA.TABLE_NAME}.${Schema.TAG_TABLE_SCHEMA.FIELDS.USER_ID}`, searchParams.userId);
+                }
+                let orderBy = searchParams.orderBy || `${Schema.TAG_TABLE_SCHEMA.TABLE_NAME}.${Schema.TAG_TABLE_SCHEMA.FIELDS.CREATED_DATE}`;
+                let orderType = searchParams.orderType || "DESC";
+                q.orderBy(orderBy, orderType);
+            };
+        };
+        return this.queryByPage(query(), offset, limit, related, filters);
+    }
+
+}
+export default TagRepository;

src/data/user.repository.ts

+import { BaseRepository, Log } from "./base.repository";
+import { UserDto } from "./sql/models";
+import { UserModel, CollectionWrap } from "../models";
+import * as Schema from "../data/sql/schema";
+import * as Promise from "bluebird";
+import { DELETE_STATUS, ROLE } from "../libs/constants";
+import { injectable, inject } from "inversify";
+
+@injectable()
+export class UserRepository extends BaseRepository<UserDto, UserModel> {
+    constructor( @inject("Logger") log?: Log) {
+        super(UserDto, UserModel, log);
+    }
+
+    /**
+     *
+     * @param email
+     * @param related
+     * @param filters
+     * @returns {Promise<any[]>}
+     */
+    public findByEmail(email: string, related = [], filters = []): Promise<UserModel> {
+        return this.findOneByQuery(q => {
+            q.where(Schema.USER_TABLE_SCHEMA.FIELDS.EMAIL, email);
+            q.where(Schema.USER_TABLE_SCHEMA.FIELDS.IS_DELETED, DELETE_STATUS.NO);
+        }, related, filters);
+    }
+
+    /**
+     * search User
+     * @param searchParams
+     * @param offset
+     * @param limit
+     * @param related
+     * @param filters
+     * @returns {Promise<any[]>}
+     */
+    public search(searchParams: any = {}, offset: number, limit: number, related = [], filters = []): Promise<CollectionWrap<UserModel>> {
+        let keyword = searchParams.key || null;
+        limit = limit || null;
+        offset = offset || null;
+
+        let query = () => {
+            return (q): void => {
+                q.where(`${Schema.USER_TABLE_SCHEMA.TABLE_NAME}.${Schema.USER_TABLE_SCHEMA.FIELDS.IS_DELETED}`, false);
+                if (searchParams.tags) {
+                    let tags = searchParams.tags.split(",");
+                    q.leftJoin(`${Schema.USER_TAG_TABLE_SCHEMA.TABLE_NAME}`, `${Schema.USER_TAG_TABLE_SCHEMA.TABLE_NAME}.${Schema.USER_TAG_TABLE_SCHEMA.FIELDS.USER_ID}`, `${Schema.USER_TABLE_SCHEMA.TABLE_NAME}.${Schema.USER_TABLE_SCHEMA.FIELDS.ID}`);
+                    q.whereIn(Schema.USER_TAG_TABLE_SCHEMA.FIELDS.TAG_ID, tags);
+                }
+                if (searchParams.parentId) {
+                    q.where(`${Schema.USER_TABLE_SCHEMA.TABLE_NAME}.${Schema.USER_TABLE_SCHEMA.FIELDS.PARENT_ID}`, searchParams.parentId);
+                }
+                if (searchParams.currentUserId) {
+                    q.where(`${Schema.USER_TABLE_SCHEMA.TABLE_NAME}.${Schema.USER_TABLE_SCHEMA.FIELDS.ID}`, "!=", searchParams.currentUserId);
+                }
+                if (searchParams.roleId) {
+                    q.where(Schema.USER_TABLE_SCHEMA.FIELDS.ROLE_ID, searchParams.roleId);
+                }
+                if (searchParams.country) {
+                    q.where(Schema.USER_TABLE_SCHEMA.FIELDS.COUNTRY, "ILIKE", searchParams.country);
+                }
+                if (searchParams.state) {
+                    q.where(Schema.USER_TABLE_SCHEMA.FIELDS.STATE, "ILIKE", searchParams.state);
+                }
+                if (searchParams.province) {
+                    q.where(Schema.USER_TABLE_SCHEMA.FIELDS.PROVINCE, "ILIKE", searchParams.province);
+                }
+
+                if (searchParams.key) {
+                    q.where(q1 => {
+                        q1.where(`${Schema.USER_TABLE_SCHEMA.TABLE_NAME}.${Schema.USER_TABLE_SCHEMA.FIELDS.FIRST_NAME}`, "ILIKE", `%${keyword}%`);
+                        q1.where(`${Schema.USER_TABLE_SCHEMA.TABLE_NAME}.${Schema.USER_TABLE_SCHEMA.FIELDS.LAST_NAME}`, "ILIKE", `%${keyword}%`);
+                        q1.orWhere(`${Schema.USER_TABLE_SCHEMA.TABLE_NAME}.${Schema.USER_TABLE_SCHEMA.FIELDS.EMAIL}`, "ILIKE", `%${keyword}%`);
+                    });
+                }
+                let orderBy = searchParams.orderBy || `${Schema.USER_TABLE_SCHEMA.TABLE_NAME}.${Schema.USER_TABLE_SCHEMA.FIELDS.FIRST_NAME}`;
+                let orderType = searchParams.orderType || "ASC";
+                q.orderByRaw(`lower(${orderBy}) ${orderType}`);
+            };
+        };
+        return this.queryByPage(query(), offset, limit, related, filters);
+    }
+
+}
+export default UserRepository;

src/data/user_code.repository.ts

+import { Log } from "./../libs/logger";
+import { USER_CODE_TABLE_SCHEMA } from "./sql/schema";
+import { CollectionWrap } from "./../models/collections";
+import { BaseRepository } from "./base.repository";
+import { UserCodeDto } from "./sql/models";
+import { UserCodeModel } from "../models";
+import * as Schema from "../data/sql/schema";
+import * as Promise from "bluebird";
+import { injectable, inject } from "inversify";
+
+@injectable()
+export class UserCodeRepository extends BaseRepository<UserCodeDto, UserCodeModel> {
+    constructor( @inject("Logger") log?: Log) {
+        super(UserCodeDto, UserCodeModel, log);
+    }
+
+    /**
+    * search UserCode
+    * @param searchParams
+    * @param offset
+    * @param limit
+    * @param related
+    * @param filters
+    * @returns {Promise<any[]>}
+    */
+    public search(searchParams: any = {}, offset: number, limit: number, related = [], filters = []): Promise<CollectionWrap<UserCodeModel>> {
+        let keyword = searchParams.key || null;
+        limit = limit || null;
+        offset = offset || null;
+
+        let query = () => {
+            return (q): void => {
+                q.where(`${Schema.USER_CODE_TABLE_SCHEMA.TABLE_NAME}.${Schema.USER_CODE_TABLE_SCHEMA.FIELDS.IS_DELETED}`, false);
+                if (searchParams.key) {
+                    q.where(q1 => {
+                        q1.where(`${Schema.USER_CODE_TABLE_SCHEMA.TABLE_NAME}.${Schema.USER_CODE_TABLE_SCHEMA.FIELDS.NAME}`, "ILIKE", `%${keyword}%`);
+                    });
+                }
+                if (searchParams.userId) {
+                    q.where(`${Schema.USER_CODE_TABLE_SCHEMA.TABLE_NAME}.${Schema.USER_CODE_TABLE_SCHEMA.FIELDS.USER_ID}`, searchParams.userId);
+                }
+                if (searchParams.isUsed) {
+                    q.where(`${Schema.USER_CODE_TABLE_SCHEMA.TABLE_NAME}.${Schema.USER_CODE_TABLE_SCHEMA.FIELDS.IS_USED}`, searchParams.isUsed);
+                }
+                let orderBy = searchParams.orderBy || `${Schema.USER_CODE_TABLE_SCHEMA.TABLE_NAME}.${Schema.USER_CODE_TABLE_SCHEMA.FIELDS.CREATED_DATE}`;
+                let orderType = searchParams.orderType || "DESC";
+                q.orderBy(orderBy, orderType);
+            };
+        };
+        return this.queryByPage(query(), offset, limit, related, filters);
+    }
+
+    /**
+     *
+     * @param code
+     * @param related
+     * @param filters
+     */
+    public findByCode(code: string, related = [], filters = []): Promise<UserCodeModel> {
+        let conditions: any = {};
+        conditions[Schema.USER_CODE_TABLE_SCHEMA.FIELDS.CODE] = code;
+        conditions[Schema.USER_CODE_TABLE_SCHEMA.FIELDS.IS_DELETED] = false;
+        conditions[Schema.USER_CODE_TABLE_SCHEMA.FIELDS.IS_USED] = false;
+
+        return this.findOneByAtribute({ conditions: conditions });
+    }
+
+}
+export default UserCodeRepository;

src/data/user_package.repository.ts

+/**
+ * Created by phuongho on 15/08/17.
+ */
+import * as Promise from "bluebird";
+import * as Schema from "../data/sql/schema";
+import { BaseRepository, Log } from "./base.repository";
+import { CollectionWrap, UserPackageModel } from "./../models";
+import { USER_PACKAGE_TABLE_SCHEMA } from "./sql/schema";
+import { UserPackageDto } from "./sql/models";
+import { injectable, inject } from "inversify";
+
+@injectable()
+export class UserPackageRepository extends BaseRepository<UserPackageDto, UserPackageModel> {
+    constructor( @inject("Logger") log?: Log) {
+        super(UserPackageDto, UserPackageModel, log);
+    }
+
+    /**
+    * search UserPackage
+    * @param searchParams
+    * @param offset
+    * @param limit
+    * @param related
+    * @param filters
+    * @returns {Promise<any[]>}
+    */
+    public search(searchParams: any = {}, offset: number, limit: number, related = [], filters = []): Promise<CollectionWrap<UserPackageModel>> {
+        let keyword = searchParams.key || null;
+        limit = limit || null;
+        offset = offset || null;
+
+        let query = () => {
+            return (q): void => {
+                q.leftJoin(`${Schema.PACKAGE_TABLE_SCHEMA.TABLE_NAME}`, `${Schema.USER_PACKAGE_TABLE_SCHEMA.TABLE_NAME}.${Schema.USER_PACKAGE_TABLE_SCHEMA.FIELDS.PACKAGE_ID}`, `${Schema.PACKAGE_TABLE_SCHEMA.TABLE_NAME}.${Schema.PACKAGE_TABLE_SCHEMA.FIELDS.ID}`);
+                q.where(`${Schema.USER_PACKAGE_TABLE_SCHEMA.TABLE_NAME}.${Schema.USER_PACKAGE_TABLE_SCHEMA.FIELDS.IS_DELETED}`, false);
+                if (searchParams.key) {
+                    q.where(q1 => {
+                        q1.where(`${Schema.PACKAGE_TABLE_SCHEMA.TABLE_NAME}.${Schema.PACKAGE_TABLE_SCHEMA.FIELDS.NAME}`, "ILIKE", `%${keyword}%`);
+                    });
+                }
+                if (searchParams.userId) {
+                    q.where(`${Schema.USER_PACKAGE_TABLE_SCHEMA.TABLE_NAME}.${Schema.USER_PACKAGE_TABLE_SCHEMA.FIELDS.USER_ID}`, searchParams.userId);
+                }
+                let orderBy = searchParams.orderBy || `${Schema.USER_PACKAGE_TABLE_SCHEMA.TABLE_NAME}.${Schema.USER_PACKAGE_TABLE_SCHEMA.FIELDS.CREATED_DATE}`;
+                let orderType = searchParams.orderType || "DESC";
+                q.orderBy(orderBy, orderType);
+            };
+        };
+        return this.queryByPage(query(), offset, limit, related, filters);
+    }
+
+    /**
+    *
+    * @param userId
+    */
+    public getInfoByUserId(userId: string): Promise<{ numberFile: number, numberAccount: number }> {
+        let ret: any = null;
+        let numberFile: number = 0;
+        let numberAccount: number = 0;
+
+        return this.findByQuery(q => {
+            q.where(Schema.USER_PACKAGE_TABLE_SCHEMA.FIELDS.IS_DELETED, false);
+            q.where(Schema.USER_PACKAGE_TABLE_SCHEMA.FIELDS.USER_ID, userId);
+        })
+            .then(objects => {
+                if (objects) {
+                    objects.forEach(item => {
+                        numberFile += item.numberFile;
+                        numberAccount += item.numberAccount;
+                    });
+                    ret = {};
+                    ret.numberFile = numberFile;
+                    ret.numberAccount = numberAccount;
+                }
+                return ret;
+            });
+    }
+
+}
+export default UserPackageRepository;

src/data/user_presentation.repository.ts

+/**
+ * Created by phuongho on 15/08/17.
+ */
+import * as Promise from "bluebird";
+import * as Schema from "../data/sql/schema";
+import { BaseRepository, Log } from "./base.repository";
+import { CollectionWrap, UserPresentationModel } from "./../models";
+import { USER_PRESENTATION_TABLE_SCHEMA } from "./sql/schema";
+import { UserPresentationDto } from "./sql/models";
+import { injectable, inject } from "inversify";
+
+@injectable()
+export class UserPresentationRepository extends BaseRepository<UserPresentationDto, UserPresentationModel> {
+    constructor( @inject("Logger") log?: Log) {
+        super(UserPresentationDto, UserPresentationModel, log);
+    }
+
+    /**
+    * search UserPresentation
+    * @param searchParams
+    * @param offset
+    * @param limit
+    * @param related
+    * @param filters
+    * @returns {Promise<any[]>}
+    */
+    public search(searchParams: any = {}, offset: number, limit: number, related = [], filters = []): Promise<CollectionWrap<UserPresentationModel>> {
+        let keyword = searchParams.key || null;
+        limit = limit || null;
+        offset = offset || null;
+
+        let query = () => {
+            return (q): void => {
+                q.leftJoin(`${Schema.PRESENTATION_TABLE_SCHEMA.TABLE_NAME}`, `${Schema.USER_PRESENTATION_TABLE_SCHEMA.TABLE_NAME}.${Schema.USER_PRESENTATION_TABLE_SCHEMA.FIELDS.PRESENTATION_ID}`, `${Schema.PRESENTATION_TABLE_SCHEMA.TABLE_NAME}.${Schema.PRESENTATION_TABLE_SCHEMA.FIELDS.ID}`);
+                q.where(`${Schema.USER_PRESENTATION_TABLE_SCHEMA.TABLE_NAME}.${Schema.USER_PRESENTATION_TABLE_SCHEMA.FIELDS.IS_DELETED}`, false);
+                if (searchParams.key) {
+                    q.where(q1 => {
+                        q1.where(`${Schema.PRESENTATION_TABLE_SCHEMA.TABLE_NAME}.${Schema.PRESENTATION_TABLE_SCHEMA.FIELDS.TITLE}`, "ILIKE", `%${keyword}%`);
+                    });
+                }
+                if (searchParams.userId) {
+                    q.where(`${Schema.USER_PRESENTATION_TABLE_SCHEMA.TABLE_NAME}.${Schema.USER_PRESENTATION_TABLE_SCHEMA.FIELDS.USER_ID}`, searchParams.userId);
+                }
+                let orderBy = searchParams.orderBy || `${Schema.PRESENTATION_TABLE_SCHEMA.TABLE_NAME}.${Schema.PRESENTATION_TABLE_SCHEMA.FIELDS.PRIORITY}`;
+                let orderType = searchParams.orderType || "ASC";
+                q.orderBy(orderBy, orderType);
+            };
+        };
+        return this.queryByPage(query(), offset, limit, related, filters);
+    }
+
+}
+export default UserPresentationRepository;

src/data/user_tag.repository.ts

+/**
+ * Created by phuongho on 15/08/17.
+ */
+import * as Promise from "bluebird";
+import * as Schema from "../data/sql/schema";
+import { BaseRepository, Log } from "./base.repository";
+import { CollectionWrap, UserTagModel } from "./../models";
+import { USER_TAG_TABLE_SCHEMA } from "./sql/schema";
+import { UserTagDto } from "./sql/models";
+import { injectable, inject } from "inversify";
+
+@injectable()
+export class UserTagRepository extends BaseRepository<UserTagDto, UserTagModel> {
+    constructor( @inject("Logger") log?: Log) {
+        super(UserTagDto, UserTagModel, log);
+    }
+
+    /**
+    * search UserTag
+    * @param searchParams
+    * @param offset
+    * @param limit
+    * @param related
+    * @param filters
+    * @returns {Promise<any[]>}
+    */
+    public search(searchParams: any = {}, offset: number, limit: number, related = [], filters = []): Promise<CollectionWrap<UserTagModel>> {
+        let keyword = searchParams.key || null;
+        limit = limit || null;
+        offset = offset || null;
+
+        let query = () => {
+            return (q): void => {
+                q.leftJoin(`${Schema.TAG_TABLE_SCHEMA.TABLE_NAME}`, `${Schema.USER_TAG_TABLE_SCHEMA.TABLE_NAME}.${Schema.USER_TAG_TABLE_SCHEMA.FIELDS.TAG_ID}`, `${Schema.TAG_TABLE_SCHEMA.TABLE_NAME}.${Schema.TAG_TABLE_SCHEMA.FIELDS.ID}`);
+                q.where(`${Schema.USER_TAG_TABLE_SCHEMA.TABLE_NAME}.${Schema.USER_TAG_TABLE_SCHEMA.FIELDS.IS_DELETED}`, false);
+                if (searchParams.key) {
+                    q.where(q1 => {
+                        q1.where(`${Schema.TAG_TABLE_SCHEMA.TABLE_NAME}.${Schema.TAG_TABLE_SCHEMA.FIELDS.NAME}`, "ILIKE", `%${keyword}%`);
+                    });
+                }
+                if (searchParams.userId) {
+                    q.where(`${Schema.USER_TAG_TABLE_SCHEMA.TABLE_NAME}.${Schema.USER_TAG_TABLE_SCHEMA.FIELDS.USER_ID}`, searchParams.userId);
+                }
+                let orderBy = searchParams.orderBy || `${Schema.USER_TAG_TABLE_SCHEMA.TABLE_NAME}.${Schema.USER_TAG_TABLE_SCHEMA.FIELDS.CREATED_DATE}`;
+                let orderType = searchParams.orderType || "DESC";
+                q.orderBy(orderBy, orderType);
+            };
+        };
+        return this.queryByPage(query(), offset, limit, related, filters);
+    }
+
+}
+export default UserTagRepository;

src/interactors/articles.service.ts

+/**
+ * Created by Anh Nga on 13/10/2017
+ */
+import * as Promise from "bluebird";
+import * as Schema from "../data/sql/schema";
+import { BaseService, Log } from "./base.service";
+import { CollectionWrap, ExceptionModel, ArticlesModel } from "../models";
+import { DELETE_STATUS } from "../libs/constants";
+import { ErrorCode, HttpStatus, logger as Logger } from "../libs";
+import { ArticlesRepository } from "../data";
+import { injectable, inject } from "inversify";
+
+@injectable()
+export class ArticlesService extends BaseService<ArticlesModel, ArticlesRepository> {
+    constructor(repo: ArticlesRepository, @inject("Logger") logger?: Log) {
+        super(repo, logger);
+    }
+    /**
+     * @param searchParams
+     * @param offset
+     * @param limit
+     * @param related
+     * @param filters
+     */
+    public search(searchParams: any, offset?: number, limit?: number, related = [], filters = []): Promise<CollectionWrap<ArticlesModel>> {
+        return this.repo.search(searchParams, offset, limit, related, filters);
+    }
+
+    /**
+     * @param data
+     * @param related
+     * @param filters
+     */
+    public create(data: ArticlesModel, related = [], filters = []): Promise<ArticlesModel> {
+        let conditions: any = {};
+        conditions[Schema.ARTICLES_TABLE_SCHEMA.FIELDS.TITLE] = data.name;
+
+        return this.repo.findOneByAtribute({ conditions: conditions })
+            .then(object => {
+                if (object != null) {
+                    return Promise.reject(new ExceptionModel(
+                        ErrorCode.RESOURCE.DUPLICATE_RESOURCE.CODE,
+                        ErrorCode.RESOURCE.DUPLICATE_RESOURCE.MESSAGE,
+                        false,
+                        HttpStatus.NOT_FOUND,
+                    ));
+                }
+                return this.insert(data);
+            });
+    }
+}
+
+export default ArticlesService;

src/interactors/assign_presentation.service.ts

+/**
+ * Created by phuongho on 05/10/17.
+ */
+import * as Promise from "bluebird";
+import * as Schema from "../data/sql/schema";
+import { BaseService, Log } from "./base.service";
+import { CollectionWrap, ExceptionModel, AssignPresentationModel } from "../models";
+import { DELETE_STATUS } from "../libs/constants";
+import { ErrorCode, HttpStatus, Logger } from "../libs";
+import { PresentationRepository, UserPresentationRepository, AssignPresentationRepository } from "./../data";
+import { UserPresentationModel } from "./../models";
+import { injectable, inject } from "inversify";
+
+@injectable()
+export class AssignPresentationService extends BaseService<AssignPresentationModel, AssignPresentationRepository> {
+    constructor(private userPresent: UserPresentationRepository,
+        private present: PresentationRepository,
+        repo: AssignPresentationRepository,
+        @inject("Logger") logger?: Log) {
+        super(repo, logger);
+    }
+
+    /**
+     * Invoke default repository
+     * @param data
+     * @param related
+     * @param filters
+     */
+    public create<T>(data: AssignPresentationModel, related: string[] = [], filters: string[] = []): Promise<AssignPresentationModel> {
+        return this.present.findById(data.presentationId)
+            .then(object => {
+                if (object === null) {
+                    return Promise.reject(new ExceptionModel(
+                        ErrorCode.RESOURCE.NOT_FOUND.CODE,
+                        ErrorCode.RESOURCE.NOT_FOUND.MESSAGE,
+                        false,
+                        HttpStatus.NOT_FOUND,
+                    ));
+                }
+                return this.repo.deleteByQuery(q => {
+                    q.where(Schema.ASSIGN_PRESENTATION_TABLE_SCHEMA.FIELDS.PRESENTATION_ID, data.presentationId);
+                });
+            })
+            .then(() => {
+                return this.insert(data);
+            })
+            .tap(() => {
+                return this.userPresent.deleteByQuery(q => {
+                    q.where(Schema.USER_PRESENTATION_TABLE_SCHEMA.FIELDS.PRESENTATION_ID, data.presentationId);
+                });
+            })
+            .tap((object) => {
+                if (data.users) {
+                    data.users.forEach(userId => {
+                        let model = new UserPresentationModel();
+                        model.userId = userId;
+                        model.presentationId = data.presentationId;
+                        this.userPresent.insert(model);
+                    });
+                }
+            });
+    }
+    /**
+     *
+     * @param presentationId
+     * @param related
+     * @param filters
+     */
+    public detailByPresentaionId(presentationId: string, related: string[] = [], filters: string[] = []): Promise<AssignPresentationModel> {
+        return this.repo.findOneByQuery(q => {
+            q.where(Schema.ASSIGN_PRESENTATION_TABLE_SCHEMA.FIELDS.PRESENTATION_ID, presentationId);
+        }, related, filters);
+    }
+}
+
+export default AssignPresentationService;

src/interactors/base.service.ts

+/**
+ * Created by phuongho on 15/08/17.
+ */
+import * as Promise from "bluebird";
+import * as _ from "lodash";
+import { BaseModel, CollectionWrap, ExceptionModel } from "../models";
+import { BaseRepository } from "../data";
+import { ErrorCode, HttpStatus } from "../libs";
+import { QueryBuilder } from "knex";
+import { WithRelatedQuery } from "bookshelf";
+import { injectable, unmanaged } from "inversify";
+
+export interface Log {
+    error(message: string, meta?: any): void;
+    warn(message: string, meta?: any): void;
+    info(message: string, meta?: any): void;
+    debug(message: string, meta?: any): void;
+}
+@injectable()
+export class BaseService<M extends BaseModel, R extends BaseRepository<any, M>> {
+    constructor( @unmanaged() protected repo?: R, @unmanaged() protected logger?: Log) {
+        this.logger = logger || {
+            error: (message: string, meta?: any): void => { },
+            warn: (message: string, meta?: any): void => { },
+            info: (message: string, meta?: any): void => { },
+            debug: (message: string, meta?: any): void => { },
+        };
+
+        this.repo = repo || {} as R;
+    }
+
+    /**
+     *
+     * @param model
+     * @param related
+     * @param filters
+     */
+    public update(model: M, related = [], filters = []): Promise<any> {
+        return this.detailById(model.id)
+            .then(object => {
+                if (!object || object.isDeleted) {
+                    throw new ExceptionModel(
+                        ErrorCode.RESOURCE.NOT_FOUND.CODE,
+                        ErrorCode.RESOURCE.NOT_FOUND.MESSAGE,
+                        false,
+                        HttpStatus.BAD_REQUEST,
+                    );
+                }
+                return this.repo.update(model);
+            });
+    }
+
+    /**
+     *
+     * @param model
+     */
+    public insert(model: M): Promise<any> {
+        return this.repo.insert(model);
+    }
+
+    /**
+     * @param model
+     * @param related
+     * @param filters
+     */
+    public insertGet(model: M, related: string[] = [], filters: string[] = []): Promise<M> {
+        return this.repo.insertGet(model, related, filters);
+    }
+
+    /**
+     * @param id
+     */
+    public forceDelete(id: string): Promise<boolean> {
+        return this.repo.forceDelete(id);
+    }
+
+    /**
+     *
+     * @param id
+     */
+    public deleteLogic(id: string): Promise<M> {
+        return this.repo.deleteLogic(id);
+    }
+
+    /**
+     * @param id
+     */
+    public removeById(id: string): Promise<any> {
+        return this.detailById(id)
+            .then((object) => {
+                return this.deleteLogic(object.id);
+            })
+            .then(object => {
+                if (object) {
+                    return true;
+                }
+                return false;
+            });
+    }
+    /**
+    * @param id
+    * @param related
+    * @param filters
+    */
+    public detailById(id: string, related = [], filters = []): Promise<M> {
+        return this.findById(id, related, filters)
+            .then(object => {
+                if (object === null || object.isDeleted === true) {
+                    return Promise.reject(new ExceptionModel(
+                        ErrorCode.RESOURCE.NOT_FOUND.CODE,
+                        ErrorCode.RESOURCE.NOT_FOUND.MESSAGE,
+                        false,
+                        HttpStatus.NOT_FOUND,
+                    ));
+                }
+                return object;
+            });
+    }
+
+    /**
+     *
+     * @param id
+     * @param related
+     * @param filters
+     */
+    public findOne(id: string, related: (string | WithRelatedQuery)[] = [], filters: string[] = []): Promise<M> {
+        return this.findById(id, related, filters);
+    }
+
+    /**
+     *
+     * @param id
+     * @param related
+     * @param filters
+     */
+    public findById(id: string, related: (string | WithRelatedQuery)[] = [], filters: string[] = []): Promise<M> {
+        return this.repo.findById(id, related, filters);
+    }
+
+
+
+    /**
+     *
+     * @param model
+     * @param related
+     * @param filters
+     */
+    public make(model: M, related: (string | WithRelatedQuery)[] = [], filters: string[] = []): Promise<M> {
+        return Promise.resolve()
+            .then(() => {
+                return this.repo.insert(model);
+            })
+            .then((object) => {
+                return this.findOne(object.id, [], filters);
+            });
+    }
+
+    /**
+     *
+     * @param id
+     * @param related
+     * @param filters
+     */
+    public delete(id: string, related: (string | WithRelatedQuery)[] = [], filters: string[] = []): Promise<string> {
+        return this.repo.deleteLogic(id)
+            .then(() => {
+                return id;
+            });
+    }
+}
+
+export default BaseService;

src/interactors/cache.service.ts

+import Redis from "../data/redis/redis";
+import { BaseService, Log } from "./base.service";
+import { injectable, inject } from "inversify";
+@injectable()
+export class CacheService extends BaseService<any, any> {
+
+    constructor(@inject("Logger") log?: Log) {
+        super(null, log);
+    }
+
+    /**
+     * Create a unique key in redis
+     * @param params array of string
+     */
+    private createKey(...params: string[]): string {
+        return params.filter(val => val != null && val !== "").join(":");
+    }
+
+    public get(key: string): any {
+        return Redis.getClient().getAsync(key);
+    }
+
+    public set(key: string, val: any, expire?: number): any {
+        if (expire != null) {
+            return Redis.getClient().setAsync(key, val, "EX", expire);
+        }
+        return Redis.getClient().setAsync(key, val);
+    }
+}
+
+export default CacheService;

src/interactors/category.service.ts

+/**
+ * Created by Anh Nga on 13/10/2017
+ */
+import * as Promise from "bluebird";
+import * as Schema from "../data/sql/schema";
+import { BaseService, Log } from "./base.service";
+import { CollectionWrap, ExceptionModel, CategoryModel } from "../models";
+import { DELETE_STATUS } from "../libs/constants";
+import { ErrorCode, HttpStatus, logger as Logger } from "../libs";
+import { CategoryRepository } from "../data";
+import { injectable, inject } from "inversify";
+
+@injectable()
+export class CategoryService extends BaseService<CategoryModel, CategoryRepository> {
+    constructor(repo: CategoryRepository, @inject("Logger") logger?: Log) {
+        super(repo, logger);
+    }
+    /**
+     * @param searchParams
+     * @param offset
+     * @param limit
+     * @param related
+     * @param filters
+     */
+    public search(searchParams: any, offset?: number, limit?: number, related = [], filters = []): Promise<CollectionWrap<CategoryModel>> {
+        return this.repo.search(searchParams, offset, limit, related, filters);
+    }
+
+    /**
+     * @param data
+     * @param related
+     * @param filters
+     */
+    public create(data: CategoryModel, related = [], filters = []): Promise<CategoryModel> {
+        let conditions: any = {};
+        conditions[Schema.CATEGORY_TABLE_SCHEMA.FIELDS.NAME] = data.name;
+
+        return this.repo.findOneByAtribute({ conditions: conditions })
+            .then(object => {
+                if (object != null) {
+                    return Promise.reject(new ExceptionModel(
+                        ErrorCode.RESOURCE.DUPLICATE_RESOURCE.CODE,
+                        ErrorCode.RESOURCE.DUPLICATE_RESOURCE.MESSAGE,
+                        false,
+                        HttpStatus.NOT_FOUND,
+                    ));
+                }
+                return this.insert(data);
+            });
+    }
+}
+
+export default CategoryService;

src/interactors/template.service.ts

+import { BaseService, Log } from "./base.service";
+import { Utils } from "../libs";
+import { injectable , inject} from "inversify";
+
+@injectable()
+export class TemplateService extends BaseService<any, any> {
+    constructor(@inject("Logger") log?: Log) {
+        super(null, log);
+    }
+}
+
+export default TemplateService;