feat: Sorting by dynamic query.

server/src/collection/NestedSet/index.js

@@ -37,12 +37,12 @@ export default class NestedSet {
 
   toTree() {
     const map = this.linkChildren();
-    const tree = {};
+    const tree = [];
 
     this.items.forEach((item) => {
       const parentNodeId = item[this.options.parentId];
       if (!parentNodeId) {
-        tree[item.id] = map[item.id];
+        tree.push(map[item.id]);
       }
     });
     this.collection = Object.values(tree);

server/src/data/ResourceFieldsKeys.js

@@ -25,6 +25,7 @@ export default {
     'type': {
       column: 'account_type_id',
       relation: 'account_types.id',
+      relationColumn: 'account_types.name',
     },
     'description': {
       column: 'description',

server/src/http/controllers/Accounts.js

@@ -1,20 +1,32 @@
 import express from 'express';
-import { check, validationResult, param, query } from 'express-validator';
+import {
+  check,
+  validationResult,
+  param,
+  query,
+} from 'express-validator';
+import { difference } from 'lodash';
 import asyncMiddleware from '@/http/middleware/asyncMiddleware';
 import Account from '@/models/Account';
 import AccountType from '@/models/AccountType';
 import AccountTransaction from '@/models/AccountTransaction';
 import JournalPoster from '@/services/Accounting/JournalPoster';
 import AccountBalance from '@/models/AccountBalance';
+import NestedSet from '@/collection/NestedSet';
 import Resource from '@/models/Resource';
 import View from '@/models/View';
 import JWTAuth from '@/http/middleware/jwtAuth';
-import NestedSet from '../../collection/NestedSet';
 import {
   mapViewRolesToConditionals,
-  validateViewRoles,
+  mapFilterRolesToDynamicFilter,
 } from '@/lib/ViewRolesBuilder';
-import FilterRoles from '@/lib/FilterRoles';
+import {
+  DynamicFilter,
+  DynamicFilterSortBy,
+  DynamicFilterViews,
+  DynamicFilterFilterRoles,
+} from '@/lib/DynamicFilter';
+
 
 export default {
   /**
@@ -40,6 +52,10 @@ export default {
       this.getAccountsList.validation,
       asyncMiddleware(this.getAccountsList.handler));
 
+    router.delete('/',
+      this.deleteBulkAccounts.validation,
+      asyncMiddleware(this.deleteBulkAccounts.handler));
+
     router.delete('/:id',
       this.deleteAccount.validation,
       asyncMiddleware(this.deleteAccount.handler));
@@ -69,7 +85,7 @@ export default {
   newAccount: {
     validation: [
       check('name').exists().isLength({ min: 3 }).trim().escape(),
-      check('code').exists().isLength({ max: 10 }).trim().escape(),
+      check('code').optional().isLength({ max: 10 }).trim().escape(),
       check('account_type_id').exists().isNumeric().toInt(),
       check('description').optional().trim().escape(),
     ],
@@ -217,6 +233,9 @@ export default {
       query('custom_view_id').optional().isNumeric().toInt(),
 
       query('stringified_filter_roles').optional().isJSON(),
+
+      query('column_sort_order').optional(),
+      query('sort_order').optional().isIn(['desc', 'asc']),
     ],
     async handler(req, res) {
       const validationErrors = validationResult(req);
@@ -226,55 +245,77 @@ export default {
           code: 'validation_error', ...validationErrors,
         });
       }
-
       const filter = {
         account_types: [],
         display_type: 'tree',
         filter_roles: [],
+        sort_order: 'asc',
         ...req.query,
       };
       if (filter.stringified_filter_roles) {
         filter.filter_roles = JSON.parse(filter.stringified_filter_roles);
       }
       const errorReasons = [];
-      const viewConditionals = [];
 
       const accountsResource = await Resource.query()
-        .where('name', 'accounts').withGraphFetched('fields').first();
+        .where('name', 'accounts')
+        .withGraphFetched('fields')
+        .first();
 
       if (!accountsResource) {
         return res.status(400).send({
           errors: [{ type: 'ACCOUNTS_RESOURCE_NOT_FOUND', code: 200 }],
         });
       }
+      const resourceFieldsKeys = accountsResource.fields.map((c) => c.key);
+
       const view = await View.query().onBuild((builder) => {
         if (filter.custom_view_id) {
           builder.where('id', filter.custom_view_id);
         } else {
           builder.where('favourite', true);
         }
-        builder.where('resource_id', accountsResource.id);
+        // builder.where('resource_id', accountsResource.id);
         builder.withGraphFetched('roles.field');
         builder.withGraphFetched('columns');
         builder.first();
       });
+      const dynamicFilter = new DynamicFilter(Account.tableName);
 
-      if (view && view.roles.length > 0) {
-        viewConditionals.push(
-          ...mapViewRolesToConditionals(view.roles),
-        );
-        if (!validateViewRoles(viewConditionals, view.rolesLogicExpression)) {
-          errorReasons.push({ type: 'VIEW.LOGIC.EXPRESSION.INVALID', code: 400 });
+      if (filter.column_sort_order) {
+        if (resourceFieldsKeys.indexOf(filter.column_sort_order) === -1) {
+          errorReasons.push({ type: 'COLUMN.SORT.ORDER.NOT.FOUND', code: 300 });
         }
+        const sortByFilter = new DynamicFilterSortBy(
+          filter.column_sort_order,
+          filter.sort_order,
+        );
+        dynamicFilter.setFilter(sortByFilter);
       }
 
-      // Validate the accounts resource fields.
-      const filterRoles = new FilterRoles(Account.tableName,
-        filter.filter_roles.map((role) => ({ ...role, columnKey: role.fieldKey })),
-        accountsResource.fields);
+      // View roles.
+      if (view && view.roles.length > 0) { 
+        const viewFilter = new DynamicFilterViews(
+          mapViewRolesToConditionals(view.roles),
+          view.rolesLogicExpression,
+        );
+        if (!viewFilter.validateFilterRoles()) {
+          errorReasons.push({ type: 'VIEW.LOGIC.EXPRESSION.INVALID', code: 400 });
+        }
+        dynamicFilter.setFilter(viewFilter);
+      }
+      // Filter roles.
+      if (filter.filter_roles.length > 0) {
+        // Validate the accounts resource fields.
+        const filterRoles = new DynamicFilterFilterRoles(
+          mapFilterRolesToDynamicFilter(filter.filter_roles),
+          accountsResource.fields,
+        );
+        dynamicFilter.setFilter(filterRoles);
 
-      if (filterRoles.validateFilterRoles().length > 0) {
-        errorReasons.push({ type: 'ACCOUNTS.RESOURCE.HAS.NO.GIVEN.FIELDS', code: 500 });
+        if (filterRoles.validateFilterRoles().length > 0) {
+          errorReasons.push({ type: 'ACCOUNTS.RESOURCE.HAS.NO.GIVEN.FIELDS', code: 500 });
+        }
       }
       if (errorReasons.length > 0) {
         return res.status(400).send({ errors: errorReasons });
@@ -284,33 +325,14 @@ export default {
         builder.withGraphFetched('type');
         builder.withGraphFetched('balance');
 
-        // Build custom view conditions query.
-        if (viewConditionals.length > 0) {
-          builder.modify('viewRolesBuilder', viewConditionals, view.rolesLogicExpression);
-        }
-        // Build filter query.
-        if (filter.filter_roles.length > 0) {
-          filterRoles.buildQuery()(builder);
-        }
+        dynamicFilter.buildQuery()(builder);
       });
 
       const nestedAccounts = new NestedSet(accounts, { parentId: 'parentAccountId' });
-      const groupsAccounts = nestedAccounts.toTree();
-      const accountsList = [];
+      const nestedSetAccounts = nestedAccounts.toTree();
 
-      if (filter.display_type === 'tree') {
-        accountsList.push(...groupsAccounts);
-      } else if (filter.display_type === 'flat') {
-        const flattenAccounts = nestedAccounts.flattenTree((account, parentAccount) => {
-          if (parentAccount) {
-            account.name = `${parentAccount.name} ― ${account.name}`;
-          }
-          return account;
-        });
-        accountsList.push(...flattenAccounts);
-      }
       return res.status(200).send({
-        accounts: accountsList,
+        accounts: nestedSetAccounts,
         ...(view) ? {
           customViewId: view.id,
         } : {},
@@ -424,4 +446,57 @@ export default {
       // return res.status(200).send();
     },
   },
+
+  deleteBulkAccounts: {
+    validation: [
+      query('ids').isArray(),
+      query('ids.*').isNumeric().toInt(),
+    ],
+    async handler(req, res) {
+      const validationErrors = validationResult(req);
+
+      if (!validationErrors.isEmpty()) {
+        return res.boom.badData(null, {
+          code: 'validation_error', ...validationErrors,
+        });
+      }
+      const filter = { ids: [], ...req.query };
+      const accounts = await Account.query().onBuild((builder) => {
+        if (filter.ids.length) {
+          builder.whereIn('id', filter.ids);
+        }
+      });
+      const accountsIds = accounts.map(a => a.id);
+      const notFoundAccounts = difference(filter.ids, accountsIds);
+
+      if (notFoundAccounts.length > 0) {
+        return res.status(404).send({
+          errors: [{ type: 'ACCOUNTS.IDS.NOT.FOUND', code: 200, ids: notFoundAccounts }],
+        });
+      }
+      const accountsTransactions = await AccountTransaction.query()
+        .whereIn('account_id', accountsIds)
+        .count('id as transactions_count')
+        .groupBy('account_id')
+        .select('account_id');
+
+      const accountsHasTransactions = [];
+
+      accountsTransactions.forEach((transaction) => {
+        if (transaction.transactionsCount > 0) {
+          accountsHasTransactions.push(transaction.accountId);
+        }
+      });
+      if (accountsHasTransactions.length > 0) {
+        return res.status(400).send({
+          errors: [{ type: 'ACCOUNTS.HAS.TRANSACTIONS', code: 300, ids: accountsHasTransactions }],
+        });
+      }
+      await Account.query()
+        .whereIn('id', accounts.map((a) => a.id))
+        .delete();
+
+      return res.status(200).send();
+    },
+  },
 };

server/src/http/controllers/Views.js

@@ -209,7 +209,7 @@ export default {
 
       form.roles.forEach((role) => {
         const fieldModel = resourceFieldsKeysMap.get(role.field_key);
-        
+
         const saveViewRoleOper = ViewRole.query().insert({
           ...pick(role, ['comparator', 'value', 'index']),
           field_id: fieldModel.id,
@@ -245,7 +245,7 @@ export default {
 
       check('columns').exists().isArray({ min: 1 }),
 
-      check('columns.*.id').optional().isNumeric().toInt(),    
+      check('columns.*.id').optional().isNumeric().toInt(),
       check('columns.*.key').exists().escape().trim(),
       check('columns.*.index').exists().isNumeric().toInt(),
 

server/src/lib/DynamicFilter/DynamicFilter.js

@@ -0,0 +1,44 @@
+import { uniqBy } from 'lodash';
+import {
+  buildFilterRolesJoins,
+} from '@/lib/ViewRolesBuilder';
+
+export default class DynamicFilter {
+  /**
+   * Constructor.
+   * @param {String} tableName -
+   */
+  constructor(tableName) {
+    this.tableName = tableName;
+    this.filters = [];
+  }
+
+  /**
+   * Set filter.
+   * @param {*} filterRole -
+   */
+  setFilter(filterRole) {
+    filterRole.setTableName(this.tableName);
+    this.filters.push(filterRole);
+  }
+
+  /**
+   * Builds queries of filter roles.
+   */
+  buildQuery() {
+    const buildersCallbacks = [];
+    const tableColumns = [];
+
+    this.filters.forEach((filter) => {
+      const { filterRoles } = filter;
+      buildersCallbacks.push(filter.buildQuery());
+      tableColumns.push(...(Array.isArray(filterRoles)) ? filterRoles : [filterRoles]);
+    });
+    return (builder) => {
+      buildersCallbacks.forEach((builderCallback) => {
+        builderCallback(builder);
+      });
+      buildFilterRolesJoins(this.tableName, uniqBy(tableColumns, 'columnKey'))(builder);
+    };
+  }
+}

server/src/lib/DynamicFilter/DynamicFilterFilterRoles.js

@@ -1,22 +1,25 @@
 import { difference } from 'lodash';
+import DynamicFilterRoleAbstructor from '@/lib/DynamicFilter/DynamicFilterRoleAbstructor';
 import {
   buildFilterQuery,
-} from '../ViewRolesBuilder';
+} from '@/lib/ViewRolesBuilder';
 
-export default class FilterRoles {
+export default class FilterRoles extends DynamicFilterRoleAbstructor {
   /**
    * Constructor method.
    * @param {Array} filterRoles -
    * @param {Array} resourceFields -
    */
-  constructor(tableName, filterRoles, resourceFields) {
+  constructor(filterRoles, resourceFields) {
+    super();
+
     this.filterRoles = filterRoles.map((role, index) => ({
       ...role,
       index: index + 1,
       columnKey: role.field_key,
+      comparator: role.comparator === 'AND' ? '&&' : '||',
     }));
     this.resourceFields = resourceFields;
-    this.tableName = tableName;
   }
 
   validateFilterRoles() {
@@ -36,10 +39,12 @@ export default class FilterRoles {
     return expression.trim();
   }
 
-  // @public
+  /**
+   * Builds database query of view roles.
+   */
   buildQuery() {
-    const logicExpression = this.buildLogicExpression();
     return (builder) => {
+      const logicExpression = this.buildLogicExpression();
       buildFilterQuery(this.tableName, this.filterRoles, logicExpression)(builder);
     };
   }

server/src/lib/DynamicFilter/DynamicFilterRoleAbstructor.js

@@ -0,0 +1,18 @@
+
+
+export default class DynamicFilterAbstructor {
+  constructor() {
+    this.filterRoles = [];
+    this.tableName = '';
+  }
+
+  setTableName(tableName) {
+    this.tableName = tableName;
+  }
+
+  buildLogicExpression() {}
+
+  validateFilterRoles() {}
+
+  buildQuery() {}
+}

server/src/lib/DynamicFilter/DynamicFilterSortBy.js

@@ -0,0 +1,31 @@
+import DynamicFilterRoleAbstructor from '@/lib/DynamicFilter/DynamicFilterRoleAbstructor';
+import {
+  getRoleFieldColumn,
+} from '@/lib/ViewRolesBuilder';
+
+export default class DynamicFilterSortBy extends DynamicFilterRoleAbstructor {
+
+  constructor(sortByFieldKey, sortDirection) {
+    super();
+
+    this.filterRoles = {
+      columnKey: sortByFieldKey,
+      value: sortDirection,
+      comparator: 'sort_by',
+    };
+  }
+
+  /**
+   * Builds database query of sort by column on the given direction.
+   */
+  buildQuery() { 
+    const { columnKey = null, value = null } = this.filterRoles;
+
+    return (builder) => {
+      const fieldRelation = getRoleFieldColumn(this.tableName, columnKey);
+      if (columnKey) {
+        builder.orderBy(`${this.tableName}.${fieldRelation.column}`, value.toLowerCase());
+      }
+    };
+  }
+}

server/src/lib/DynamicFilter/DynamicFilterViews.js

@@ -0,0 +1,46 @@
+import DynamicFilterRoleAbstructor from '@/lib/DynamicFilter/DynamicFilterRoleAbstructor';
+import {
+  validateViewRoles,
+  buildFilterQuery,
+} from '@/lib/ViewRolesBuilder';
+
+export default class DynamicFilterViews extends DynamicFilterRoleAbstructor {
+  /**
+   * Constructor method.
+   * @param {*} filterRoles -
+   * @param {*} logicExpression -
+   */
+  constructor(filterRoles, logicExpression) {
+    super();
+
+    this.filterRoles = filterRoles;
+    this.logicExpression = logicExpression
+      .replace('AND', '&&')
+      .replace('OR', '||');
+
+    this.tableName = '';
+  }
+
+  /**
+   * Retrieve logic expression.
+   */
+  buildLogicExpression() {
+    return this.logicExpression;
+  }
+
+  /**
+   * Validates filter roles.
+   */
+  validateFilterRoles() {
+    return validateViewRoles(this.filterRoles, this.logicExpression);
+  }
+
+  /**
+   * Builds database query of view roles.
+   */
+  buildQuery() {
+    return (builder) => {
+      buildFilterQuery(this.tableName, this.filterRoles, this.logicExpression)(builder);
+    };
+  }
+}

server/src/lib/DynamicFilter/index.js

@@ -0,0 +1,13 @@
+
+
+import DynamicFilter from './DynamicFilter';
+import DynamicFilterSortBy from './DynamicFilterSortBy';
+import DynamicFilterViews from './DynamicFilterViews';
+import DynamicFilterFilterRoles from './DynamicFilterFilterRoles';
+
+export {
+  DynamicFilter,
+  DynamicFilterSortBy,
+  DynamicFilterViews,
+  DynamicFilterFilterRoles,
+};

server/src/lib/ViewRolesBuilder/FilterRolesDynamicFilter.js

@@ -0,0 +1,44 @@
+import DynamicFilterRoleAbstructor from '@/lib/DynamicFilter/DynamicFilterRoleAbstructor';
+import {
+  validateViewRoles,
+  buildFilterQuery,
+} from '@/lib/ViewRolesBuilder';
+
+export default class ViewRolesDynamicFilter extends DynamicFilterRoleAbstructor {
+  /**
+   * Constructor method.
+   * @param {*} filterRoles 
+   * @param {*} logicExpression 
+   */
+  constructor(filterRoles, logicExpression) {
+    super();
+
+    this.filterRoles = filterRoles;
+    this.logicExpression = logicExpression;
+
+    this.tableName = '';
+  }
+
+  /**
+   * Retrieve logic expression.
+   */
+  buildLogicExpression() {
+    return this.logicExpression;
+  }
+
+  /**
+   * Validates filter roles.
+   */
+  validateFilterRoles() {
+    return validateViewRoles(this.filterRoles, this.logicExpression);
+  }
+
+  /**
+   * Builds database query of view roles.
+   */
+  buildQuery() {
+    return (builder) => {
+      buildFilterQuery(this.tableName, this.filterRoles, this.logicExpression)(builder);
+    };
+  }
+}

server/src/lib/ViewRolesBuilder/index.js

@@ -29,9 +29,8 @@ export function getRoleFieldColumn(tableName, columnKey) {
  */
 export function buildRoleQuery(tableName, role) {
   const fieldRelation = getRoleFieldColumn(tableName, role.columnKey);
-  const comparatorColumn = fieldRelation.relation || `${tableName}.${fieldRelation.column}`;
+  const comparatorColumn = fieldRelation.relationColumn || `${tableName}.${fieldRelation.column}`;
 
-  console.log(comparatorColumn, role.value);
   switch (role.comparator) {
     case 'equals':
     default:
@@ -44,6 +43,7 @@ export function buildRoleQuery(tableName, role) {
         builder.whereNot(comparatorColumn, role.value);
       };
     case 'contain':
+    case 'contains':
       return (builder) => {
         builder.where(comparatorColumn, 'LIKE', `%${role.value}%`);
       };
@@ -78,6 +78,17 @@ export function buildFilterRolesJoins(tableName, roles) {
   };
 }
 
+export function buildSortColumnJoin(tableName, sortColumnKey) {
+  return (builder) => {
+    const fieldColumn = getRoleFieldColumn(tableName, sortColumnKey);
+
+    if (fieldColumn.relation) {
+      const joinTable = getTableFromRelationColumn(fieldColumn.relation);
+      builder.join(joinTable, `${tableName}.${fieldColumn.column}`, '=', fieldColumn.relation);
+    }
+  }
+}
+
 /**
  * Builds database query from stored view roles.
  *
@@ -110,7 +121,6 @@ export function buildFilterRolesQuery(tableName, roles, logicExpression = '') {
  */
 export const buildFilterQuery = (tableName, roles, logicExpression) => {
   return (builder) => {
-    buildFilterRolesJoins(tableName, roles)(builder);
     buildFilterRolesQuery(tableName, roles, logicExpression)(builder);
   };
 };
@@ -148,4 +158,28 @@ export function mapViewRolesToConditionals(viewRoles) {
     slug: viewRole.field.slug,
     index: viewRole.index,
   }));
+}
+
+
+export function mapFilterRolesToDynamicFilter(roles) {
+  return roles.map((role) => ({
+    ...role,
+    columnKey: role.fieldKey,
+  }));
+}
+
+/**
+ * Builds sort column query.
+ * @param {String} tableName -
+ * @param {String} columnKey -
+ * @param {String} sortDirection -
+ */
+export function buildSortColumnQuery(tableName, columnKey, sortDirection) {
+  const fieldRelation = getRoleFieldColumn(tableName, columnKey);
+  const sortColumn = fieldRelation.relation || `${tableName}.${fieldRelation.column}`;
+
+  return (builder) => {
+    builder.orderBy(sortColumn, sortDirection);
+    buildSortColumnJoin(tableName, columnKey)(builder);
+  };
 }

server/src/models/Account.js

@@ -4,6 +4,7 @@ import { flatten } from 'lodash';
 import BaseModel from '@/models/Model';
 import {
   buildFilterQuery,
+  buildSortColumnQuery,
 } from '@/lib/ViewRolesBuilder';
 export default class Account extends BaseModel {
   /**
@@ -33,6 +34,9 @@ export default class Account extends BaseModel {
       viewRolesBuilder(query, conditionals, expression) {
         buildFilterQuery(Account.tableName, conditionals, expression)(query);
       },
+      sortColumnBuilder(query, columnKey, direction) {
+        buildSortColumnQuery(Account.tableName, columnKey, direction)(query);
+      }
     };
   }