WIP Advanced filter.

server/src/data/ResourceFieldsKeys.js

@@ -1,6 +1,36 @@
+/* eslint-disable quote-props */
 
 export default {
-  "expense_account": 'expense_account_id',
-  "payment_account": 'payment_account_id',
-  "account_type": "account_type_id"
-}
+  // Expenses.
+  'expenses': {
+    'expense_account': {
+      column: ' ',
+      relation: 'accounts.name',
+    },
+    'payment_account': {
+      column: 'payment_account_id',
+      relation: 'accounts.id',
+    },
+    'account_type': {
+      column: 'account_type_id',
+      relation: 'account_types.id',
+    },
+  },
+
+  // Accounts
+  'accounts': {
+    'name': {
+      column: 'name',
+    },
+    'type': {
+      column: 'account_type_id',
+      relation: 'account_types.id',
+    },
+    'description': {
+      column: 'description',
+    },
+    'code': {
+      column: 'code',
+    },
+  },
+};

server/src/http/controllers/Accounts.js

@@ -14,6 +14,7 @@ import {
   mapViewRolesToConditionals,
   validateViewRoles,
 } from '@/lib/ViewRolesBuilder';
+import FilterRoles from '@/lib/FilterRoles';
 
 export default {
   /**
@@ -215,11 +216,7 @@ export default {
       query('account_types.*').optional().isNumeric().toInt(),
       query('custom_view_id').optional().isNumeric().toInt(),
 
-      query('roles').optional().isArray({ min: 1 }),
-      query('roles.*.field_key').exists().escape().trim(),
-      query('roles.*.comparator').exists(),
-      query('roles.*.value').exists(),
-      query('roles.*.index').exists().isNumeric().toInt(),
+      query('stringified_filter_roles').optional().isJSON(),
     ],
     async handler(req, res) {
       const validationErrors = validationResult(req);
@@ -233,11 +230,17 @@ export default {
       const filter = {
         account_types: [],
         display_type: 'tree',
+        filter_roles: [],
         ...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').first();
+
+      const accountsResource = await Resource.query()
+        .where('name', 'accounts').withGraphFetched('fields').first();
 
       if (!accountsResource) {
         return res.status(400).send({
@@ -264,6 +267,15 @@ export default {
           errorReasons.push({ type: 'VIEW.LOGIC.EXPRESSION.INVALID', code: 400 });
         }
       }
+
+      // Validate the accounts resource fields.
+      const filterRoles = new FilterRoles(Account.tableName,
+        filter.filter_roles.map((role) => ({ ...role, columnKey: role.fieldKey })),
+        accountsResource.fields);
+
+      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 });
       }
@@ -271,9 +283,15 @@ export default {
         builder.modify('filterAccountTypes', filter.account_types);
         builder.withGraphFetched('type');
 
-        if (viewConditionals.length) {
+        // 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);
+        }
       });
 
       const nestedAccounts = new NestedSet(accounts, { parentId: 'parentAccountId' });

server/src/lib/FilterRoles/index.js

@@ -0,0 +1,46 @@
+import { difference } from 'lodash';
+import {
+  buildFilterQuery,
+} from '../ViewRolesBuilder';
+
+export default class FilterRoles {
+  /**
+   * Constructor method.
+   * @param {Array} filterRoles -
+   * @param {Array} resourceFields -
+   */
+  constructor(tableName, filterRoles, resourceFields) {
+    this.filterRoles = filterRoles.map((role, index) => ({
+      ...role,
+      index: index + 1,
+      columnKey: role.field_key,
+    }));
+    this.resourceFields = resourceFields;
+    this.tableName = tableName;
+  }
+
+  validateFilterRoles() {
+    const filterFieldsKeys = this.filterRoles.map((r) => r.field_key);
+    const resourceFieldsKeys = this.resourceFields.map((r) => r.key);
+
+    return difference(filterFieldsKeys, resourceFieldsKeys);
+  }
+
+  // @private
+  buildLogicExpression() {
+    let expression = '';
+    this.filterRoles.forEach((role, index) => {
+      expression += (index === 0)
+        ? `${role.index} ` : `${role.condition} ${role.index} `;
+    });
+    return expression.trim();
+  }
+
+  // @public
+  buildQuery() {
+    const logicExpression = this.buildLogicExpression();
+    return (builder) => {
+      buildFilterQuery(this.tableName, this.filterRoles, logicExpression)(builder);
+    };
+  }
+}

server/src/lib/ViewRolesBuilder/index.js

@@ -5,41 +5,90 @@ import QueryParser from '@/lib/LogicEvaluation/QueryParser';
 import resourceFieldsKeys from '@/data/ResourceFieldsKeys';
 
 //  const role = {
-//   compatotor: '',
-//   value: '',
-//   columnKey: '',
-//   columnSlug: '',
-//   index: 1,
+//   compatotor: String,
+//   value: String,
+//   columnKey: String,
+//   columnSlug: String,
+//   index: Number,
 // }
 
-export function buildRoleQuery(role) {
-  const columnName = resourceFieldsKeys[role.columnKey];
+/**
+ * Get field column metadata and its relation with other tables.
+ * @param {String} tableName - Table name of target column.
+ * @param {String} columnKey - Target column key that stored in resource field.
+ */
+export function getRoleFieldColumn(tableName, columnKey) {
+  const tableFields = resourceFieldsKeys[tableName];
+  return (tableFields[columnKey]) ? tableFields[columnKey] : null;
+}
 
+/**
+ * Builds roles queries.
+ * @param {String} tableName -
+ * @param {Object} role -
+ */
+export function buildRoleQuery(tableName, role) {
+  const fieldRelation = getRoleFieldColumn(tableName, role.columnKey);
+  const comparatorColumn = fieldRelation.relation || `${tableName}.${fieldRelation.column}`;
+
+  console.log(comparatorColumn, role.value);
   switch (role.comparator) {
     case 'equals':
     default:
       return (builder) => {
-        builder.where(columnName, role.value);
+        builder.where(comparatorColumn, role.value);
       };
     case 'not_equal':
     case 'not_equals':
       return (builder) => {
-        builder.whereNot(columnName, role.value);
+        builder.whereNot(comparatorColumn, role.value);
+      };
+    case 'contain':
+      return (builder) => {
+        builder.where(comparatorColumn, 'LIKE', `%${role.value}%`);
       };
   }
 }
 
+/**
+ * Extract relation table name from relation.
+ * @param {String} column -
+ * @return {String} - join relation table.
+ */
+export const getTableFromRelationColumn = (column) => {
+  const splitedColumn = column.split('.');
+  return (splitedColumn.length > 0) ? splitedColumn[0] : '';
+};
+
+/**
+ * Builds view roles join queries.
+ * @param {String} tableName -
+ * @param {Array} roles -
+ */
+export function buildFilterRolesJoins(tableName, roles) {
+  return (builder) => {
+    roles.forEach((role) => {
+      const fieldColumn = getRoleFieldColumn(tableName, role.columnKey);
+
+      if (fieldColumn.relation) {
+        const joinTable = getTableFromRelationColumn(fieldColumn.relation);
+        builder.join(joinTable, `${tableName}.${fieldColumn.column}`, '=', fieldColumn.relation);
+      }
+    });
+  };
+}
+
 /**
  * Builds database query from stored view roles.
  *
  * @param {Array} roles -
  * @return {Function}
  */
-export function viewRolesBuilder(roles, logicExpression = '') {
+export function buildFilterRolesQuery(tableName, roles, logicExpression = '') {
   const rolesIndexSet = {};
 
   roles.forEach((role) => {
-    rolesIndexSet[role.index] = buildRoleQuery(role);
+    rolesIndexSet[role.index] = buildRoleQuery(tableName, role);
   });
   // Lexer for logic expression.
   const lexer = new Lexer(logicExpression);
@@ -54,23 +103,36 @@ export function viewRolesBuilder(roles, logicExpression = '') {
 }
 
 /**
- * Validates the view logic expression.
- * @param {String} logicExpression 
- * @param {Array} indexes 
+ * Builds filter query for query builder.
+ * @param {String} tableName -
+ * @param {Array} roles -
+ * @param {String} logicExpression -
  */
-export function validateViewLogicExpression(logicExpression, indexes) {
+export const buildFilterQuery = (tableName, roles, logicExpression) => {
+  return (builder) => {
+    buildFilterRolesJoins(tableName, roles)(builder);
+    buildFilterRolesQuery(tableName, roles, logicExpression)(builder);
+  };
+};
+
+/**
+ * Validates the view logic expression.
+ * @param {String} logicExpression -
+ * @param {Array} indexes -
+ */
+export function validateFilterLogicExpression(logicExpression, indexes) {
   const logicExpIndexes = logicExpression.match(/\d+/g) || [];
   return !difference(logicExpIndexes.map(Number), indexes).length;
 }
 
 /**
- * 
+ * Validates view roles.
  * @param {Array} roles -
  * @param {String} logicExpression -
  * @return {Boolean}
  */
 export function validateViewRoles(roles, logicExpression) {
-  return validateViewLogicExpression(logicExpression, roles.map((r) => r.index));
+  return validateFilterLogicExpression(logicExpression, roles.map((r) => r.index));
 }
 
 /**
@@ -82,7 +144,7 @@ export function mapViewRolesToConditionals(viewRoles) {
   return viewRoles.map((viewRole) => ({
     comparator: viewRole.comparator,
     value: viewRole.value,
-    columnKey: viewRole.field.columnKey,
+    columnKey: viewRole.field.key,
     slug: viewRole.field.slug,
     index: viewRole.index,
   }));

server/src/models/Account.js

@@ -2,8 +2,9 @@
 import { Model } from 'objection';
 import { flatten } from 'lodash';
 import BaseModel from '@/models/Model';
-import {viewRolesBuilder} from '@/lib/ViewRolesBuilder';
-
+import {
+  buildFilterQuery,
+} from '@/lib/ViewRolesBuilder';
 export default class Account extends BaseModel {
   /**
    * Table name
@@ -16,19 +17,21 @@ export default class Account extends BaseModel {
    * Model modifiers.
    */
   static get modifiers() {
+    const TABLE_NAME = Account.tableName;
+
     return {
       filterAccounts(query, accountIds) {
         if (accountIds.length > 0) {
-          query.whereIn('id', accountIds);
+          query.whereIn(`${TABLE_NAME}.id`, accountIds);
         }
       },
       filterAccountTypes(query, typesIds) {
         if (typesIds.length > 0) {
-          query.whereIn('accoun_type_id', typesIds);
+          query.whereIn('account_types.accoun_type_id', typesIds);
         }
       },
       viewRolesBuilder(query, conditionals, expression) {
-        viewRolesBuilder(conditionals, expression)(query);
+        buildFilterQuery(Account.tableName, conditionals, expression)(query);
       },
     };
   }