feat: remove uncategorized transaction from expenses

feat(webapp): Dialog to choose the bank service provider

.env.example

@@ -63,4 +63,35 @@ GOTENBERG_DOCS_URL=http://server:3000/public/
 EXCHANGE_RATE_SERVICE=open-exchange-rate
 
 # Open Exchange Rate
-OPEN_EXCHANGE_RATE_APP_ID=
+OPEN_EXCHANGE_RATE_APP_ID=
+
+# The Plaid environment to use ('sandbox' or 'development').
+# https://plaid.com/docs/#api-host
+PLAID_ENV=sandbox
+
+# Your Plaid keys, which can be found in the Plaid Dashboard.
+# https://dashboard.plaid.com/account/keys
+PLAID_CLIENT_ID=
+PLAID_SECRET_DEVELOPMENT=
+PLAID_SECRET_SANDBOX=
+
+PLAID_LINK_WEBHOOK=
+
+# (Optional) Redirect URI settings section
+# Only required for OAuth redirect URI testing (not common on desktop):
+# Sandbox Mode:
+# Set the PLAID_SANDBOX_REDIRECT_URI below to 'http://localhost:3001/oauth-link'.
+# The OAuth redirect flow requires an endpoint on the developer's website
+# that the bank website should redirect to. You will also need to configure
+# this redirect URI for your client ID through the Plaid developer dashboard
+# at https://dashboard.plaid.com/team/api.
+# Development mode:
+# When running in development mode, you must use an https:// url.
+# You will need to configure this https:// redirect URI in the Plaid developer dashboard.
+# Instructions to create a self-signed certificate for localhost can be found at
+# https://github.com/plaid/pattern/blob/master/README.md#testing-oauth.
+# If your system is not set up to run localhost with https://, you will be unable to test
+# the OAuth in development and should leave the PLAID_DEVELOPMENT_REDIRECT_URI blank.
+
+PLAID_SANDBOX_REDIRECT_URI=
+PLAID_DEVELOPMENT_REDIRECT_URI=

packages/server/package.json

@@ -91,12 +91,14 @@
     "pluralize": "^8.0.0",
     "pug": "^3.0.2",
     "puppeteer": "^10.2.0",
+    "plaid": "^10.3.0",
     "qim": "0.0.52",
     "ramda": "^0.27.1",
     "rate-limiter-flexible": "^2.1.14",
     "reflect-metadata": "^0.1.13",
     "rtl-detect": "^1.0.4",
     "source-map-loader": "^4.0.1",
+    "socket.io": "^4.7.4",
     "tmp-promise": "^3.0.3",
     "ts-transformer-keys": "^0.4.2",
     "tsyringe": "^4.3.0",

packages/server/resources/views/modules/financial-sheet.pug

@@ -21,4 +21,5 @@ block content
         each row in table.rows
           tr(class=row.classNames)
             each cell in row.cells 
-              td(class='cell--' + cell.key)!= cell.value
+              td(class='cell--' + cell.key)
+                span!= cell.value

packages/server/src/api/controllers/Banking/BankingController.ts

@@ -0,0 +1,18 @@
+import Container, { Inject, Service } from 'typedi';
+import { Router } from 'express';
+import BaseController from '@/api/controllers/BaseController';
+import { PlaidBankingController } from './PlaidBankingController';
+
+@Service()
+export class BankingController extends BaseController {
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.use('/plaid', Container.get(PlaidBankingController).router());
+
+    return router;
+  }
+}

packages/server/src/api/controllers/Banking/PlaidBankingController.ts

@@ -0,0 +1,53 @@
+import { Inject, Service } from 'typedi';
+import { Router, Request, Response } from 'express';
+import BaseController from '@/api/controllers/BaseController';
+import { PlaidApplication } from '@/services/Banking/Plaid/PlaidApplication';
+
+@Service()
+export class PlaidBankingController extends BaseController {
+  @Inject()
+  private plaidApp: PlaidApplication;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.post('/link-token', this.linkToken.bind(this));
+    router.post('/exchange-token', this.exchangeToken.bind(this));
+
+    return router;
+  }
+
+  /**
+   * Retrieves the Plaid link token.
+   * @param {Request} req
+   * @param {response} res
+   * @returns {Response}
+   */
+  private async linkToken(req: Request, res: Response) {
+    const { tenantId } = req;
+
+    const linkToken = await this.plaidApp.getLinkToken(tenantId);
+
+    return res.status(200).send(linkToken);
+  }
+
+  /**
+   * Exchanges the given public token.
+   * @param {Request} req
+   * @param {response} res
+   * @returns {Response}
+   */
+  public async exchangeToken(req: Request, res: Response) {
+    const { tenantId } = req;
+    const { public_token, institution_id } = req.body;
+
+    await this.plaidApp.exchangeToken(tenantId, {
+      institutionId: institution_id,
+      publicToken: public_token,
+    });
+    return res.status(200).send({});
+  }
+}

packages/server/src/api/controllers/Cashflow/CashflowController.ts

@@ -13,9 +13,9 @@ export default class CashflowController {
   router() {
     const router = Router();
 
+    router.use(Container.get(CommandCashflowTransaction).router());
     router.use(Container.get(GetCashflowTransaction).router());
     router.use(Container.get(GetCashflowAccounts).router());
-    router.use(Container.get(CommandCashflowTransaction).router());
     router.use(Container.get(DeleteCashflowTransaction).router());
 
     return router;

packages/server/src/api/controllers/Cashflow/DeleteCashflowTransaction.ts

@@ -3,14 +3,15 @@ import { Router, Request, Response, NextFunction } from 'express';
 import { param } from 'express-validator';
 import BaseController from '../BaseController';
 import { ServiceError } from '@/exceptions';
-import DeleteCashflowTransactionService from '../../../services/Cashflow/DeleteCashflowTransactionService';
 import CheckPolicies from '@/api/middleware/CheckPolicies';
+
 import { AbilitySubject, CashflowAction } from '@/interfaces';
+import { CashflowApplication } from '@/services/Cashflow/CashflowApplication';
 
 @Service()
-export default class DeleteCashflowTransaction extends BaseController {
+export default class DeleteCashflowTransactionController extends BaseController {
   @Inject()
-  deleteCashflowService: DeleteCashflowTransactionService;
+  private cashflowApplication: CashflowApplication;
 
   /**
    * Controller router.
@@ -44,7 +45,7 @@ export default class DeleteCashflowTransaction extends BaseController {
 
     try {
       const { oldCashflowTransaction } =
-        await this.deleteCashflowService.deleteCashflowTransaction(
+        await this.cashflowApplication.deleteTransaction(
           tenantId,
           transactionId
         );

packages/server/src/api/controllers/Cashflow/GetCashflowAccounts.ts

@@ -1,20 +1,16 @@
 import { Service, Inject } from 'typedi';
 import { Router, Request, Response, NextFunction } from 'express';
-import { param, query } from 'express-validator';
-import GetCashflowAccountsService from '@/services/Cashflow/GetCashflowAccountsService';
+import { query } from 'express-validator';
 import BaseController from '../BaseController';
-import GetCashflowTransactionsService from '@/services/Cashflow/GetCashflowTransactionsService';
 import { ServiceError } from '@/exceptions';
 import CheckPolicies from '@/api/middleware/CheckPolicies';
 import { AbilitySubject, CashflowAction } from '@/interfaces';
+import { CashflowApplication } from '@/services/Cashflow/CashflowApplication';
 
 @Service()
 export default class GetCashflowAccounts extends BaseController {
   @Inject()
-  getCashflowAccountsService: GetCashflowAccountsService;
-
-  @Inject()
-  getCashflowTransactionsService: GetCashflowTransactionsService;
+  private cashflowApplication: CashflowApplication;
 
   /**
    * Controller router.
@@ -62,10 +58,7 @@ export default class GetCashflowAccounts extends BaseController {
 
     try {
       const cashflowAccounts =
-        await this.getCashflowAccountsService.getCashflowAccounts(
-          tenantId,
-          filter
-        );
+        await this.cashflowApplication.getCashflowAccounts(tenantId, filter);
 
       return res.status(200).send({
         cashflow_accounts: this.transfromToResponse(cashflowAccounts),

packages/server/src/api/controllers/Cashflow/GetCashflowTransaction.ts

@@ -2,15 +2,15 @@ import { Service, Inject } from 'typedi';
 import { Router, Request, Response, NextFunction } from 'express';
 import { param } from 'express-validator';
 import BaseController from '../BaseController';
-import GetCashflowTransactionsService from '@/services/Cashflow/GetCashflowTransactionsService';
 import { ServiceError } from '@/exceptions';
 import CheckPolicies from '@/api/middleware/CheckPolicies';
 import { AbilitySubject, CashflowAction } from '@/interfaces';
+import { CashflowApplication } from '@/services/Cashflow/CashflowApplication';
 
 @Service()
 export default class GetCashflowAccounts extends BaseController {
   @Inject()
-  getCashflowTransactionsService: GetCashflowTransactionsService;
+  private cashflowApplication: CashflowApplication;
 
   /**
    * Controller router.
@@ -43,11 +43,10 @@ export default class GetCashflowAccounts extends BaseController {
     const { transactionId } = req.params;
 
     try {
-      const cashflowTransaction =
-        await this.getCashflowTransactionsService.getCashflowTransaction(
-          tenantId,
-          transactionId
-        );
+      const cashflowTransaction = await this.cashflowApplication.getTransaction(
+        tenantId,
+        transactionId
+      );
 
       return res.status(200).send({
         cashflow_transaction: this.transfromToResponse(cashflowTransaction),

packages/server/src/api/controllers/Cashflow/NewCashflowTransaction.ts

@@ -1,16 +1,16 @@
 import { Service, Inject } from 'typedi';
-import { check } from 'express-validator';
+import { ValidationChain, check, param, query } from 'express-validator';
 import { Router, Request, Response, NextFunction } from 'express';
 import BaseController from '../BaseController';
 import { ServiceError } from '@/exceptions';
-import NewCashflowTransactionService from '@/services/Cashflow/NewCashflowTransactionService';
 import CheckPolicies from '@/api/middleware/CheckPolicies';
 import { AbilitySubject, CashflowAction } from '@/interfaces';
+import { CashflowApplication } from '@/services/Cashflow/CashflowApplication';
 
 @Service()
 export default class NewCashflowTransactionController extends BaseController {
   @Inject()
-  private newCashflowTranscationService: NewCashflowTransactionService;
+  private cashflowApplication: CashflowApplication;
 
   /**
    * Router constructor.
@@ -18,6 +18,18 @@ export default class NewCashflowTransactionController extends BaseController {
   public router() {
     const router = Router();
 
+    router.get(
+      '/transactions/uncategorized/:id',
+      this.asyncMiddleware(this.getUncategorizedCashflowTransaction),
+      this.catchServiceErrors
+    );
+    router.get(
+      '/transactions/:id/uncategorized',
+      this.getUncategorizedTransactionsValidationSchema,
+      this.validationResult,
+      this.asyncMiddleware(this.getUncategorizedCashflowTransactions),
+      this.catchServiceErrors
+    );
     router.post(
       '/transactions',
       CheckPolicies(CashflowAction.Create, AbilitySubject.Cashflow),
@@ -26,13 +38,72 @@ export default class NewCashflowTransactionController extends BaseController {
       this.asyncMiddleware(this.newCashflowTransaction),
       this.catchServiceErrors
     );
+    router.post(
+      '/transactions/:id/uncategorize',
+      this.revertCategorizedCashflowTransaction,
+      this.catchServiceErrors
+    );
+    router.post(
+      '/transactions/:id/categorize',
+      this.categorizeCashflowTransactionValidationSchema,
+      this.validationResult,
+      this.categorizeCashflowTransaction,
+      this.catchServiceErrors
+    );
+    router.post(
+      '/transaction/:id/categorize/expense',
+      this.categorizeAsExpenseValidationSchema,
+      this.validationResult,
+      this.categorizesCashflowTransactionAsExpense,
+      this.catchServiceErrors
+    );
     return router;
   }
 
+  /**
+   * Getting uncategorized transactions validation schema.
+   * @returns {ValidationChain}
+   */
+  public get getUncategorizedTransactionsValidationSchema() {
+    return [
+      param('id').exists().isNumeric().toInt(),
+      query('page').optional().isNumeric().toInt(),
+      query('page_size').optional().isNumeric().toInt(),
+    ];
+  }
+
+  /**
+   * Categorize as expense validation schema.
+   */
+  public get categorizeAsExpenseValidationSchema() {
+    return [
+      check('expense_account_id').exists(),
+      check('date').isISO8601().exists(),
+      check('reference_no').optional(),
+      check('exchange_rate').optional().isFloat({ gt: 0 }).toFloat(),
+    ];
+  }
+
+  /**
+   * Categorize cashflow tranasction validation schema.
+   */
+  public get categorizeCashflowTransactionValidationSchema() {
+    return [
+      check('date').exists().isISO8601().toDate(),
+      check('credit_account_id').exists().isInt().toInt(),
+      check('transaction_number').optional(),
+      check('transaction_type').exists(),
+      check('reference_no').optional(),
+      check('exchange_rate').optional().isFloat({ gt: 0 }).toFloat(),
+      check('description').optional(),
+      check('branch_id').optional({ nullable: true }).isNumeric().toInt(),
+    ];
+  }
+
   /**
    * New cashflow transaction validation schema.
    */
-  get newTransactionValidationSchema() {
+  public get newTransactionValidationSchema() {
     return [
       check('date').exists().isISO8601().toDate(),
       check('reference_no').optional({ nullable: true }).trim().escape(),
@@ -48,9 +119,7 @@ export default class NewCashflowTransactionController extends BaseController {
       check('credit_account_id').exists().isInt().toInt(),
 
       check('exchange_rate').optional().isFloat({ gt: 0 }).toFloat(),
-
       check('branch_id').optional({ nullable: true }).isNumeric().toInt(),
-
       check('publish').default(false).isBoolean().toBoolean(),
     ];
   }
@@ -70,13 +139,12 @@ export default class NewCashflowTransactionController extends BaseController {
     const ownerContributionDTO = this.matchedBodyData(req);
 
     try {
-      const { cashflowTransaction } =
-        await this.newCashflowTranscationService.newCashflowTransaction(
+      const cashflowTransaction =
+        await this.cashflowApplication.createTransaction(
           tenantId,
           ownerContributionDTO,
           userId
         );
-
       return res.status(200).send({
         id: cashflowTransaction.id,
         message: 'New cashflow transaction has been created successfully.',
@@ -86,11 +154,147 @@ export default class NewCashflowTransactionController extends BaseController {
     }
   };
 
+  /**
+   * Revert the categorized cashflow transaction.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private revertCategorizedCashflowTransaction = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: cashflowTransactionId } = req.params;
+
+    try {
+      const data = await this.cashflowApplication.uncategorizeTransaction(
+        tenantId,
+        cashflowTransactionId
+      );
+      return res.status(200).send({ data });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Categorize the cashflow transaction.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private categorizeCashflowTransaction = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: cashflowTransactionId } = req.params;
+    const cashflowTransaction = this.matchedBodyData(req);
+
+    try {
+      await this.cashflowApplication.categorizeTransaction(
+        tenantId,
+        cashflowTransactionId,
+        cashflowTransaction
+      );
+      return res.status(200).send({
+        message: 'The cashflow transaction has been created successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Categorize the transaction as expense transaction.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  private categorizesCashflowTransactionAsExpense = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: cashflowTransactionId } = req.params;
+    const cashflowTransaction = this.matchedBodyData(req);
+
+    try {
+      await this.cashflowApplication.categorizeAsExpense(
+        tenantId,
+        cashflowTransactionId,
+        cashflowTransaction
+      );
+      return res.status(200).send({
+        message: 'The cashflow transaction has been created successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Retrieves the uncategorized cashflow transactions.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  public getUncategorizedCashflowTransaction = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: transactionId } = req.params;
+
+    try {
+      const data = await this.cashflowApplication.getUncategorizedTransaction(
+        tenantId,
+        transactionId
+      );
+      return res.status(200).send({ data });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  /**
+   * Retrieves the uncategorized cashflow transactions.
+   * @param {Request} req
+   * @param {Response} res
+   * @param {NextFunction} next
+   */
+  public getUncategorizedCashflowTransactions = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ) => {
+    const { tenantId } = req;
+    const { id: accountId } = req.params;
+    const query = this.matchedQueryData(req);
+
+    try {
+      const data = await this.cashflowApplication.getUncategorizedTransactions(
+        tenantId,
+        accountId,
+        query
+      );
+
+      return res.status(200).send(data);
+    } catch (error) {
+      next(error);
+    }
+  };
+
   /**
    * Handle the service errors.
    * @param error
-   * @param req
-   * @param res
+   * @param {Request} req
+   * @param {res
    * @param next
    * @returns
    */
@@ -140,6 +344,16 @@ export default class NewCashflowTransactionController extends BaseController {
           ],
         });
       }
+      if (error.errorType === 'UNCATEGORIZED_TRANSACTION_TYPE_INVALID') {
+        return res.boom.badRequest(null, {
+          errors: [
+            {
+              type: 'UNCATEGORIZED_TRANSACTION_TYPE_INVALID',
+              code: 4100,
+            },
+          ],
+        });
+      }
     }
     next(error);
   }

packages/server/src/api/controllers/Webhooks/Webhooks.ts

@@ -0,0 +1,47 @@
+import { Router } from 'express';
+import { PlaidApplication } from '@/services/Banking/Plaid/PlaidApplication';
+import { Request, Response } from 'express';
+import { Inject, Service } from 'typedi';
+import BaseController from '../BaseController';
+import { PlaidWebhookTenantBootMiddleware } from '@/services/Banking/Plaid/PlaidWebhookTenantBootMiddleware';
+
+@Service()
+export class Webhooks extends BaseController {
+  @Inject()
+  private plaidApp: PlaidApplication;
+
+  /**
+   * Router constructor.
+   */
+  router() {
+    const router = Router();
+
+    router.use(PlaidWebhookTenantBootMiddleware);
+    router.post('/plaid', this.plaidWebhooks.bind(this));
+
+    return router;
+  }
+
+  /**
+   * Listens to Plaid webhooks.
+   * @param {Request} req
+   * @param {Response} res
+   * @returns {Response}
+   */
+  public async plaidWebhooks(req: Request, res: Response) {
+    const { tenantId } = req;
+    const {
+      webhook_type: webhookType,
+      webhook_code: webhookCode,
+      item_id: plaidItemId,
+    } = req.body;
+
+    await this.plaidApp.webhooks(
+      tenantId,
+      plaidItemId,
+      webhookType,
+      webhookCode
+    );
+    return res.status(200).send({ code: 200, message: 'ok' });
+  }
+}

packages/server/src/api/index.ts

@@ -56,6 +56,8 @@ import { ProjectsController } from './controllers/Projects/Projects';
 import { ProjectTasksController } from './controllers/Projects/Tasks';
 import { ProjectTimesController } from './controllers/Projects/Times';
 import { TaxRatesController } from './controllers/TaxRates/TaxRates';
+import { BankingController } from './controllers/Banking/BankingController';
+import { Webhooks } from './controllers/Webhooks/Webhooks';
 
 export default () => {
   const app = Router();
@@ -71,6 +73,7 @@ export default () => {
   app.use('/ping', Container.get(Ping).router());
   app.use('/jobs', Container.get(Jobs).router());
   app.use('/account', Container.get(Account).router());
+  app.use('/webhooks', Container.get(Webhooks).router());
 
   // - Dashboard routes.
   // ---------------------------
@@ -118,6 +121,7 @@ export default () => {
     Container.get(InventoryItemsCostController).router()
   );
   dashboard.use('/cashflow', Container.get(CashflowController).router());
+  dashboard.use('/banking', Container.get(BankingController).router());
   dashboard.use('/roles', Container.get(RolesController).router());
   dashboard.use(
     '/transactions-locking',

packages/server/src/config/index.ts

@@ -177,6 +177,19 @@ module.exports = {
     service: 'open-exchange-rate',
     openExchangeRate: {
       appId: process.env.OPEN_EXCHANGE_RATE_APP_ID,
-    }
-  }
+    },
+  },
+
+  /**
+   * Plaid.
+   */
+  plaid: {
+    env: process.env.PLAID_ENV || 'sandbox',
+    clientId: process.env.PLAID_CLIENT_ID,
+    secretDevelopment: process.env.PLAID_SECRET_DEVELOPMENT,
+    secretSandbox: process.env.PLAID_SECRET_SANDBOX,
+    redirectSandBox: process.env.PLAID_SANDBOX_REDIRECT_URI,
+    redirectDevelopment: process.env.PLAID_DEVELOPMENT_REDIRECT_URI,
+    linkWebhook: process.env.PLAID_LINK_WEBHOOK
+  },
 };

packages/server/src/data/options.ts

@@ -136,6 +136,11 @@ export default {
       type: 'number',
     },
   },
+  inventory: {
+    cost_compute_running: {
+      type: 'boolean',
+    },
+  },
   accounts: {
     account_code_required: {
       type: 'boolean',

packages/server/src/database/migrations/20240201160214_create_plaid_items_Table.js

@@ -0,0 +1,14 @@
+exports.up = function (knex) {
+  return knex.schema.createTable('plaid_items', (table) => {
+    table.increments('id');
+    table.integer('tenant_id').unsigned();
+    table.string('plaid_item_id');
+    table.string('plaid_institution_id');
+    table.string('plaid_access_token');
+    table.string('last_cursor');
+    table.string('status');
+    table.timestamps();
+  });
+};
+
+exports.down = function (knex) {};

packages/server/src/database/migrations/20240201235818_add_plaid_account_id_to_accounts_table.js

@@ -0,0 +1,9 @@
+exports.up = function (knex) {
+  return knex.schema.table('accounts', (table) => {
+    table.string('plaid_account_id');
+    table.string('account_mask').nullable();
+    table.decimal('bank_balance', 15, 5);
+  });
+};
+
+exports.down = function (knex) {};

packages/server/src/database/migrations/20240204180554_add_plaid_transaction_id_to_cashflow_transaction.js

@@ -0,0 +1,7 @@
+exports.up = function (knex) {
+  return knex.schema.table('cashflow_transactions', (table) => {
+    table.string('plaid_transaction_id');
+  });
+};
+
+exports.down = function (knex) {};

packages/server/src/database/migrations/20240228183404_create_uncateogrized_cashflow_transactions_table.js

@@ -0,0 +1,28 @@
+exports.up = function (knex) {
+  return knex.schema.createTable(
+    'uncategorized_cashflow_transactions',
+    (table) => {
+      table.increments('id');
+      table.date('date').index();
+      table.decimal('amount');
+      table.string('currency_code');
+      table.string('reference_no').index();
+      table.string('payee');
+      table
+        .integer('account_id')
+        .unsigned()
+        .references('id')
+        .inTable('accounts');
+      table.string('description');
+      table.string('categorize_ref_type');
+      table.integer('categorize_ref_id').unsigned();
+      table.boolean('categorized').defaultTo(false);
+      table.string('plaid_transaction_id');
+      table.timestamps();
+    }
+  );
+};
+
+exports.down = function (knex) {
+  return knex.schema.dropTableIfExists('uncategorized_cashflow_transactions');
+};

packages/server/src/database/migrations/20240304153926_add_uncategorized_transactions_column_to_accounts_table.js

@@ -0,0 +1,10 @@
+exports.up = function (knex) {
+  return knex.schema.table('accounts', (table) => {
+    table.integer('uncategorized_transactions').defaultTo(0);
+    table.boolean('is_system_account').defaultTo(true);
+    table.boolean('is_feeds_active').defaultTo(false);
+    table.datetime('last_feeds_updated_at').nullable();
+  });
+};
+
+exports.down = function (knex) {};

packages/server/src/interfaces/Account.ts

@@ -6,12 +6,15 @@ export interface IAccountDTO {
   code: string;
   description: string;
   accountType: string;
-  parentAccountId: number;
+  parentAccountId?: number;
   active: boolean;
+  bankBalance?: number;
+  accountMask?: string;
 }
 
 export interface IAccountCreateDTO extends IAccountDTO {
   currencyCode?: string;
+  plaidAccountId?: string;
 }
 
 export interface IAccountEditDTO extends IAccountDTO {}
@@ -33,6 +36,7 @@ export interface IAccount {
   type?: any[];
   accountNormal: string;
   accountParentType: string;
+  bankBalance: string;
 }
 
 export enum AccountNormal {
@@ -154,10 +158,9 @@ export enum AccountAction {
   TransactionsLocking = 'TransactionsLocking',
 }
 
-
 export enum TaxRateAction {
   CREATE = 'Create',
   EDIT = 'Edit',
   DELETE = 'Delete',
   VIEW = 'View',
-}
+}

packages/server/src/interfaces/CashFlow.ts

@@ -233,3 +233,38 @@ export interface ICashflowTransactionSchema {
 }
 
 export interface ICashflowTransactionInput extends ICashflowTransactionSchema {}
+
+export interface ICategorizeCashflowTransactioDTO {
+  creditAccountId: number;
+  referenceNo: string;
+  transactionNumber: string;
+  transactionType: string;
+  exchangeRate: number;
+  description: string;
+  branchId: number;
+}
+
+export interface IUncategorizedCashflowTransaction {
+  id?: number;
+  amount: number;
+  date: Date;
+  currencyCode: string;
+  accountId: number;
+  description: string;
+  referenceNo: string;
+  categorizeRefType: string;
+  categorizeRefId: number;
+  categorized: boolean;
+}
+
+
+export interface CreateUncategorizedTransactionDTO {
+  date: Date | string;
+  accountId: number;
+  amount: number;
+  currencyCode: string;
+  payee?: string;
+  description?: string;
+  referenceNo?: string | null;
+  plaidTransactionId?: string | null;
+}

packages/server/src/interfaces/CashflowService.ts

@@ -1,5 +1,6 @@
 import { Knex } from 'knex';
 import { IAccount } from './Account';
+import { IUncategorizedCashflowTransaction } from './CashFlow';
 
 export interface ICashflowAccountTransactionsFilter {
   page: number;
@@ -45,9 +46,12 @@ export interface ICashflowCommandDTO {
 
   publish: boolean;
   branchId?: number;
+  plaidTransactionId?: string;
 }
 
-export interface ICashflowNewCommandDTO extends ICashflowCommandDTO {}
+export interface ICashflowNewCommandDTO extends ICashflowCommandDTO {
+  plaidAccountId?: string;
+}
 
 export interface ICashflowTransaction {
   id?: number;
@@ -121,8 +125,39 @@ export interface ICommandCashflowDeletedPayload {
   trx: Knex.Transaction;
 }
 
+export interface ICashflowTransactionCategorizedPayload {
+  tenantId: number;
+  cashflowTransactionId: number;
+  cashflowTransaction: ICashflowTransaction;
+  trx: Knex.Transaction;
+}
+export interface ICashflowTransactionUncategorizingPayload {
+  tenantId: number;
+  uncategorizedTransaction: IUncategorizedCashflowTransaction;
+  trx: Knex.Transaction;
+}
+export interface ICashflowTransactionUncategorizedPayload {
+  tenantId: number;
+  uncategorizedTransaction: IUncategorizedCashflowTransaction;
+  oldUncategorizedTransaction: IUncategorizedCashflowTransaction;
+  trx: Knex.Transaction;
+}
+
 export enum CashflowAction {
   Create = 'Create',
   Delete = 'Delete',
   View = 'View',
 }
+
+export interface CategorizeTransactionAsExpenseDTO {
+  expenseAccountId: number;
+  exchangeRate: number;
+  referenceNo: string;
+  description: string;
+  branchId?: number;
+}
+
+export interface IGetUncategorizedTransactionsQuery {
+  page?: number;
+  pageSize?: number;
+}

packages/server/src/interfaces/Plaid.ts

@@ -0,0 +1,56 @@
+export interface IPlaidItemCreatedEventPayload {
+  tenantId: number;
+  plaidAccessToken: string;
+  plaidItemId: string;
+  plaidInstitutionId: string;
+}
+
+export interface PlaidItemDTO {
+  publicToken: string;
+  institutionId: string;
+}
+
+export interface PlaidAccount {
+  account_id: string;
+  balances: {
+    available: number;
+    current: number;
+    iso_currency_code: string;
+    limit: null;
+    unofficial_currency_code: null;
+  };
+  mask: string;
+  name: string;
+  official_name: string;
+  persistent_account_id: string;
+  subtype: string;
+  type: string;
+}
+
+export interface PlaidTransaction {
+  date: string;
+  account_id: string;
+  amount: number;
+  authorized_date: string;
+  name: string;
+  category: string[];
+  check_number: number | null;
+  iso_currency_code: string;
+  transaction_id: string;
+  transaction_type: string;
+  payment_meta: { reference_number: string | null; payee: string | null };
+}
+
+export interface PlaidFetchedTransactionsUpdates {
+  added: any[];
+  modified: any[];
+  removed: any[];
+  accessToken: string;
+  cursor: string;
+}
+
+export interface SyncAccountsTransactionsTask {
+  tenantId: number;
+  plaidAccountId: number;
+  plaidTransactions: PlaidTransaction[];
+}

packages/server/src/interfaces/index.ts

@@ -74,6 +74,7 @@ export * from './Tasks';
 export * from './Times';
 export * from './ProjectProfitabilitySummary';
 export * from './TaxRate';
+export * from './Plaid';
 
 export interface I18nService {
   __: (input: string) => string;

packages/server/src/lib/Plaid/Plaid.ts

@@ -0,0 +1,103 @@
+import { forEach } from 'lodash';
+import { Configuration, PlaidApi, PlaidEnvironments } from 'plaid';
+import { createPlaidApiEvent } from './PlaidApiEventsDBSync';
+import config from '@/config';
+
+const OPTIONS = { clientApp: 'Plaid-Pattern' };
+
+// We want to log requests to / responses from the Plaid API (via the Plaid client), as this data
+// can be useful for troubleshooting.
+
+/**
+ * Logging function for Plaid client methods that use an access_token as an argument. Associates
+ * the Plaid API event log entry with the item and user the request is for.
+ *
+ * @param {string} clientMethod the name of the Plaid client method called.
+ * @param {Array} clientMethodArgs the arguments passed to the Plaid client method.
+ * @param {Object} response the response from the Plaid client.
+ */
+const defaultLogger = async (clientMethod, clientMethodArgs, response) => {
+  const accessToken = clientMethodArgs[0].access_token;
+  // const { id: itemId, user_id: userId } = await retrieveItemByPlaidAccessToken(
+  //   accessToken
+  // );
+  // await createPlaidApiEvent(1, 1, clientMethod, clientMethodArgs, response);
+
+  // console.log(response);
+};
+
+/**
+ * Logging function for Plaid client methods that do not use access_token as an argument. These
+ * Plaid API event log entries will not be associated with an item or user.
+ *
+ * @param {string} clientMethod the name of the Plaid client method called.
+ * @param {Array} clientMethodArgs the arguments passed to the Plaid client method.
+ * @param {Object} response the response from the Plaid client.
+ */
+const noAccessTokenLogger = async (
+  clientMethod,
+  clientMethodArgs,
+  response
+) => {
+  // console.log(response);
+
+  // await createPlaidApiEvent(
+  //   undefined,
+  //   undefined,
+  //   clientMethod,
+  //   clientMethodArgs,
+  //   response
+  // );
+};
+
+// Plaid client methods used in this app, mapped to their appropriate logging functions.
+const clientMethodLoggingFns = {
+  accountsGet: defaultLogger,
+  institutionsGet: noAccessTokenLogger,
+  institutionsGetById: noAccessTokenLogger,
+  itemPublicTokenExchange: noAccessTokenLogger,
+  itemRemove: defaultLogger,
+  linkTokenCreate: noAccessTokenLogger,
+  transactionsSync: defaultLogger,
+  sandboxItemResetLogin: defaultLogger,
+};
+// Wrapper for the Plaid client. This allows us to easily log data for all Plaid client requests.
+export class PlaidClientWrapper {
+  constructor() {
+    // Initialize the Plaid client.
+    const configuration = new Configuration({
+      basePath: PlaidEnvironments[config.plaid.env],
+      baseOptions: {
+        headers: {
+          'PLAID-CLIENT-ID': config.plaid.clientId,
+          'PLAID-SECRET':
+            config.plaid.env === 'development'
+              ? config.plaid.secretDevelopment
+              : config.plaid.secretSandbox,
+          'Plaid-Version': '2020-09-14',
+        },
+      },
+    });
+
+    this.client = new PlaidApi(configuration);
+
+    // Wrap the Plaid client methods to add a logging function.
+    forEach(clientMethodLoggingFns, (logFn, method) => {
+      this[method] = this.createWrappedClientMethod(method, logFn);
+    });
+  }
+
+  // Allows us to log API request data for troubleshooting purposes.
+  createWrappedClientMethod(clientMethod, log) {
+    return async (...args) => {
+      try {
+        const res = await this.client[clientMethod](...args);
+        await log(clientMethod, args, res);
+        return res;
+      } catch (err) {
+        await log(clientMethod, args, err?.response?.data);
+        throw err;
+      }
+    };
+  }
+}

packages/server/src/lib/Plaid/PlaidApiEventsDBSync.ts

@@ -0,0 +1,48 @@
+/**
+ * Creates a single Plaid api event log entry.
+ *
+ * @param {string} itemId the item id in the request.
+ * @param {string} userId the user id in the request.
+ * @param {string} plaidMethod the Plaid client method called.
+ * @param {Array} clientMethodArgs the arguments passed to the Plaid client method.
+ * @param {Object} response the Plaid api response object.
+ */
+export const createPlaidApiEvent = async (
+  itemId,
+  userId,
+  plaidMethod,
+  clientMethodArgs,
+  response
+) => {
+  const {
+    error_code: errorCode,
+    error_type: errorType,
+    request_id: requestId,
+  } = response;
+  const query = {
+    text: `
+      INSERT INTO plaid_api_events_table
+        (
+          item_id,
+          user_id,
+          plaid_method,
+          arguments,
+          request_id,
+          error_type,
+          error_code
+        )
+      VALUES
+        ($1, $2, $3, $4, $5, $6, $7);
+    `,
+    values: [
+      itemId,
+      userId,
+      plaidMethod,
+      JSON.stringify(clientMethodArgs),
+      requestId,
+      errorType,
+      errorCode,
+    ],
+  };
+  // await db.query(query);
+};

packages/server/src/lib/Plaid/index.ts

@@ -0,0 +1 @@
+export * from './Plaid';

packages/server/src/loaders/eventEmitter.ts

@@ -84,9 +84,11 @@ import { WriteInvoiceTaxTransactionsSubscriber } from '@/services/TaxRates/subsc
 import { BillTaxRateValidateSubscriber } from '@/services/TaxRates/subscribers/BillTaxRateValidateSubscriber';
 import { WriteBillTaxTransactionsSubscriber } from '@/services/TaxRates/subscribers/WriteBillTaxTransactionsSubscriber';
 import { SyncItemTaxRateOnEditTaxSubscriber } from '@/services/TaxRates/SyncItemTaxRateOnEditTaxSubscriber';
+import { PlaidUpdateTransactionsOnItemCreatedSubscriber } from '@/services/Banking/Plaid/subscribers/PlaidUpdateTransactionsOnItemCreatedSubscriber';
 import { InvoiceChangeStatusOnMailSentSubscriber } from '@/services/Sales/Invoices/subscribers/InvoiceChangeStatusOnMailSentSubscriber';
 import { SaleReceiptMarkClosedOnMailSentSubcriber } from '@/services/Sales/Receipts/subscribers/SaleReceiptMarkClosedOnMailSentSubcriber';
 import { SaleEstimateMarkApprovedOnMailSent } from '@/services/Sales/Estimates/subscribers/SaleEstimateMarkApprovedOnMailSent';
+import { DeleteCashflowTransactionOnUncategorize } from '@/services/Cashflow/subscribers/DeleteCashflowTransactionOnUncategorize';
 
 export default () => {
   return new EventPublisher();
@@ -209,5 +211,11 @@ export const susbcribers = () => {
     WriteBillTaxTransactionsSubscriber,
 
     SyncItemTaxRateOnEditTaxSubscriber,
+
+    // Plaid
+    PlaidUpdateTransactionsOnItemCreatedSubscriber,
+
+    // Cashflow
+    DeleteCashflowTransactionOnUncategorize,
   ];
 };

packages/server/src/loaders/express.ts

@@ -5,6 +5,8 @@ import boom from 'express-boom';
 import errorHandler from 'errorhandler';
 import bodyParser from 'body-parser';
 import fileUpload from 'express-fileupload';
+import { Server } from 'socket.io';
+import Container from 'typedi';
 import routes from 'api';
 import LoggerMiddleware from '@/api/middleware/LoggerMiddleware';
 import AgendashController from '@/api/controllers/Agendash';
@@ -72,4 +74,32 @@ export default ({ app }) => {
   app.use((req: Request, res: Response, next: NextFunction) => {
     return res.boom.notFound();
   });
+  const server = app.listen(app.get('port'), (err) => {
+    if (err) {
+      console.log(err);
+      process.exit(1);
+      return;
+    }
+    console.log(`
+      ################################################
+        Server listening on port: ${app.get('port')}
+      ################################################
+    `);
+  });
+  const io = new Server(server, { path: '/socket' });
+
+  // Set socket.io listeners.
+  io.on('connection', (socket) => {
+    console.log('SOCKET CONNECTED');
+
+    socket.on('disconnect', () => {
+      console.log('SOCKET DISCONNECTED');
+    });
+  });
+  // Middleware to pass socket to each request object.
+  app.use((req: Request, res: Response, next: NextFunction) => {
+    req.io = io;
+    next();
+  });
+  Container.set('socket', io);
 };

packages/server/src/loaders/jobs.ts

@@ -10,6 +10,7 @@ import { SendSaleInvoiceReminderMailJob } from '@/services/Sales/Invoices/SendSa
 import { SendSaleEstimateMailJob } from '@/services/Sales/Estimates/SendSaleEstimateMailJob';
 import { SaleReceiptMailNotificationJob } from '@/services/Sales/Receipts/SaleReceiptMailNotificationJob';
 import { PaymentReceiveMailNotificationJob } from '@/services/Sales/PaymentReceives/PaymentReceiveMailNotificationJob';
+import { PlaidFetchTransactionsJob } from '@/services/Banking/Plaid/PlaidFetchTransactionsJob';
 
 export default ({ agenda }: { agenda: Agenda }) => {
   new ResetPasswordMailJob(agenda);
@@ -23,6 +24,7 @@ export default ({ agenda }: { agenda: Agenda }) => {
   new SendSaleEstimateMailJob(agenda);
   new SaleReceiptMailNotificationJob(agenda);
   new PaymentReceiveMailNotificationJob(agenda);
+  new PlaidFetchTransactionsJob(agenda);
 
   agenda.start();
 };

packages/server/src/loaders/tenantModels.ts

@@ -61,6 +61,8 @@ import Task from 'models/Task';
 import TaxRate from 'models/TaxRate';
 import TaxRateTransaction from 'models/TaxRateTransaction';
 import Attachment from 'models/Attachment';
+import PlaidItem from 'models/PlaidItem';
+import UncategorizedCashflowTransaction from 'models/UncategorizedCashflowTransaction';
 
 export default (knex) => {
   const models = {
@@ -124,7 +126,9 @@ export default (knex) => {
     Task,
     TaxRate,
     TaxRateTransaction,
-    Attachment
+    Attachment,
+    PlaidItem,
+    UncategorizedCashflowTransaction
   };
   return mapValues(models, (model) => model.bindKnex(knex));
 };

packages/server/src/models/Account.ts

@@ -196,6 +196,7 @@ export default class Account extends mixin(TenantModel, [
     const Expense = require('models/Expense');
     const ExpenseEntry = require('models/ExpenseCategory');
     const ItemEntry = require('models/ItemEntry');
+    const UncategorizedTransaction = require('models/UncategorizedCashflowTransaction');
 
     return {
       /**
@@ -305,6 +306,21 @@ export default class Account extends mixin(TenantModel, [
           to: 'items_entries.sellAccountId',
         },
       },
+
+      /**
+       * Associated uncategorized transactions.
+       */
+      uncategorizedTransactions: {
+        relation: Model.HasManyRelation,
+        modelClass: UncategorizedTransaction.default,
+        join: {
+          from: 'accounts.id',
+          to: 'uncategorized_cashflow_transactions.accountId',
+        },
+        filter: (query) => {
+          query.where('categorized', false);
+        },
+      },
     };
   }
 

packages/server/src/models/CashflowTransaction.ts

@@ -12,6 +12,7 @@ export default class CashflowTransaction extends TenantModel {
   transactionType: string;
   amount: number;
   exchangeRate: number;
+  uncategorize: boolean;
 
   /**
    * Table name.

packages/server/src/models/Expense.ts

@@ -215,6 +215,10 @@ export default class Expense extends mixin(TenantModel, [
           to: 'branches.id',
         },
       },
+
+      /**
+       * 
+       */
       media: {
         relation: Model.ManyToManyRelation,
         modelClass: Media.default,

packages/server/src/models/PlaidItem.ts

@@ -0,0 +1,24 @@
+import TenantModel from 'models/TenantModel';
+
+export default class PlaidItem extends TenantModel {
+  /**
+   * Table name.
+   */
+  static get tableName() {
+    return 'plaid_items';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return [];
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    return {};
+  }
+}

packages/server/src/models/UncategorizedCashflowTransaction.ts

@@ -0,0 +1,140 @@
+/* eslint-disable global-require */
+import TenantModel from 'models/TenantModel';
+import { Model, ModelOptions, QueryContext } from 'objection';
+import Account from './Account';
+
+export default class UncategorizedCashflowTransaction extends TenantModel {
+  id!: number;
+  amount!: number;
+  categorized!: boolean;
+  accountId!: number;
+
+  /**
+   * Table name.
+   */
+  static get tableName() {
+    return 'uncategorized_cashflow_transactions';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  static get timestamps() {
+    return ['createdAt', 'updatedAt'];
+  }
+
+  /**
+   * Virtual attributes.
+   */
+  static get virtualAttributes() {
+    return [
+      'withdrawal',
+      'deposit',
+      'isDepositTransaction',
+      'isWithdrawalTransaction',
+    ];
+  }
+
+  /**
+   * Retrieves the withdrawal amount.
+   * @returns {number}
+   */
+  public get withdrawal() {
+    return this.amount < 0 ? Math.abs(this.amount) : 0;
+  }
+
+  /**
+   * Retrieves the deposit amount.
+   * @returns {number}
+   */
+  public get deposit(): number {
+    return this.amount > 0 ? Math.abs(this.amount) : 0;
+  }
+
+  /**
+   * Detarmines whether the transaction is deposit transaction.
+   */
+  public get isDepositTransaction(): boolean {
+    return 0 < this.deposit;
+  }
+
+  /**
+   * Detarmines whether the transaction is withdrawal transaction.
+   */
+  public get isWithdrawalTransaction(): boolean {
+    return 0 < this.withdrawal;
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const Account = require('models/Account');
+
+    return {
+      /**
+       * Transaction may has associated to account.
+       */
+      account: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Account.default,
+        join: {
+          from: 'uncategorized_cashflow_transactions.accountId',
+          to: 'accounts.id',
+        },
+      },
+    };
+  }
+
+  /**
+   * Updates the count of uncategorized transactions for the associated account
+   * based on the specified operation.
+   * @param {QueryContext} queryContext - The query context for the transaction.
+   * @param {boolean} increment - Indicates whether to increment or decrement the count.
+   */
+  private async updateUncategorizedTransactionCount(
+    queryContext: QueryContext,
+    increment: boolean
+  ) {
+    const operation = increment ? 'increment' : 'decrement';
+    const amount = increment ? 1 : -1;
+
+    await Account.query(queryContext.transaction)
+      .findById(this.accountId)
+      [operation]('uncategorized_transactions', amount);
+  }
+
+  /**
+   * Runs after insert.
+   * @param {QueryContext} queryContext
+   */
+  public async $afterInsert(queryContext) {
+    await super.$afterInsert(queryContext);
+    await this.updateUncategorizedTransactionCount(queryContext, true);
+  }
+
+  /**
+   * Runs after update.
+   * @param {ModelOptions} opt
+   * @param {QueryContext} queryContext
+   */
+  public async $afterUpdate(
+    opt: ModelOptions,
+    queryContext: QueryContext
+  ): Promise<any> {
+    await super.$afterUpdate(opt, queryContext);
+
+    if (this.id && this.categorized) {
+      await this.updateUncategorizedTransactionCount(queryContext, false);
+    }
+  }
+
+  /**
+   * Runs after delete.
+   * @param {QueryContext} queryContext
+   */
+  public async $afterDelete(queryContext: QueryContext) {
+    await super.$afterDelete(queryContext);
+    await this.updateUncategorizedTransactionCount(queryContext, false);
+  }
+}

packages/server/src/server.ts

@@ -10,19 +10,6 @@ async function startServer() {
 
   // Intiialize all registered loaders.
   await loadersFactory({ expressApp: app });
-
-  app.listen(app.get('port'), (err) => {
-    if (err) {
-      console.log(err);
-      process.exit(1);
-      return;
-    }
-    console.log(`
-      ################################################
-        Server listening on port: ${app.get('port')}
-      ################################################
-    `);
-  });
 }
 
 startServer();

packages/server/src/services/Accounts/AccountTransform.ts

@@ -13,7 +13,7 @@ export class AccountTransformer extends Transformer {
    * @returns {Array}
    */
   public includeAttributes = (): string[] => {
-    return ['formattedAmount', 'flattenName'];
+    return ['formattedAmount', 'flattenName', 'bankBalanceFormatted'];
   };
 
   /**
@@ -41,6 +41,17 @@ export class AccountTransformer extends Transformer {
     return formatNumber(account.amount, { currencyCode: account.currencyCode });
   };
 
+  /**
+   * Retrieves the formatted bank balance.
+   * @param {IAccount} account
+   * @returns {string}
+   */
+  protected bankBalanceFormatted = (account: IAccount): string => {
+    return formatNumber(account.bankBalance, {
+      currencyCode: account.currencyCode,
+    });
+  };
+
   /**
    * Transformes the accounts collection to flat or nested array.
    * @param {IAccount[]}

packages/server/src/services/Banking/Plaid/PlaidApplication.ts

@@ -0,0 +1,59 @@
+import { Inject, Service } from 'typedi';
+import { PlaidLinkTokenService } from './PlaidLinkToken';
+import { PlaidItemService } from './PlaidItem';
+import { PlaidItemDTO } from '@/interfaces';
+import { PlaidWebooks } from './PlaidWebhooks';
+
+@Service()
+export class PlaidApplication {
+  @Inject()
+  private getLinkTokenService: PlaidLinkTokenService;
+
+  @Inject()
+  private plaidItemService: PlaidItemService;
+
+  @Inject()
+  private plaidWebhooks: PlaidWebooks;
+
+  /**
+   * Retrieves the Plaid link token.
+   * @param {number} tenantId
+   * @param {number} itemId
+   * @returns
+   */
+  public getLinkToken(tenantId: number) {
+    return this.getLinkTokenService.getLinkToken(tenantId);
+  }
+
+  /**
+   * Exchanges the Plaid access token.
+   * @param {number} tenantId
+   * @param {PlaidItemDTO} itemDTO
+   * @returns
+   */
+  public exchangeToken(tenantId: number, itemDTO: PlaidItemDTO): Promise<void> {
+    return this.plaidItemService.item(tenantId, itemDTO);
+  }
+
+  /**
+   * Listens to Plaid webhooks
+   * @param {number} tenantId 
+   * @param {string} webhookType 
+   * @param {string} plaidItemId 
+   * @param {string} webhookCode 
+   * @returns 
+   */
+  public webhooks(
+    tenantId: number,
+    plaidItemId: string,
+    webhookType: string,
+    webhookCode: string
+  ) {
+    return this.plaidWebhooks.webhooks(
+      tenantId,
+      plaidItemId,
+      webhookType,
+      webhookCode
+    );
+  }
+}

packages/server/src/services/Banking/Plaid/PlaidFetchTransactionsJob.ts

@@ -0,0 +1,43 @@
+import Container, { Service } from 'typedi';
+import { PlaidUpdateTransactions } from './PlaidUpdateTransactions';
+import { IPlaidItemCreatedEventPayload } from '@/interfaces';
+
+@Service()
+export class PlaidFetchTransactionsJob {
+  /**
+   * Constructor method.
+   */
+  constructor(agenda) {
+    agenda.define(
+      'plaid-update-account-transactions',
+      { priority: 'high', concurrency: 2 },
+      this.handler
+    );
+  }
+
+  /**
+   * Triggers the function.
+   */
+  private handler = async (job, done: Function) => {
+    const { tenantId, plaidItemId } = job.attrs
+      .data as IPlaidItemCreatedEventPayload;
+
+    const plaidFetchTransactionsService = Container.get(
+      PlaidUpdateTransactions
+    );
+    const io = Container.get('socket');
+
+    try {
+      await plaidFetchTransactionsService.updateTransactions(
+        tenantId,
+        plaidItemId
+      );
+      // Notify the frontend to reflect the new transactions changes.
+      io.emit('NEW_TRANSACTIONS_DATA', { plaidItemId });
+      done();
+    } catch (error) {
+      console.log(error);
+      done(error);
+    }
+  };
+}

packages/server/src/services/Banking/Plaid/PlaidItem.ts

@@ -0,0 +1,58 @@
+import { Inject, Service } from 'typedi';
+import { PlaidClientWrapper } from '@/lib/Plaid';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import events from '@/subscribers/events';
+import {
+  IPlaidItemCreatedEventPayload,
+  PlaidItemDTO,
+} from '@/interfaces/Plaid';
+import SystemPlaidItem from '@/system/models/SystemPlaidItem';
+
+@Service()
+export class PlaidItemService {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  /**
+   * Exchanges the public token to get access token and item id and then creates
+   * a new Plaid item.
+   * @param {number} tenantId
+   * @param {PlaidItemDTO} itemDTO
+   * @returns {Promise<void>}
+   */
+  public async item(tenantId: number, itemDTO: PlaidItemDTO): Promise<void> {
+    const { PlaidItem } = this.tenancy.models(tenantId);
+    const { publicToken, institutionId } = itemDTO;
+
+    const plaidInstance = new PlaidClientWrapper();
+
+    // Exchange the public token for a private access token and store with the item.
+    const response = await plaidInstance.itemPublicTokenExchange({
+      public_token: publicToken,
+    });
+    const plaidAccessToken = response.data.access_token;
+    const plaidItemId = response.data.item_id;
+
+    // Store the Plaid item metadata on tenant scope.
+    const plaidItem = await PlaidItem.query().insertAndFetch({
+      tenantId,
+      plaidAccessToken,
+      plaidItemId,
+      plaidInstitutionId: institutionId,
+    });
+    // Stores the Plaid item id on system scope.
+    await SystemPlaidItem.query().insert({ tenantId, plaidItemId });
+
+    // Triggers `onPlaidItemCreated` event.
+    await this.eventPublisher.emitAsync(events.plaid.onItemCreated, {
+      tenantId,
+      plaidAccessToken,
+      plaidItemId,
+      plaidInstitutionId: institutionId,
+    } as IPlaidItemCreatedEventPayload);
+  }
+}

packages/server/src/services/Banking/Plaid/PlaidLinkToken.ts

@@ -0,0 +1,34 @@
+import { PlaidClientWrapper } from '@/lib/Plaid';
+import { Service } from 'typedi';
+import config from '@/config';
+
+@Service()
+export class PlaidLinkTokenService {
+  /**
+   * Retrieves the plaid link token.
+   * @param {number} tenantId
+   * @returns
+   */
+  async getLinkToken(tenantId: number) {
+    const accessToken = null;
+
+    // Must include transactions in order to receive transactions webhooks
+    const products = ['transactions'];
+    const linkTokenParams = {
+      user: {
+        // This should correspond to a unique id for the current user.
+        client_user_id: 'uniqueId' + tenantId,
+      },
+      client_name: 'Pattern',
+      products,
+      country_codes: ['US'],
+      language: 'en',
+      webhook: config.plaid.linkWebhook,
+      access_token: accessToken,
+    };
+    const plaidInstance = new PlaidClientWrapper();
+    const createResponse = await plaidInstance.linkTokenCreate(linkTokenParams);
+
+    return createResponse.data;
+  }
+}

packages/server/src/services/Banking/Plaid/PlaidSyncDB.ts

@@ -0,0 +1,198 @@
+import * as R from 'ramda';
+import { Inject, Service } from 'typedi';
+import bluebird from 'bluebird';
+import { entries, groupBy } from 'lodash';
+import { CreateAccount } from '@/services/Accounts/CreateAccount';
+import { PlaidAccount, PlaidTransaction } from '@/interfaces';
+import {
+  transformPlaidAccountToCreateAccount,
+  transformPlaidTrxsToCashflowCreate,
+} from './utils';
+import { DeleteCashflowTransaction } from '@/services/Cashflow/DeleteCashflowTransactionService';
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { CashflowApplication } from '@/services/Cashflow/CashflowApplication';
+
+const CONCURRENCY_ASYNC = 10;
+
+@Service()
+export class PlaidSyncDb {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private createAccountService: CreateAccount;
+
+  @Inject()
+  private cashflowApp: CashflowApplication;
+
+  @Inject()
+  private deleteCashflowTransactionService: DeleteCashflowTransaction;
+
+  /**
+   * Syncs the plaid accounts to the system accounts.
+   * @param {number} tenantId Tenant ID.
+   * @param {PlaidAccount[]} plaidAccounts
+   * @returns {Promise<void>}
+   */
+  public async syncBankAccounts(
+    tenantId: number,
+    plaidAccounts: PlaidAccount[],
+    institution: any
+  ): Promise<void> {
+    const transformToPlaidAccounts =
+      transformPlaidAccountToCreateAccount(institution);
+
+    const accountCreateDTOs = R.map(transformToPlaidAccounts)(plaidAccounts);
+
+    await bluebird.map(
+      accountCreateDTOs,
+      (createAccountDTO: any) =>
+        this.createAccountService.createAccount(tenantId, createAccountDTO),
+      { concurrency: CONCURRENCY_ASYNC }
+    );
+  }
+
+  /**
+   * Synsc the Plaid transactions to the system GL entries.
+   * @param {number} tenantId - Tenant ID.
+   * @param {number} plaidAccountId - Plaid account ID.
+   * @param {PlaidTransaction[]} plaidTranasctions - Plaid transactions
+   */
+  public async syncAccountTranactions(
+    tenantId: number,
+    plaidAccountId: number,
+    plaidTranasctions: PlaidTransaction[]
+  ): Promise<void> {
+    const { Account } = this.tenancy.models(tenantId);
+
+    const cashflowAccount = await Account.query()
+      .findOne({ plaidAccountId })
+      .throwIfNotFound();
+
+    const openingEquityBalance = await Account.query().findOne(
+      'slug',
+      'opening-balance-equity'
+    );
+    // Transformes the Plaid transactions to cashflow create DTOs.
+    const transformTransaction = transformPlaidTrxsToCashflowCreate(
+      cashflowAccount.id,
+      openingEquityBalance.id
+    );
+    const uncategorizedTransDTOs =
+      R.map(transformTransaction)(plaidTranasctions);
+
+    // Creating account transaction queue.
+    await bluebird.map(
+      uncategorizedTransDTOs,
+      (uncategoriedDTO) =>
+        this.cashflowApp.createUncategorizedTransaction(
+          tenantId,
+          uncategoriedDTO
+        ),
+      { concurrency: 1 }
+    );
+  }
+
+  /**
+   * Syncs the accounts transactions in paraller under controlled concurrency.
+   * @param {number} tenantId
+   * @param {PlaidTransaction[]} plaidTransactions
+   */
+  public async syncAccountsTransactions(
+    tenantId: number,
+    plaidAccountsTransactions: PlaidTransaction[]
+  ): Promise<void> {
+    const groupedTrnsxByAccountId = entries(
+      groupBy(plaidAccountsTransactions, 'account_id')
+    );
+    await bluebird.map(
+      groupedTrnsxByAccountId,
+      ([plaidAccountId, plaidTransactions]: [number, PlaidTransaction[]]) => {
+        return this.syncAccountTranactions(
+          tenantId,
+          plaidAccountId,
+          plaidTransactions
+        );
+      },
+      { concurrency: CONCURRENCY_ASYNC }
+    );
+  }
+
+  /**
+   * Syncs the removed Plaid transactions ids from the cashflow system transactions.
+   * @param {string[]} plaidTransactionsIds - Plaid Transactions IDs.
+   */
+  public async syncRemoveTransactions(
+    tenantId: number,
+    plaidTransactionsIds: string[]
+  ) {
+    const { CashflowTransaction } = this.tenancy.models(tenantId);
+
+    const cashflowTransactions = await CashflowTransaction.query().whereIn(
+      'plaidTransactionId',
+      plaidTransactionsIds
+    );
+    const cashflowTransactionsIds = cashflowTransactions.map(
+      (trans) => trans.id
+    );
+    await bluebird.map(
+      cashflowTransactionsIds,
+      (transactionId: number) =>
+        this.deleteCashflowTransactionService.deleteCashflowTransaction(
+          tenantId,
+          transactionId
+        ),
+      { concurrency: CONCURRENCY_ASYNC }
+    );
+  }
+
+  /**
+   * Syncs the Plaid item last transaction cursor.
+   * @param {number} tenantId - Tenant ID.
+   * @param {string} itemId - Plaid item ID.
+   * @param {string} lastCursor - Last transaction cursor.
+   */
+  public async syncTransactionsCursor(
+    tenantId: number,
+    plaidItemId: string,
+    lastCursor: string
+  ) {
+    const { PlaidItem } = this.tenancy.models(tenantId);
+
+    await PlaidItem.query().findOne({ plaidItemId }).patch({ lastCursor });
+  }
+
+  /**
+   * Updates the last feeds updated at of the given Plaid accounts ids.
+   * @param {number} tenantId
+   * @param {string[]} plaidAccountIds
+   */
+  public async updateLastFeedsUpdatedAt(
+    tenantId: number,
+    plaidAccountIds: string[]
+  ) {
+    const { Account } = this.tenancy.models(tenantId);
+
+    await Account.query().whereIn('plaid_account_id', plaidAccountIds).patch({
+      lastFeedsUpdatedAt: new Date(),
+    });
+  }
+
+  /**
+   * Updates the accounts feed active status of the given Plaid accounts ids.
+   * @param {number} tenantId
+   * @param {number[]} plaidAccountIds
+   * @param {boolean} isFeedsActive
+   */
+  public async updateAccountsFeedsActive(
+    tenantId: number,
+    plaidAccountIds: string[],
+    isFeedsActive: boolean = true
+  ) {
+    const { Account } = this.tenancy.models(tenantId);
+
+    await Account.query().whereIn('plaid_account_id', plaidAccountIds).patch({
+      isFeedsActive,
+    });
+  }
+}

packages/server/src/services/Banking/Plaid/PlaidUpdateTransactions.ts

@@ -0,0 +1,119 @@
+import HasTenancyService from '@/services/Tenancy/TenancyService';
+import { Inject, Service } from 'typedi';
+import { PlaidClientWrapper } from '@/lib/Plaid/Plaid';
+import { PlaidSyncDb } from './PlaidSyncDB';
+import { PlaidFetchedTransactionsUpdates } from '@/interfaces';
+
+@Service()
+export class PlaidUpdateTransactions {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private plaidSync: PlaidSyncDb;
+
+  /**
+   * Handles the fetching and storing of new, modified, or removed transactions
+   * @param {number} tenantId Tenant ID.
+   * @param {string} plaidItemId the Plaid ID for the item.
+   */
+  public async updateTransactions(tenantId: number, plaidItemId: string) {
+    // Fetch new transactions from plaid api.
+    const { added, modified, removed, cursor, accessToken } =
+      await this.fetchTransactionUpdates(tenantId, plaidItemId);
+
+    const request = { access_token: accessToken };
+    const plaidInstance = new PlaidClientWrapper();
+    const {
+      data: { accounts, item },
+    } = await plaidInstance.accountsGet(request);
+
+    const plaidAccountsIds = accounts.map((a) => a.account_id);
+
+    const {
+      data: { institution },
+    } = await plaidInstance.institutionsGetById({
+      institution_id: item.institution_id,
+      country_codes: ['US', 'UK'],
+    });
+    // Update the DB.
+    await this.plaidSync.syncBankAccounts(tenantId, accounts, institution);
+    await this.plaidSync.syncAccountsTransactions(
+      tenantId,
+      added.concat(modified)
+    );
+    await this.plaidSync.syncRemoveTransactions(tenantId, removed);
+    await this.plaidSync.syncTransactionsCursor(tenantId, plaidItemId, cursor);
+
+    // Update the last feeds updated at of the updated accounts.
+    await this.plaidSync.updateLastFeedsUpdatedAt(tenantId, plaidAccountsIds);
+
+    // Turn on the accounts feeds flag.
+    await this.plaidSync.updateAccountsFeedsActive(tenantId, plaidAccountsIds);
+
+    return {
+      addedCount: added.length,
+      modifiedCount: modified.length,
+      removedCount: removed.length,
+    };
+  }
+
+  /**
+   * Fetches transactions from the `Plaid API` for a given item.
+   * @param {number} tenantId - Tenant ID.
+   * @param {string} plaidItemId - The Plaid ID for the item.
+   * @returns {Promise<PlaidFetchedTransactionsUpdates>}
+   */
+  private async fetchTransactionUpdates(
+    tenantId: number,
+    plaidItemId: string
+  ): Promise<PlaidFetchedTransactionsUpdates> {
+    // the transactions endpoint is paginated, so we may need to hit it multiple times to
+    // retrieve all available transactions.
+    const { PlaidItem } = this.tenancy.models(tenantId);
+
+    const plaidItem = await PlaidItem.query().findOne(
+      'plaidItemId',
+      plaidItemId
+    );
+    if (!plaidItem) {
+      throw new Error('The given Plaid item id is not found.');
+    }
+    const { plaidAccessToken, lastCursor } = plaidItem;
+    let cursor = lastCursor;
+
+    // New transaction updates since "cursor"
+    let added = [];
+    let modified = [];
+    // Removed transaction ids
+    let removed = [];
+    let hasMore = true;
+
+    const batchSize = 100;
+    try {
+      // Iterate through each page of new transaction updates for item
+      /* eslint-disable no-await-in-loop */
+      while (hasMore) {
+        const request = {
+          access_token: plaidAccessToken,
+          cursor: cursor,
+          count: batchSize,
+        };
+        const plaidInstance = new PlaidClientWrapper();
+        const response = await plaidInstance.transactionsSync(request);
+        const data = response.data;
+        // Add this page of results
+        added = added.concat(data.added);
+        modified = modified.concat(data.modified);
+        removed = removed.concat(data.removed);
+        hasMore = data.has_more;
+        // Update cursor to the next cursor
+        cursor = data.next_cursor;
+      }
+    } catch (err) {
+      console.error(`Error fetching transactions: ${err.message}`);
+      cursor = lastCursor;
+    }
+    return { added, modified, removed, cursor, accessToken: plaidAccessToken };
+  }
+}

packages/server/src/services/Banking/Plaid/PlaidWebhookTenantBootMiddleware.ts

@@ -0,0 +1,32 @@
+import { Request, Response, NextFunction } from 'express';
+import { SystemPlaidItem, Tenant } from '@/system/models';
+import tenantDependencyInjection from '@/api/middleware/TenantDependencyInjection';
+
+export const PlaidWebhookTenantBootMiddleware = async (
+  req: Request,
+  res: Response,
+  next: NextFunction
+) => {
+  const { item_id: plaidItemId } = req.body;
+  const plaidItem = await SystemPlaidItem.query().findOne({ plaidItemId });
+
+  const notFoundOrganization = () => {
+    return res.boom.unauthorized('Organization identication not found.', {
+      errors: [{ type: 'ORGANIZATION.ID.NOT.FOUND', code: 100 }],
+    });
+  };
+  // In case the given organization not found.
+  if (!plaidItem) {
+    return notFoundOrganization();
+  }
+  const tenant = await Tenant.query()
+    .findById(plaidItem.tenantId)
+    .withGraphFetched('metadata');
+
+  // When the given organization id not found on the system storage.
+  if (!tenant) {
+    return notFoundOrganization();
+  }
+  tenantDependencyInjection(req, tenant);
+  next();
+};

packages/server/src/services/Banking/Plaid/PlaidWebhooks.ts

@@ -0,0 +1,140 @@
+import { Inject, Service } from 'typedi';
+import { PlaidUpdateTransactions } from './PlaidUpdateTransactions';
+
+@Service()
+export class PlaidWebooks {
+  @Inject()
+  private updateTransactionsService: PlaidUpdateTransactions;
+
+  /**
+   * Listens to Plaid webhooks
+   * @param {number} tenantId - Tenant Id.
+   * @param {string} webhookType - Webhook type.
+   * @param {string} plaidItemId - Plaid item Id.
+   * @param {string} webhookCode - webhook code.
+   */
+  public async webhooks(
+    tenantId: number,
+    plaidItemId: string,
+    webhookType: string,
+    webhookCode: string
+  ): Promise<void> {
+    const _webhookType = webhookType.toLowerCase();
+
+    // There are five types of webhooks: AUTH, TRANSACTIONS, ITEM, INCOME, and ASSETS.
+    // @TODO implement handling for remaining webhook types.
+    const webhookHandlerMap = {
+      transactions: this.handleTransactionsWebooks.bind(this),
+      item: this.itemsHandler.bind(this),
+    };
+    const webhookHandler =
+      webhookHandlerMap[_webhookType] || this.unhandledWebhook;
+
+    await webhookHandler(tenantId, plaidItemId, webhookCode);
+  }
+
+  /**
+   * Handles all unhandled/not yet implemented webhook events.
+   * @param {string} webhookType
+   * @param {string} webhookCode
+   * @param {string} plaidItemId
+   */
+  private async unhandledWebhook(
+    webhookType: string,
+    webhookCode: string,
+    plaidItemId: string
+  ): Promise<void> {
+    console.log(
+      `UNHANDLED ${webhookType} WEBHOOK: ${webhookCode}: Plaid item id ${plaidItemId}: unhandled webhook type received.`
+    );
+  }
+
+  /**
+   * Logs to console and emits to socket
+   * @param {string} additionalInfo
+   * @param {string} webhookCode
+   * @param {string} plaidItemId
+   */
+  private serverLogAndEmitSocket(
+    additionalInfo: string,
+    webhookCode: string,
+    plaidItemId: string
+  ): void {
+    console.log(
+      `WEBHOOK: TRANSACTIONS: ${webhookCode}: Plaid_item_id ${plaidItemId}: ${additionalInfo}`
+    );
+  }
+
+  /**
+   * Handles all transaction webhook events. The transaction webhook notifies
+   * you that a single item has new transactions available.
+   * @param {number} tenantId
+   * @param {string} plaidItemId
+   * @param {string} webhookCode
+   * @returns {Promise<void>}
+   */
+  public async handleTransactionsWebooks(
+    tenantId: number,
+    plaidItemId: string,
+    webhookCode: string
+  ): Promise<void> {
+    switch (webhookCode) {
+      case 'SYNC_UPDATES_AVAILABLE': {
+        // Fired when new transactions data becomes available.
+        const { addedCount, modifiedCount, removedCount } =
+          await this.updateTransactionsService.updateTransactions(
+            tenantId,
+            plaidItemId
+          );
+        this.serverLogAndEmitSocket(
+          `Transactions: ${addedCount} added, ${modifiedCount} modified, ${removedCount} removed`,
+          webhookCode,
+          plaidItemId
+        );
+        break;
+      }
+      case 'DEFAULT_UPDATE':
+      case 'INITIAL_UPDATE':
+      case 'HISTORICAL_UPDATE':
+        /* ignore - not needed if using sync endpoint + webhook */
+        break;
+      default:
+        this.serverLogAndEmitSocket(
+          `unhandled webhook type received.`,
+          webhookCode,
+          plaidItemId
+        );
+    }
+  }
+
+  /**
+   * Handles all Item webhook events.
+   * @param {number} tenantId - Tenant ID
+   * @param {string} webhookCode - The webhook code
+   * @param {string} plaidItemId - The Plaid ID for the item
+   * @returns {Promise<void>}
+   */
+  public async itemsHandler(
+    tenantId: number,
+    plaidItemId: string,
+    webhookCode: string
+  ): Promise<void> {
+    switch (webhookCode) {
+      case 'WEBHOOK_UPDATE_ACKNOWLEDGED':
+        this.serverLogAndEmitSocket('is updated', plaidItemId, error);
+        break;
+      case 'ERROR': {
+        break;
+      }
+      case 'PENDING_EXPIRATION': {
+        break;
+      }
+      default:
+        this.serverLogAndEmitSocket(
+          'unhandled webhook type received.',
+          webhookCode,
+          plaidItemId
+        );
+    }
+  }
+}

packages/server/src/services/Banking/Plaid/subscribers/PlaidUpdateTransactionsOnItemCreatedSubscriber.ts

@@ -0,0 +1,34 @@
+import { Inject, Service } from 'typedi';
+import { EventSubscriber } from '@/lib/EventPublisher/EventPublisher';
+import { IPlaidItemCreatedEventPayload } from '@/interfaces/Plaid';
+import events from '@/subscribers/events';
+
+@Service()
+export class PlaidUpdateTransactionsOnItemCreatedSubscriber extends EventSubscriber {
+  @Inject('agenda')
+  private agenda: any;
+
+  /**
+   * Constructor method.
+   */
+  public attach(bus) {
+    bus.subscribe(
+      events.plaid.onItemCreated,
+      this.handleUpdateTransactionsOnItemCreated
+    );
+  }
+
+  /**
+   * Updates the Plaid item transactions
+   * @param {IPlaidItemCreatedEventPayload} payload - Event payload.
+   */
+  private handleUpdateTransactionsOnItemCreated = async ({
+    tenantId,
+    plaidItemId,
+    plaidAccessToken,
+    plaidInstitutionId,
+  }: IPlaidItemCreatedEventPayload) => {
+    const payload = { tenantId, plaidItemId };
+    await this.agenda.now('plaid-update-account-transactions', payload);
+  };
+}

packages/server/src/services/Banking/Plaid/utils.ts

@@ -0,0 +1,54 @@
+import * as R from 'ramda';
+import {
+  CreateUncategorizedTransactionDTO,
+  IAccountCreateDTO,
+  PlaidAccount,
+  PlaidTransaction,
+} from '@/interfaces';
+
+/**
+ * Transformes the Plaid account to create cashflow account DTO.
+ * @param {PlaidAccount} plaidAccount
+ * @returns {IAccountCreateDTO}
+ */
+export const transformPlaidAccountToCreateAccount = R.curry(
+  (institution: any, plaidAccount: PlaidAccount): IAccountCreateDTO => {
+    return {
+      name: `${institution.name} - ${plaidAccount.name}`,
+      code: '',
+      description: plaidAccount.official_name,
+      currencyCode: plaidAccount.balances.iso_currency_code,
+      accountType: 'cash',
+      active: true,
+      plaidAccountId: plaidAccount.account_id,
+      bankBalance: plaidAccount.balances.current,
+      accountMask: plaidAccount.mask,
+    };
+  }
+);
+
+/**
+ * Transformes the plaid transaction to cashflow create DTO.
+ * @param {number} cashflowAccountId - Cashflow account ID.
+ * @param {number} creditAccountId - Credit account ID.
+ * @param {PlaidTransaction} plaidTranasction - Plaid transaction.
+ * @returns {CreateUncategorizedTransactionDTO}
+ */
+export const transformPlaidTrxsToCashflowCreate = R.curry(
+  (
+    cashflowAccountId: number,
+    creditAccountId: number,
+    plaidTranasction: PlaidTransaction
+  ): CreateUncategorizedTransactionDTO => {
+    return {
+      date: plaidTranasction.date,
+      amount: plaidTranasction.amount,
+      description: plaidTranasction.name,
+      payee: plaidTranasction.payment_meta?.payee,
+      currencyCode: plaidTranasction.iso_currency_code,
+      accountId: cashflowAccountId,
+      referenceNo: plaidTranasction.payment_meta?.reference_number,
+      plaidTransactionId: plaidTranasction.transaction_id,
+    };
+  }
+);

packages/server/src/services/Cashflow/CashflowApplication.ts

@@ -0,0 +1,213 @@
+import { Inject, Service } from 'typedi';
+import { DeleteCashflowTransaction } from './DeleteCashflowTransactionService';
+import { UncategorizeCashflowTransaction } from './UncategorizeCashflowTransaction';
+import { CategorizeCashflowTransaction } from './CategorizeCashflowTransaction';
+import {
+  CategorizeTransactionAsExpenseDTO,
+  CreateUncategorizedTransactionDTO,
+  ICashflowAccountsFilter,
+  ICashflowNewCommandDTO,
+  ICategorizeCashflowTransactioDTO,
+  IGetUncategorizedTransactionsQuery,
+} from '@/interfaces';
+import { CategorizeTransactionAsExpense } from './CategorizeTransactionAsExpense';
+import { GetUncategorizedTransactions } from './GetUncategorizedTransactions';
+import { CreateUncategorizedTransaction } from './CreateUncategorizedTransaction';
+import { GetUncategorizedTransaction } from './GetUncategorizedTransaction';
+import NewCashflowTransactionService from './NewCashflowTransactionService';
+import GetCashflowAccountsService from './GetCashflowAccountsService';
+import { GetCashflowTransactionService } from './GetCashflowTransactionsService';
+
+@Service()
+export class CashflowApplication {
+  @Inject()
+  private createTransactionService: NewCashflowTransactionService;
+
+  @Inject()
+  private deleteTransactionService: DeleteCashflowTransaction;
+
+  @Inject()
+  private getCashflowAccountsService: GetCashflowAccountsService;
+
+  @Inject()
+  private getCashflowTransactionService: GetCashflowTransactionService;
+
+  @Inject()
+  private uncategorizeTransactionService: UncategorizeCashflowTransaction;
+
+  @Inject()
+  private categorizeTransactionService: CategorizeCashflowTransaction;
+
+  @Inject()
+  private categorizeAsExpenseService: CategorizeTransactionAsExpense;
+
+  @Inject()
+  private getUncategorizedTransactionsService: GetUncategorizedTransactions;
+
+  @Inject()
+  private getUncategorizedTransactionService: GetUncategorizedTransaction;
+
+  @Inject()
+  private createUncategorizedTransactionService: CreateUncategorizedTransaction;
+
+  /**
+   * Creates a new cashflow transaction.
+   * @param {number} tenantId
+   * @param {ICashflowNewCommandDTO} transactionDTO
+   * @param {number} userId
+   * @returns
+   */
+  public createTransaction(
+    tenantId: number,
+    transactionDTO: ICashflowNewCommandDTO,
+    userId?: number
+  ) {
+    return this.createTransactionService.newCashflowTransaction(
+      tenantId,
+      transactionDTO,
+      userId
+    );
+  }
+
+  /**
+   * Deletes the given cashflow transaction.
+   * @param {number} tenantId
+   * @param {number} cashflowTransactionId
+   * @returns
+   */
+  public deleteTransaction(tenantId: number, cashflowTransactionId: number) {
+    return this.deleteTransactionService.deleteCashflowTransaction(
+      tenantId,
+      cashflowTransactionId
+    );
+  }
+
+  /**
+   * Retrieves specific cashflow transaction.
+   * @param {number} tenantId
+   * @param {number} cashflowTransactionId
+   * @returns
+   */
+  public getTransaction(tenantId: number, cashflowTransactionId: number) {
+    return this.getCashflowTransactionService.getCashflowTransaction(
+      tenantId,
+      cashflowTransactionId
+    );
+  }
+
+  /**
+   * Retrieves the cashflow accounts.
+   * @param {number} tenantId
+   * @param {ICashflowAccountsFilter} filterDTO
+   * @returns
+   */
+  public getCashflowAccounts(
+    tenantId: number,
+    filterDTO: ICashflowAccountsFilter
+  ) {
+    return this.getCashflowAccountsService.getCashflowAccounts(
+      tenantId,
+      filterDTO
+    );
+  }
+
+  /**
+   * Creates a new uncategorized cash transaction.
+   * @param {number} tenantId
+   * @param {CreateUncategorizedTransactionDTO} createUncategorizedTransactionDTO
+   * @returns {IUncategorizedCashflowTransaction}
+   */
+  public createUncategorizedTransaction(
+    tenantId: number,
+    createUncategorizedTransactionDTO: CreateUncategorizedTransactionDTO
+  ) {
+    return this.createUncategorizedTransactionService.create(
+      tenantId,
+      createUncategorizedTransactionDTO
+    );
+  }
+
+  /**
+   * Uncategorize the given cashflow transaction.
+   * @param {number} tenantId
+   * @param {number} cashflowTransactionId
+   * @returns
+   */
+  public uncategorizeTransaction(
+    tenantId: number,
+    cashflowTransactionId: number
+  ) {
+    return this.uncategorizeTransactionService.uncategorize(
+      tenantId,
+      cashflowTransactionId
+    );
+  }
+
+  /**
+   * Categorize the given cashflow transaction.
+   * @param {number} tenantId
+   * @param {number} cashflowTransactionId
+   * @param {ICategorizeCashflowTransactioDTO} categorizeDTO
+   * @returns
+   */
+  public categorizeTransaction(
+    tenantId: number,
+    cashflowTransactionId: number,
+    categorizeDTO: ICategorizeCashflowTransactioDTO
+  ) {
+    return this.categorizeTransactionService.categorize(
+      tenantId,
+      cashflowTransactionId,
+      categorizeDTO
+    );
+  }
+
+  /**
+   * Categorizes the given cashflow transaction as expense transaction.
+   * @param {number} tenantId
+   * @param {number} cashflowTransactionId
+   * @param {CategorizeTransactionAsExpenseDTO} transactionDTO
+   */
+  public categorizeAsExpense(
+    tenantId: number,
+    cashflowTransactionId: number,
+    transactionDTO: CategorizeTransactionAsExpenseDTO
+  ) {
+    return this.categorizeAsExpenseService.categorize(
+      tenantId,
+      cashflowTransactionId,
+      transactionDTO
+    );
+  }
+
+  /**
+   * Retrieves the uncategorized cashflow transactions.
+   * @param {number} tenantId
+   */
+  public getUncategorizedTransactions(
+    tenantId: number,
+    accountId: number,
+    query: IGetUncategorizedTransactionsQuery
+  ) {
+    return this.getUncategorizedTransactionsService.getTransactions(
+      tenantId,
+      accountId,
+      query
+    );
+  }
+
+  /**
+   * Retrieves specific uncategorized transaction.
+   * @param {number} tenantId
+   * @param {number} uncategorizedTransactionId
+   */
+  public getUncategorizedTransaction(
+    tenantId: number,
+    uncategorizedTransactionId: number
+  ) {
+    return this.getUncategorizedTransactionService.getTransaction(
+      tenantId,
+      uncategorizedTransactionId
+    );
+  }
+}

packages/server/src/services/Cashflow/CashflowTransactionJournalEntries.ts

@@ -1,11 +1,9 @@
 import { Inject, Service } from 'typedi';
 import { Knex } from 'knex';
-import * as R from 'ramda';
 import {
   ILedgerEntry,
   ICashflowTransaction,
   AccountNormal,
-  ICashflowTransactionLine,
 } from '../../interfaces';
 import {
   transformCashflowTransactionType,

packages/server/src/services/Cashflow/CategorizeCashflowTransaction.ts

@@ -0,0 +1,101 @@
+import { Inject, Service } from 'typedi';
+import HasTenancyService from '../Tenancy/TenancyService';
+import events from '@/subscribers/events';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import UnitOfWork from '../UnitOfWork';
+import {
+  ICashflowTransactionCategorizedPayload,
+  ICashflowTransactionUncategorizingPayload,
+  ICategorizeCashflowTransactioDTO,
+} from '@/interfaces';
+import { Knex } from 'knex';
+import { transformCategorizeTransToCashflow } from './utils';
+import { CommandCashflowValidator } from './CommandCasflowValidator';
+import NewCashflowTransactionService from './NewCashflowTransactionService';
+import { TransferAuthorizationGuaranteeDecision } from 'plaid';
+
+@Service()
+export class CategorizeCashflowTransaction {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private commandValidators: CommandCashflowValidator;
+
+  @Inject()
+  private createCashflow: NewCashflowTransactionService;
+
+  /**
+   * Categorize the given cashflow transaction.
+   * @param {number} tenantId
+   * @param {ICategorizeCashflowTransactioDTO} categorizeDTO
+   */
+  public async categorize(
+    tenantId: number,
+    uncategorizedTransactionId: number,
+    categorizeDTO: ICategorizeCashflowTransactioDTO
+  ) {
+    const { UncategorizedCashflowTransaction } = this.tenancy.models(tenantId);
+
+    // Retrieves the uncategorized transaction or throw an error.
+    const transaction = await UncategorizedCashflowTransaction.query()
+      .findById(uncategorizedTransactionId)
+      .throwIfNotFound();
+
+    // Validates the transaction shouldn't be categorized before.
+    this.commandValidators.validateTransactionShouldNotCategorized(transaction);
+
+    // Validate the uncateogirzed transaction if it's deposit the transaction direction
+    // should `IN` and the same thing if it's withdrawal the direction should be OUT.
+    this.commandValidators.validateUncategorizeTransactionType(
+      transaction,
+      categorizeDTO.transactionType
+    );
+    // Edits the cashflow transaction under UOW env.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onTransactionCategorizing` event.
+      await this.eventPublisher.emitAsync(
+        events.cashflow.onTransactionCategorizing,
+        {
+          tenantId,
+          trx,
+        } as ICashflowTransactionUncategorizingPayload
+      );
+      // Transformes the categorize DTO to the cashflow transaction.
+      const cashflowTransactionDTO = transformCategorizeTransToCashflow(
+        transaction,
+        categorizeDTO
+      );
+      // Creates a new cashflow transaction.
+      const cashflowTransaction =
+        await this.createCashflow.newCashflowTransaction(
+          tenantId,
+          cashflowTransactionDTO
+        );
+      // Updates the uncategorized transaction as categorized.
+      await UncategorizedCashflowTransaction.query(trx).patchAndFetchById(
+        uncategorizedTransactionId,
+        {
+          categorized: true,
+          categorizeRefType: 'CashflowTransaction',
+          categorizeRefId: cashflowTransaction.id,
+        }
+      );
+      // Triggers `onCashflowTransactionCategorized` event.
+      await this.eventPublisher.emitAsync(
+        events.cashflow.onTransactionCategorized,
+        {
+          tenantId,
+          // cashflowTransaction,
+          trx,
+        } as ICashflowTransactionCategorizedPayload
+      );
+    });
+  }
+}

packages/server/src/services/Cashflow/CategorizeTransactionAsExpense.ts

@@ -0,0 +1,80 @@
+import {
+  CategorizeTransactionAsExpenseDTO,
+  ICashflowTransactionCategorizedPayload,
+} from '@/interfaces';
+import { Inject, Service } from 'typedi';
+import UnitOfWork from '../UnitOfWork';
+import events from '@/subscribers/events';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import HasTenancyService from '../Tenancy/TenancyService';
+import { Knex } from 'knex';
+import { CreateExpense } from '../Expenses/CRUD/CreateExpense';
+
+@Service()
+export class CategorizeTransactionAsExpense {
+  @Inject()
+  private uow: UnitOfWork;
+
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private createExpenseService: CreateExpense;
+
+  /**
+   * Categorize the transaction as expense transaction.
+   * @param {number} tenantId
+   * @param {number} cashflowTransactionId
+   * @param {CategorizeTransactionAsExpenseDTO} transactionDTO
+   */
+  public async categorize(
+    tenantId: number,
+    cashflowTransactionId: number,
+    transactionDTO: CategorizeTransactionAsExpenseDTO
+  ) {
+    const { CashflowTransaction } = this.tenancy.models(tenantId);
+
+    const transaction = await CashflowTransaction.query()
+      .findById(cashflowTransactionId)
+      .throwIfNotFound();
+
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onTransactionUncategorizing` event.
+      await this.eventPublisher.emitAsync(
+        events.cashflow.onTransactionCategorizingAsExpense,
+        {
+          tenantId,
+          trx,
+        } as ICashflowTransactionCategorizedPayload
+      );
+      // Creates a new expense transaction.
+      const expenseTransaction = await this.createExpenseService.newExpense(
+        tenantId,
+        {
+          
+        },
+        1
+      );
+      // Updates the item on the storage and fetches the updated once.
+      const cashflowTransaction = await CashflowTransaction.query(
+        trx
+      ).patchAndFetchById(cashflowTransactionId, {
+        categorizeRefType: 'Expense',
+        categorizeRefId: expenseTransaction.id,
+        uncategorized: true,
+      });
+      // Triggers `onTransactionUncategorized` event.
+      await this.eventPublisher.emitAsync(
+        events.cashflow.onTransactionCategorizedAsExpense,
+        {
+          tenantId,
+          cashflowTransaction,
+          trx,
+        } as ICashflowTransactionUncategorizedPayload
+      );
+    });
+  }
+}

packages/server/src/services/Cashflow/CommandCasflowValidator.ts

@@ -1,9 +1,14 @@
 import { Service } from 'typedi';
 import { includes, camelCase, upperFirst } from 'lodash';
-import { IAccount } from '@/interfaces';
+import { IAccount, IUncategorizedCashflowTransaction } from '@/interfaces';
 import { getCashflowTransactionType } from './utils';
 import { ServiceError } from '@/exceptions';
-import { CASHFLOW_TRANSACTION_TYPE, ERRORS } from './constants';
+import {
+  CASHFLOW_DIRECTION,
+  CASHFLOW_TRANSACTION_TYPE,
+  ERRORS,
+} from './constants';
+import CashflowTransaction from '@/models/CashflowTransaction';
 
 @Service()
 export class CommandCashflowValidator {
@@ -46,4 +51,52 @@ export class CommandCashflowValidator {
     }
     return transformedType;
   };
+
+  /**
+   * Validate the given transaction should be categorized.
+   * @param {CashflowTransaction} cashflowTransaction
+   */
+  public validateTransactionShouldCategorized(
+    cashflowTransaction: CashflowTransaction
+  ) {
+    if (!cashflowTransaction.uncategorize) {
+      throw new ServiceError(ERRORS.TRANSACTION_ALREADY_CATEGORIZED);
+    }
+  }
+
+  /**
+   * Validate the given transcation shouldn't be categorized.
+   * @param {CashflowTransaction} cashflowTransaction
+   */
+  public validateTransactionShouldNotCategorized(
+    cashflowTransaction: CashflowTransaction
+  ) {
+    if (cashflowTransaction.uncategorize) {
+      throw new ServiceError(ERRORS.TRANSACTION_ALREADY_CATEGORIZED);
+    }
+  }
+
+  /**
+   *
+   * @param {uncategorizeTransaction}
+   * @param {string} transactionType
+   * @throws {ServiceError(ERRORS.UNCATEGORIZED_TRANSACTION_TYPE_INVALID)}
+   */
+  public validateUncategorizeTransactionType(
+    uncategorizeTransaction: IUncategorizedCashflowTransaction,
+    transactionType: string
+  ) {
+    const type = getCashflowTransactionType(
+      upperFirst(camelCase(transactionType)) as CASHFLOW_TRANSACTION_TYPE
+    );
+    if (
+      (type.direction === CASHFLOW_DIRECTION.IN &&
+        uncategorizeTransaction.isDepositTransaction) ||
+      (type.direction === CASHFLOW_DIRECTION.OUT &&
+        uncategorizeTransaction.isWithdrawalTransaction)
+    ) {
+      return;
+    }
+    throw new ServiceError(ERRORS.UNCATEGORIZED_TRANSACTION_TYPE_INVALID);
+  }
 }

packages/server/src/services/Cashflow/CreateUncategorizedTransaction.ts

@@ -0,0 +1,40 @@
+import { Inject, Service } from 'typedi';
+import HasTenancyService from '../Tenancy/TenancyService';
+import UnitOfWork, { IsolationLevel } from '../UnitOfWork';
+import { Knex } from 'knex';
+import { CreateUncategorizedTransactionDTO } from '@/interfaces';
+
+@Service()
+export class CreateUncategorizedTransaction {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  /**
+   * Creates an uncategorized cashflow transaction.
+   * @param {number} tenantId
+   * @param {CreateUncategorizedTransactionDTO} createDTO
+   */
+  public create(
+    tenantId: number,
+    createDTO: CreateUncategorizedTransactionDTO
+  ) {
+    const { UncategorizedCashflowTransaction, Account } =
+      this.tenancy.models(tenantId);
+
+    return this.uow.withTransaction(
+      tenantId,
+      async (trx: Knex.Transaction) => {
+        const transaction = await UncategorizedCashflowTransaction.query(
+          trx
+        ).insertAndFetch({
+          ...createDTO,
+        });
+        
+        return transaction;
+      },
+    );
+  }
+}

packages/server/src/services/Cashflow/DeleteCashflowTransactionService.ts

@@ -13,15 +13,15 @@ import UnitOfWork from '@/services/UnitOfWork';
 import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
 
 @Service()
-export default class CommandCashflowTransactionService {
+export class DeleteCashflowTransaction {
   @Inject()
-  tenancy: HasTenancyService;
+  private tenancy: HasTenancyService;
 
   @Inject()
-  eventPublisher: EventPublisher;
+  private eventPublisher: EventPublisher;
 
   @Inject()
-  uow: UnitOfWork;
+  private uow: UnitOfWork;
 
   /**
    * Deletes the cashflow transaction with associated journal entries.

packages/server/src/services/Cashflow/GetCashflowTransactionsService.ts

@@ -4,17 +4,13 @@ import { CashflowTransactionTransformer } from './CashflowTransactionTransformer
 import { ERRORS } from './constants';
 import { ICashflowTransaction } from '@/interfaces';
 import { ServiceError } from '@/exceptions';
-import I18nService from '@/services/I18n/I18nService';
 import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
 
 @Service()
-export default class GetCashflowTransactionsService {
+export class GetCashflowTransactionService {
   @Inject()
   private tenancy: HasTenancyService;
 
-  @Inject()
-  private i18nService: I18nService;
-
   @Inject()
   private transfromer: TransformerInjectable;
 
@@ -35,6 +31,7 @@ export default class GetCashflowTransactionsService {
       .withGraphFetched('entries.cashflowAccount')
       .withGraphFetched('entries.creditAccount')
       .withGraphFetched('transactions.account')
+      .orderBy('date', 'DESC')
       .throwIfNotFound();
 
     this.throwErrorCashflowTranscationNotFound(cashflowTransaction);

packages/server/src/services/Cashflow/GetUncategorizedTransaction.ts

@@ -0,0 +1,36 @@
+import { Inject, Service } from 'typedi';
+import HasTenancyService from '../Tenancy/TenancyService';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+import { UncategorizedTransactionTransformer } from './UncategorizedTransactionTransformer';
+
+@Service()
+export class GetUncategorizedTransaction {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Retrieves specific uncategorized cashflow transaction.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} uncategorizedTransactionId - Uncategorized transaction id.
+   */
+  public async getTransaction(
+    tenantId: number,
+    uncategorizedTransactionId: number
+  ) {
+    const { UncategorizedCashflowTransaction } = this.tenancy.models(tenantId);
+
+    const transaction = await UncategorizedCashflowTransaction.query()
+      .findById(uncategorizedTransactionId)
+      .withGraphFetched('account')
+      .throwIfNotFound();
+
+    return this.transformer.transform(
+      tenantId,
+      transaction,
+      new UncategorizedTransactionTransformer()
+    );
+  }
+}

packages/server/src/services/Cashflow/GetUncategorizedTransactions.ts

@@ -0,0 +1,51 @@
+import { Inject, Service } from 'typedi';
+import HasTenancyService from '../Tenancy/TenancyService';
+import { TransformerInjectable } from '@/lib/Transformer/TransformerInjectable';
+import { UncategorizedTransactionTransformer } from './UncategorizedTransactionTransformer';
+import { IGetUncategorizedTransactionsQuery } from '@/interfaces';
+
+@Service()
+export class GetUncategorizedTransactions {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private transformer: TransformerInjectable;
+
+  /**
+   * Retrieves the uncategorized cashflow transactions.
+   * @param {number} tenantId - Tenant id.
+   * @param {number} accountId - Account Id.
+   */
+  public async getTransactions(
+    tenantId: number,
+    accountId: number,
+    query: IGetUncategorizedTransactionsQuery
+  ) {
+    const { UncategorizedCashflowTransaction } = this.tenancy.models(tenantId);
+
+    // Parsed query with default values.
+    const _query = {
+      page: 1,
+      pageSize: 20,
+      ...query,
+    };
+    const { results, pagination } =
+      await UncategorizedCashflowTransaction.query()
+        .where('accountId', accountId)
+        .where('categorized', false)
+        .withGraphFetched('account')
+        .orderBy('date', 'DESC')
+        .pagination(_query.page - 1, _query.pageSize);
+
+    const data = await this.transformer.transform(
+      tenantId,
+      results,
+      new UncategorizedTransactionTransformer()
+    );
+    return {
+      data,
+      pagination,
+    };
+  }
+}

packages/server/src/services/Cashflow/NewCashflowTransactionService.ts

@@ -1,11 +1,10 @@
 import { Service, Inject } from 'typedi';
-import { isEmpty, pick } from 'lodash';
+import { pick } from 'lodash';
 import { Knex } from 'knex';
 import * as R from 'ramda';
 import {
   ICashflowNewCommandDTO,
   ICashflowTransaction,
-  ICashflowTransactionLine,
   ICommandCashflowCreatedPayload,
   ICommandCashflowCreatingPayload,
   ICashflowTransactionInput,
@@ -86,6 +85,7 @@ export default class NewCashflowTransactionService {
       'cashflowAccountId',
       'creditAccountId',
       'branchId',
+      'plaidTransactionId',
     ]);
     // Retreive the next invoice number.
     const autoNextNumber =
@@ -124,8 +124,8 @@ export default class NewCashflowTransactionService {
   public newCashflowTransaction = async (
     tenantId: number,
     newTransactionDTO: ICashflowNewCommandDTO,
-    userId: number
-  ): Promise<{ cashflowTransaction: ICashflowTransaction }> => {
+    userId?: number
+  ): Promise<ICashflowTransaction> => {
     const { CashflowTransaction, Account } = this.tenancy.models(tenantId);
 
     // Retrieves the cashflow account or throw not found error.
@@ -174,7 +174,7 @@ export default class NewCashflowTransactionService {
           trx,
         } as ICommandCashflowCreatedPayload
       );
-      return { cashflowTransaction };
+      return cashflowTransaction;
     });
   };
 }

packages/server/src/services/Cashflow/UncategorizeCashflowTransaction.ts

@@ -0,0 +1,72 @@
+import { Knex } from 'knex';
+import { Inject, Service } from 'typedi';
+import HasTenancyService from '../Tenancy/TenancyService';
+import UnitOfWork from '../UnitOfWork';
+import events from '@/subscribers/events';
+import { EventPublisher } from '@/lib/EventPublisher/EventPublisher';
+import {
+  ICashflowTransactionUncategorizedPayload,
+  ICashflowTransactionUncategorizingPayload,
+} from '@/interfaces';
+
+@Service()
+export class UncategorizeCashflowTransaction {
+  @Inject()
+  private tenancy: HasTenancyService;
+
+  @Inject()
+  private eventPublisher: EventPublisher;
+
+  @Inject()
+  private uow: UnitOfWork;
+
+  /**
+   * Uncategorizes the given cashflow transaction.
+   * @param {number} tenantId
+   * @param {number} cashflowTransactionId
+   */
+  public async uncategorize(
+    tenantId: number,
+    uncategorizedTransactionId: number
+  ) {
+    const { UncategorizedCashflowTransaction } = this.tenancy.models(tenantId);
+
+    const oldUncategorizedTransaction =
+      await UncategorizedCashflowTransaction.query()
+        .findById(uncategorizedTransactionId)
+        .throwIfNotFound();
+
+    // Updates the transaction under UOW.
+    return this.uow.withTransaction(tenantId, async (trx: Knex.Transaction) => {
+      // Triggers `onTransactionUncategorizing` event.
+      await this.eventPublisher.emitAsync(
+        events.cashflow.onTransactionUncategorizing,
+        {
+          tenantId,
+          trx,
+        } as ICashflowTransactionUncategorizingPayload
+      );
+      // Removes the ref relation with the related transaction.
+      const uncategorizedTransaction =
+        await UncategorizedCashflowTransaction.query(trx).updateAndFetchById(
+          uncategorizedTransactionId,
+          {
+            categorized: false,
+            categorizeRefId: null,
+            categorizeRefType: null,
+          }
+        );
+      // Triggers `onTransactionUncategorized` event.
+      await this.eventPublisher.emitAsync(
+        events.cashflow.onTransactionUncategorized,
+        {
+          tenantId,
+          uncategorizedTransaction,
+          oldUncategorizedTransaction,
+          trx,
+        } as ICashflowTransactionUncategorizedPayload
+      );
+      return uncategorizedTransaction;
+    });
+  }
+}

packages/server/src/services/Cashflow/UncategorizedTransactionTransformer.ts

@@ -0,0 +1,65 @@
+import { Transformer } from '@/lib/Transformer/Transformer';
+import { formatNumber } from '@/utils';
+
+export class UncategorizedTransactionTransformer extends Transformer {
+  /**
+   * Include these attributes to sale invoice object.
+   * @returns {string[]}
+   */
+  public includeAttributes = (): string[] => {
+    return [
+      'formattedAmount',
+      'formattedDate',
+      'formattetDepositAmount',
+      'formattedWithdrawalAmount',
+    ];
+  };
+
+  /**
+   * Formattes the transaction date.
+   * @param transaction
+   * @returns {string}
+   */
+  public formattedDate(transaction) {
+    return this.formatDate(transaction.date);
+  }
+
+  /**
+   * Formatted amount.
+   * @param transaction 
+   * @returns {string}
+   */
+  public formattedAmount(transaction) {
+    return formatNumber(transaction.amount, {
+      currencyCode: transaction.currencyCode,
+    });
+  }
+
+  /**
+   * Formatted deposit amount.
+   * @param transaction
+   * @returns {string}
+   */
+  protected formattetDepositAmount(transaction) {
+    if (transaction.isDepositTransaction) {
+      return formatNumber(transaction.deposit, {
+        currencyCode: transaction.currencyCode,
+      });
+    }
+    return '';
+  }
+
+  /**
+   * Formatted withdrawal amount.
+   * @param transaction
+   * @returns {string}
+   */
+  protected formattedWithdrawalAmount(transaction) {
+    if (transaction.isWithdrawalTransaction) {
+      return formatNumber(transaction.withdrawal, {
+        currencyCode: transaction.currencyCode,
+      });
+    }
+    return '';
+  }
+}

packages/server/src/services/Cashflow/constants.ts

@@ -8,7 +8,10 @@ export const ERRORS = {
   CREDIT_ACCOUNTS_IDS_NOT_FOUND: 'CREDIT_ACCOUNTS_IDS_NOT_FOUND',
   CREDIT_ACCOUNTS_HAS_INVALID_TYPE: 'CREDIT_ACCOUNTS_HAS_INVALID_TYPE',
   ACCOUNT_ID_HAS_INVALID_TYPE: 'ACCOUNT_ID_HAS_INVALID_TYPE',
-  ACCOUNT_HAS_ASSOCIATED_TRANSACTIONS: 'account_has_associated_transactions'
+  ACCOUNT_HAS_ASSOCIATED_TRANSACTIONS: 'account_has_associated_transactions',
+  TRANSACTION_ALREADY_CATEGORIZED: 'TRANSACTION_ALREADY_CATEGORIZED',
+  TRANSACTION_ALREADY_UNCATEGORIZED: 'TRANSACTION_ALREADY_UNCATEGORIZED',
+  UNCATEGORIZED_TRANSACTION_TYPE_INVALID: 'UNCATEGORIZED_TRANSACTION_TYPE_INVALID'
 };
 
 export enum CASHFLOW_DIRECTION {

packages/server/src/services/Cashflow/subscribers/DeleteCashflowTransactionOnUncategorize.ts

@@ -0,0 +1,40 @@
+import { Inject, Service } from 'typedi';
+import events from '@/subscribers/events';
+import { ICashflowTransactionUncategorizedPayload } from '@/interfaces';
+import { DeleteCashflowTransaction } from '../DeleteCashflowTransactionService';
+
+@Service()
+export class DeleteCashflowTransactionOnUncategorize {
+  @Inject()
+  private deleteCashflowTransactionService: DeleteCashflowTransaction;
+
+  /**
+   * Attaches events with handlers.
+   */
+  public attach = (bus) => {
+    bus.subscribe(
+      events.cashflow.onTransactionUncategorized,
+      this.deleteCashflowTransactionOnUncategorize.bind(this)
+    );
+  };
+
+  /**
+   * Deletes the cashflow transaction on uncategorize transaction.
+   * @param {ICashflowTransactionUncategorizedPayload} payload
+   */
+  public async deleteCashflowTransactionOnUncategorize({
+    tenantId,
+    oldUncategorizedTransaction,
+    trx,
+  }: ICashflowTransactionUncategorizedPayload) {
+    // Deletes the cashflow transaction.
+    if (
+      oldUncategorizedTransaction.categorizeRefType === 'CashflowTransaction'
+    ) {
+      await this.deleteCashflowTransactionService.deleteCashflowTransaction(
+        tenantId,
+        oldUncategorizedTransaction.categorizeRefId
+      );
+    }
+  }
+}

packages/server/src/services/Cashflow/utils.ts

@@ -1,13 +1,19 @@
-import { upperFirst, camelCase } from 'lodash';
+import { upperFirst, camelCase, omit } from 'lodash';
 import {
   CASHFLOW_TRANSACTION_TYPE,
   CASHFLOW_TRANSACTION_TYPE_META,
   ICashflowTransactionTypeMeta,
 } from './constants';
+import {
+  ICashflowNewCommandDTO,
+  ICashflowTransaction,
+  ICategorizeCashflowTransactioDTO,
+  IUncategorizedCashflowTransaction,
+} from '@/interfaces';
 
 /**
  * Ensures the given transaction type to transformed to appropriate format.
- * @param {string} type 
+ * @param {string} type
  * @returns {string}
  */
 export const transformCashflowTransactionType = (type) => {
@@ -32,3 +38,29 @@ export function getCashflowTransactionType(
 export const getCashflowAccountTransactionsTypes = () => {
   return Object.values(CASHFLOW_TRANSACTION_TYPE_META).map((meta) => meta.type);
 };
+
+/**
+ * Tranasformes the given uncategorized transaction and categorized DTO
+ * to cashflow create DTO.
+ * @param {IUncategorizedCashflowTransaction} uncategorizeModel 
+ * @param {ICategorizeCashflowTransactioDTO} categorizeDTO 
+ * @returns {ICashflowNewCommandDTO}
+ */
+export const transformCategorizeTransToCashflow = (
+  uncategorizeModel: IUncategorizedCashflowTransaction,
+  categorizeDTO: ICategorizeCashflowTransactioDTO
+): ICashflowNewCommandDTO => {
+  return {
+    date: uncategorizeModel.date,
+    referenceNo: categorizeDTO.referenceNo || uncategorizeModel.referenceNo,
+    description: categorizeDTO.description || uncategorizeModel.description,
+    cashflowAccountId: uncategorizeModel.accountId,
+    creditAccountId: categorizeDTO.creditAccountId,
+    exchangeRate: categorizeDTO.exchangeRate || 1,
+    currencyCode: uncategorizeModel.currencyCode,
+    amount: uncategorizeModel.amount,
+    transactionNumber: categorizeDTO.transactionNumber,
+    transactionType: categorizeDTO.transactionType,
+    publish: true,
+  };
+};

packages/server/src/services/FinancialStatements/AgingSummary/AgingSummaryTable.ts

@@ -56,7 +56,7 @@ export default abstract class AgingSummaryTable extends R.compose(
     node: IAgingSummaryContact | IAgingSummaryTotal
   ): ITableColumnAccessor[] => {
     return node.aging.map((aging, index) => ({
-      key: 'aging',
+      key: 'aging_period',
       accessor: `aging[${index}].total.formattedAmount`,
     }));
   };

packages/server/src/services/FinancialStatements/AgingSummary/_constants.ts

@@ -5,8 +5,17 @@ export enum AgingSummaryRowType {
 
 export const HtmlTableCss = `
 table tr.row-type--total td{
-  font-weight: 500;
+  font-weight: 600;
   border-top: 1px solid #bbb;
   border-bottom: 3px double #333;
 }
+
+table .column--current,
+table .column--aging_period,
+table .column--total,
+table .cell--current,
+table .cell--aging_period,
+table .cell--total  {
+  text-align: right;
+}
 `;

packages/server/src/services/FinancialStatements/CustomerBalanceSummary/CustomerBalanceSummaryTableInjectable.ts

@@ -25,19 +25,18 @@ export class CustomerBalanceSummaryTableInjectable {
     tenantId: number,
     filter: ICustomerBalanceSummaryQuery
   ): Promise<ICustomerBalanceSummaryTable> {
-    
     const i18n = this.tenancy.i18n(tenantId);
     const { data, query, meta } =
       await this.customerBalanceSummaryService.customerBalanceSummary(
         tenantId,
         filter
       );
-    const tableRows = new CustomerBalanceSummaryTable(data, filter, i18n);
+    const table = new CustomerBalanceSummaryTable(data, filter, i18n);
 
     return {
       table: {
-        columns: tableRows.tableColumns(),
-        rows: tableRows.tableRows(),
+        columns: table.tableColumns(),
+        rows: table.tableRows(),
       },
       query,
       meta,

packages/server/src/services/FinancialStatements/CustomerBalanceSummary/CustomerBalanceSummaryTableRows.ts

@@ -52,7 +52,7 @@ export class CustomerBalanceSummaryTable {
    */
   private getCustomerColumnsAccessor = (): IColumnMapperMeta[] => {
     const columns = [
-      { key: 'customerName', accessor: 'customerName' },
+      { key: 'name', accessor: 'customerName' },
       { key: 'total', accessor: 'total.formattedAmount' },
     ];
     return R.compose(
@@ -85,7 +85,7 @@ export class CustomerBalanceSummaryTable {
    */
   private getTotalColumnsAccessor = (): IColumnMapperMeta[] => {
     const columns = [
-      { key: 'total', value: this.i18n.__('Total') },
+      { key: 'name', value: this.i18n.__('Total') },
       { key: 'total', accessor: 'total.formattedAmount' },
     ];
     return R.compose(

packages/server/src/services/FinancialStatements/CustomerBalanceSummary/constants.ts

@@ -3,4 +3,12 @@ table tr.row-type--total td {
   font-weight: 600;
   border-top: 1px solid #bbb;
   border-bottom: 3px double #333;
-}`;
+}
+table .column--name {
+  width: 65%;
+}
+table .column--total,
+table .cell--total {
+  text-align: right;
+}
+`;

packages/server/src/services/FinancialStatements/GeneralLedger/constants.ts

@@ -10,4 +10,20 @@ table tr.row-type--closing-balance td{
 table tr.row-type--closing-balance td {
   border-bottom: 1px solid #ececec; 
 }
-`;
+
+table .column--debit,
+table .column--credit,
+table .column--amount,
+table .column--running_balance,
+table .cell--debit,
+table .cell--credit,
+table .cell--amount,
+table .cell--running_balance{
+  text-align: right;
+}
+table tr.row-type--account .cell--date span,
+table tr.row-type--opening-balance .cell--account_name span,
+table tr.row-type--closing-balance .cell--account_name span{
+  white-space: nowrap;
+}
+`;

packages/server/src/services/FinancialStatements/SalesTaxLiabilitySummary/SalesTaxLiabilitySummaryApplication.ts

@@ -75,6 +75,6 @@ export class SalesTaxLiabilitySummaryApplication {
     tenantId: number,
     query: SalesTaxLiabilitySummaryQuery
   ): Promise<Buffer> {
-    return this.salesTaxLiabiltiyPdf.pdf(tenantId, query):
+    return this.salesTaxLiabiltiyPdf.pdf(tenantId, query);
   }
 }

packages/server/src/services/FinancialStatements/TransactionsByVendor/TransactionsByVendorMeta.ts

@@ -25,9 +25,11 @@ export class TransactionsByVendorMeta {
     const formattedFromDate = moment(query.fromDate).format('YYYY/MM/DD');
     const formattedDateRange = `From ${formattedFromDate} | To ${formattedToDate}`;
 
+    const sheetName = 'Transactions By Vendor';
+
     return {
       ...commonMeta,
-      sheetName: 'Transactions By Vendor',
+      sheetName,
       formattedFromDate,
       formattedToDate,
       formattedDateRange,

packages/server/src/services/FinancialStatements/TransactionsByVendor/TransactionsByVendorPdf.ts

@@ -2,6 +2,7 @@ import { Inject, Service } from 'typedi';
 import { ITransactionsByVendorsFilter } from '@/interfaces';
 import { TableSheetPdf } from '../TableSheetPdf';
 import { TransactionsByVendorTableInjectable } from './TransactionsByVendorTableInjectable';
+import { HtmlTableCustomCss } from './constants';
 
 @Service()
 export class TransactionsByVendorsPdf {
@@ -27,7 +28,8 @@ export class TransactionsByVendorsPdf {
       tenantId,
       table.table,
       table.meta.sheetName,
-      table.meta.formattedDateRange
+      table.meta.formattedDateRange,
+      HtmlTableCustomCss
     );
   }
 }

packages/server/src/services/FinancialStatements/TransactionsByVendor/constants.ts

@@ -0,0 +1,23 @@
+export const HtmlTableCustomCss = `
+table tr td:not(:first-child) {
+  border-left: 1px solid #ececec;
+}
+table tr:last-child td {
+  border-bottom: 1px solid #ececec; 
+}
+table .cell--credit,
+table .cell--debit,
+table .column--credit,
+table .column--debit,
+table .column--running_balance,
+table .cell--running_balance{
+  text-align: right;
+}
+table tr.row-type--closing-balance td,
+table tr.row-type--opening-balance td {
+  font-weight: 600;
+}
+table tr.row-type--vendor:not(:first-child) td {
+  border-top: 1px solid #ddd;
+}
+`;

packages/server/src/services/FinancialStatements/TrialBalanceSheet/_constants.ts

@@ -6,7 +6,7 @@ export enum IROW_TYPE {
 export const HtmlTableCustomCss = `
 table tr.row-type--total td{
   border-top: 1px solid #bbb;
-  font-weight: 500;
+  font-weight: 600;
   border-bottom: 3px double #000;
 }
 

packages/server/src/services/FinancialStatements/VendorBalanceSummary/VendorBalanceSummaryTableRows.ts

@@ -54,7 +54,7 @@ export class VendorBalanceSummaryTable {
    */
   private getVendorColumnsAccessor = (): IColumnMapperMeta[] => {
     const columns = [
-      { key: 'vendorName', accessor: 'vendorName' },
+      { key: 'name', accessor: 'vendorName' },
       { key: 'total', accessor: 'total.formattedAmount' },
     ];
     return R.compose(
@@ -87,7 +87,7 @@ export class VendorBalanceSummaryTable {
    */
   private getTotalColumnsAccessor = (): IColumnMapperMeta[] => {
     const columns = [
-      { key: 'total', value: this.i18n.__('Total') },
+      { key: 'name', value: this.i18n.__('Total') },
       { key: 'total', accessor: 'total.formattedAmount' },
     ];
     return R.compose(

packages/server/src/services/FinancialStatements/VendorBalanceSummary/constants.ts

@@ -3,4 +3,12 @@ table tr.row-type--total td {
   font-weight: 600;
   border-top: 1px solid #bbb;
   border-bottom: 3px double #333;
-}`;
+}
+table .column--name {
+  width: 65%;
+}
+table .column--total,
+table .cell--total {
+  text-align: right;
+}
+`;

packages/server/src/subscribers/events.ts

@@ -392,6 +392,15 @@ export default {
 
     onTransactionDeleting: 'onCashflowTransactionDeleting',
     onTransactionDeleted: 'onCashflowTransactionDeleted',
+
+    onTransactionCategorizing: 'onTransactionCategorizing',
+    onTransactionCategorized: 'onCashflowTransactionCategorized',
+
+    onTransactionUncategorizing: 'onTransactionUncategorizing',
+    onTransactionUncategorized: 'onTransactionUncategorized',
+
+    onTransactionCategorizingAsExpense: 'onTransactionCategorizingAsExpense',
+    onTransactionCategorizedAsExpense: 'onTransactionCategorizedAsExpense',
   },
 
   /**
@@ -601,4 +610,8 @@ export default {
     onInactivating: 'onTaxRateInactivating',
     onInactivated: 'onTaxRateInactivated',
   },
+
+  plaid: {
+    onItemCreated: 'onPlaidItemCreated',
+  },
 };

packages/server/src/system/migrations/20240222134235_create_plaid_items_table.js

@@ -0,0 +1,15 @@
+exports.up = function (knex) {
+  return knex.schema.createTable('plaid_items', (table) => {
+    table.bigIncrements('id');
+    table
+      .bigInteger('tenant_id')
+      .unsigned()
+      .index()
+      .references('id')
+      .inTable('tenants');
+    table.string('plaid_item_id');
+    table.timestamps();
+  });
+};
+
+exports.down = (knex) => {};

packages/server/src/system/models/SystemPlaidItem.ts

@@ -0,0 +1,49 @@
+import { Model } from 'objection';
+import SystemModel from '@/system/models/SystemModel';
+
+export default class SystemPlaidItem extends SystemModel {
+  tenantId: number;
+  plaidItemId: string;
+
+  /**
+   * Table name.
+   */
+  static get tableName() {
+    return 'plaid_items';
+  }
+
+  /**
+   * Timestamps columns.
+   */
+  get timestamps() {
+    return ['createdAt', 'updatedAt'];
+  }
+
+  /**
+   * Virtual attributes.
+   */
+  static get virtualAttributes() {
+    return [];
+  }
+
+  /**
+   * Relationship mapping.
+   */
+  static get relationMappings() {
+    const Tenant = require('system/models/Tenant');
+
+    return {
+      /**
+       * System user may belongs to tenant model.
+       */
+      tenant: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: Tenant.default,
+        join: {
+          from: 'users.tenantId',
+          to: 'tenants.id',
+        },
+      },
+    };
+  }
+}

packages/server/src/system/models/index.ts

@@ -3,5 +3,13 @@ import TenantMetadata from './TenantMetadata';
 import SystemUser from './SystemUser';
 import PasswordReset from './PasswordReset';
 import Invite from './Invite';
+import SystemPlaidItem from './SystemPlaidItem';
 
-export { Tenant, TenantMetadata, SystemUser, PasswordReset, Invite };
+export {
+  Tenant,
+  TenantMetadata,
+  SystemUser,
+  PasswordReset,
+  Invite,
+  SystemPlaidItem,
+};

packages/webapp/package.json

@@ -40,6 +40,7 @@
     "@types/react-transition-group": "^4.4.5",
     "@types/styled-components": "^5.1.25",
     "@types/yup": "^0.29.13",
+    "@types/socket.io-client": "^3.0.0",
     "@typescript-eslint/eslint-plugin": "^2.10.0",
     "@typescript-eslint/parser": "^2.10.0",
     "@welldone-software/why-did-you-render": "^6.0.0-rc.1",
@@ -69,6 +70,9 @@
     "moment-timezone": "^0.5.33",
     "path-browserify": "^1.0.1",
     "prop-types": "15.8.1",
+    "plaid": "^9.3.0",
+    "plaid-threads": "^11.4.3",
+    "react-plaid-link": "^3.2.1",
     "query-string": "^7.1.1",
     "ramda": "^0.27.1",
     "react": "^18.2.0",
@@ -111,6 +115,7 @@
     "style-loader": "0.23.1",
     "styled-components": "^5.3.1",
     "stylis-rtlcss": "^2.1.1",
+    "socket.io-client": "^4.7.4",
     "typescript": "^4.8.3",
     "yup": "^0.28.1"
   },

packages/webapp/src/components/ContentTabs/ContentTabs.tsx

@@ -0,0 +1,111 @@
+// @ts-nocheck
+import React from 'react';
+import styled from 'styled-components';
+import { useUncontrolled } from '@/hooks/useUncontrolled';
+
+const ContentTabsRoot = styled('div')`
+  display: flex;
+  gap: 10px;
+`;
+interface ContentTabItemRootProps {
+  active?: boolean;
+}
+const ContentTabItemRoot = styled.button<ContentTabItemRootProps>`
+  flex: 1 0;
+  background: #fff;
+  border: 1px solid #e1e2e8;
+  border-radius: 5px;
+  padding: 11px;
+  text-align: left;
+  cursor: pointer;
+
+  ${(props) =>
+    props.active &&
+    `
+      border-color: #1552c8;
+      box-shadow: 0 0 0 0.25px #1552c8;
+
+      ${ContentTabTitle} {
+        color: #1552c8;
+        font-weight: 500;
+      }
+      ${ContentTabDesc} {
+        color: #1552c8;        
+      }
+    `}
+  &:hover,
+  &:active {
+    border-color: #1552c8;
+  }
+`;
+const ContentTabTitle = styled('h3')`
+  font-size: 14px;
+  font-weight: 400;
+  color: #2f343c;
+`;
+const ContentTabDesc = styled('p')`
+  margin: 0;
+  color: #5f6b7c;
+  margin-top: 4px;
+  font-size: 12px;
+`;
+
+interface ContentTabsItemProps {
+  id: string;
+  title?: React.ReactNode;
+  description?: React.ReactNode;
+  active?: boolean;
+}
+
+const ContentTabsItem = ({
+  title,
+  description,
+  active,
+  onClick,
+}: ContentTabsItemProps) => {
+  return (
+    <ContentTabItemRoot active={active} onClick={onClick}>
+      <ContentTabTitle>{title}</ContentTabTitle>
+      <ContentTabDesc>{description}</ContentTabDesc>
+    </ContentTabItemRoot>
+  );
+};
+
+interface ContentTabsProps {
+  initialValue?: string;
+  value?: string;
+  onChange?: (value: string) => void;
+  children?: React.ReactNode;
+  className?: string;
+}
+
+export function ContentTabs({
+  initialValue,
+  value,
+  onChange,
+  children,
+  className,
+}: ContentTabsProps) {
+  const [localValue, handleItemChange] = useUncontrolled<string>({
+    initialValue,
+    value,
+    onChange,
+    finalValue: '',
+  });
+  const tabs = React.Children.toArray(children);
+
+  return (
+    <ContentTabsRoot className={className}>
+      {tabs.map((tab) => (
+        <ContentTabsItem
+          key={tab.key}
+          {...tab.props}
+          active={localValue === tab.props.id}
+          onClick={() => handleItemChange(tab.props?.id)}
+        />
+      ))}
+    </ContentTabsRoot>
+  );
+}
+
+ContentTabs.Tab = ContentTabsItem;

packages/webapp/src/components/ContentTabs/index.ts

@@ -0,0 +1 @@
+export * from './ContentTabs';

packages/webapp/src/components/Dashboard/Dashboard.tsx

@@ -14,6 +14,7 @@ import GlobalHotkeys from './GlobalHotkeys';
 import DashboardProvider from './DashboardProvider';
 import DrawersContainer from '@/components/DrawersContainer';
 import AlertsContainer from '@/containers/AlertsContainer';
+import { DashboardSockets } from './DashboardSockets';
 
 /**
  * Dashboard preferences.
@@ -50,6 +51,7 @@ export default function Dashboard() {
         <Route path="/" component={DashboardAnyPage} />
       </Switch>
 
+      <DashboardSockets />
       <DashboardUniversalSearch />
       <GlobalHotkeys />
       <DialogsContainer />

packages/webapp/src/components/Dashboard/DashboardSockets.tsx

@@ -0,0 +1,31 @@
+import { useEffect, useRef } from 'react';
+import { useQueryClient } from 'react-query';
+import { io } from 'socket.io-client';
+import t from '@/hooks/query/types';
+import { AppToaster } from '@/components';
+import { Intent } from '@blueprintjs/core';
+
+export function DashboardSockets() {
+  const socket = useRef<any>();
+  const client = useQueryClient();
+
+  useEffect(() => {
+    socket.current = io('/', { path: '/socket' });
+  
+    socket.current.on('NEW_TRANSACTIONS_DATA', () => {
+      client.invalidateQueries(t.ACCOUNTS);
+      client.invalidateQueries(t.ACCOUNT_TRANSACTION);
+      client.invalidateQueries(t.CASH_FLOW_ACCOUNTS);
+      client.invalidateQueries(t.CASH_FLOW_TRANSACTIONS);
+
+      AppToaster.show({
+        message: 'The Plaid connected accounts have been updated.',
+        intent: Intent.SUCCESS,
+      });
+    });
+    return () => {
+      socket.current.removeAllListeners();
+      socket.current.close();
+    };
+  }, []);
+}

packages/webapp/src/components/Dashboard/GlobalHotkeys.tsx

@@ -5,12 +5,16 @@ import { useHistory } from 'react-router-dom';
 import { getDashboardRoutes } from '@/routes/dashboard';
 import withDashboardActions from '@/containers/Dashboard/withDashboardActions';
 import withDialogActions from '@/containers/Dialog/withDialogActions';
+import withUniversalSearchActions from '@/containers/UniversalSearch/withUniversalSearchActions';
 
 import { compose } from '@/utils';
 
 function GlobalHotkeys({
   // #withDashboardActions
-  toggleSidebarExpend,
+  toggleSidebarExpand,
+
+  // withUniversalSearchActions
+  openGlobalSearch,
 
   // #withDialogActions
   openDialog,
@@ -24,7 +28,7 @@ function GlobalHotkeys({
     .toString();
 
   const handleSidebarToggleBtn = () => {
-    toggleSidebarExpend();
+    toggleSidebarExpand();
   };
   useHotkeys(
     globalHotkeys,
@@ -37,10 +41,26 @@ function GlobalHotkeys({
     },
     [history],
   );
-  useHotkeys('ctrl+/', (event, handle) => handleSidebarToggleBtn());
-  useHotkeys('shift+d', (event, handle) => openDialog('money-in', {}));
-  useHotkeys('shift+q', (event, handle) => openDialog('money-out', {}));
+  useHotkeys('ctrl+/', () => {
+    handleSidebarToggleBtn();
+  });
+  useHotkeys('shift+d', () => {
+    openDialog('money-in', {});
+  });
+  useHotkeys('shift+q', () => {
+    openDialog('money-out', {});
+  });
+  useHotkeys('/', () => {
+    setTimeout(() => {
+      openGlobalSearch();
+    }, 0);
+  });
+
   return <div></div>;
 }
 
-export default compose(withDashboardActions, withDialogActions)(GlobalHotkeys);
+export default compose(
+  withDashboardActions,
+  withDialogActions,
+  withUniversalSearchActions,
+)(GlobalHotkeys);

packages/webapp/src/components/DialogsContainer.tsx

@@ -50,6 +50,7 @@ import InvoiceMailDialog from '@/containers/Sales/Invoices/InvoiceMailDialog/Inv
 import EstimateMailDialog from '@/containers/Sales/Estimates/EstimateMailDialog/EstimateMailDialog';
 import ReceiptMailDialog from '@/containers/Sales/Receipts/ReceiptMailDialog/ReceiptMailDialog';
 import PaymentMailDialog from '@/containers/Sales/PaymentReceives/PaymentMailDialog/PaymentMailDialog';
+import { ConnectBankDialog } from '@/containers/CashFlow/ConnectBankDialog';
 
 /**
  * Dialogs container.
@@ -146,6 +147,7 @@ export default function DialogsContainer() {
       <EstimateMailDialog dialogName={DialogsName.EstimateMail} />
       <ReceiptMailDialog dialogName={DialogsName.ReceiptMail} />
       <PaymentMailDialog dialogName={DialogsName.PaymentMail} />
+      <ConnectBankDialog dialogName={DialogsName.ConnectBankCreditCard} />
     </div>
   );
 }

packages/webapp/src/components/Drawer/DrawerBody.tsx

@@ -1,5 +1,6 @@
 // @ts-nocheck
 import React from 'react';
+import clsx from 'classnames';
 import { Classes } from '@blueprintjs/core';
 import { LoadingIndicator } from '../Indicator';
 
@@ -11,8 +12,8 @@ export function DrawerLoading({ loading, mount = false, children }) {
   );
 }
 
-export function DrawerBody({ children }) {
-  return <div className={Classes.DRAWER_BODY}>{children}</div>;
+export function DrawerBody({ children, className }) {
+  return <div className={clsx(Classes.DRAWER_BODY, className)}>{children}</div>;
 }
 
 export * from './DrawerActionsBar';

packages/webapp/src/components/DrawersContainer.tsx

@@ -23,6 +23,7 @@ import WarehouseTransferDetailDrawer from '@/containers/Drawers/WarehouseTransfe
 import TaxRateDetailsDrawer from '@/containers/TaxRates/drawers/TaxRateDetailsDrawer/TaxRateDetailsDrawer';
 
 import { DRAWERS } from '@/constants/drawers';
+import CategorizeTransactionDrawer from '@/containers/CashFlow/CategorizeTransaction/drawers/CategorizeTransactionDrawer/CategorizeTransactionDrawer';
 
 /**
  * Drawers container of the dashboard.
@@ -61,6 +62,7 @@ export default function DrawersContainer() {
         name={DRAWERS.WAREHOUSE_TRANSFER_DETAILS}
       />
       <TaxRateDetailsDrawer name={DRAWERS.TAX_RATE_DETAILS} />
+      <CategorizeTransactionDrawer name={DRAWERS.CATEGORIZE_TRANSACTION} />
     </div>
   );
 }

packages/webapp/src/components/Forms/Select.tsx

@@ -26,12 +26,12 @@ const SelectButton = styled(Button)`
   position: relative;
   padding-right: 30px;
 
-  &.bp4-small{
+  &.bp4-small {
     padding-right: 24px;
   }
 
   &:not(.is-selected):not([class*='bp4-intent-']):not(.bp4-minimal) {
-    color: #5c7080;
+    color: #8f99a8;
   }
   &:after {
     content: '';

packages/webapp/src/components/UniversalSearch/UniversalSearch.tsx

@@ -152,6 +152,7 @@ function UniversalSearchBar({ isOpen, onSearchTypeChange, ...listProps }) {
             onSearchTypeChange={onSearchTypeChange}
           />
         }
+        autoFocus={true}
       />
       {listProps.itemList}
     </div>

packages/webapp/src/constants/dialogs.ts

@@ -53,6 +53,7 @@ export enum DialogsName {
   EstimateMail = 'estimate-mail',
   ReceiptMail = 'receipt-mail',
   PaymentMail = 'payment-mail',
+  ConnectBankCreditCard = 'connect-bank-credit-card',
   InvoiceFormMailDeliver = 'InvoiceFormMailDeliver',
   EstimateFormMailDeliver = 'EstimateFormMailDeliver',
   ReceiptFormMailDeliver = 'ReceiptFormMailDeliver',

packages/webapp/src/constants/drawers.ts

@@ -23,4 +23,5 @@ export enum DRAWERS {
   REFUND_VENDOR_CREDIT_DETAILS = 'refund-vendor-detail-drawer',
   WAREHOUSE_TRANSFER_DETAILS = 'warehouse-transfer-detail-drawer',
   TAX_RATE_DETAILS = 'tax-rate-detail-drawer',
+  CATEGORIZE_TRANSACTION = 'categorize-transaction',
 }

packages/webapp/src/constants/tables.tsx

@@ -15,6 +15,7 @@ export const TABLES = {
   EXPENSES: 'expenses',
   CASHFLOW_ACCOUNTS: 'cashflow_accounts',
   CASHFLOW_Transactions: 'cashflow_transactions',
+  UNCATEGORIZED_CASHFLOW_TRANSACTION: 'UNCATEGORIZED_CASHFLOW_TRANSACTION',
   CREDIT_NOTES: 'credit_notes',
   VENDOR_CREDITS: 'vendor_credits',
   WAREHOUSE_TRANSFERS: 'warehouse_transfers',

packages/webapp/src/containers/Accounts/components.tsx

@@ -116,3 +116,16 @@ export function BalanceCell({ cell }) {
     <span class="placeholder">—</span>
   );
 }
+
+/**
+ * Balance cell.
+ */
+export function BankBalanceCell({ cell }) {
+  const account = cell.row.original;
+
+  return account.amount !== null ? (
+    <span>{account.bank_balance_formatted}</span>
+  ) : (
+    <span class="placeholder">—</span>
+  );
+}

packages/webapp/src/containers/Accounts/utils.tsx

@@ -4,7 +4,7 @@ import intl from 'react-intl-universal';
 import { Intent, Tag } from '@blueprintjs/core';
 
 import { If, AppToaster } from '@/components';
-import { NormalCell, BalanceCell } from './components';
+import { NormalCell, BalanceCell, BankBalanceCell } from './components';
 import { transformTableStateToQuery, isBlank } from '@/utils';
 
 /**
@@ -94,6 +94,15 @@ export const useAccountsTableColumns = () => {
         width: 75,
         clickable: true,
       },
+      {
+        id: 'bank_balance',
+        Header: 'Bank Balance',
+        accessor: 'bank_balance_formatted',
+        Cell: BankBalanceCell,
+        width: 150,
+        clickable: true,
+        align: 'right',
+      },
       {
         id: 'balance',
         Header: intl.get('balance'),
@@ -119,5 +128,5 @@ export const transformAccountsStateToQuery = (tableState) => {
   return {
     ...transformTableStateToQuery(tableState),
     inactive_mode: tableState.inactiveMode,
-  }
-}
+  };
+};

packages/webapp/src/containers/Banking/Plaid/PlaidLanchLink.tsx

@@ -0,0 +1,100 @@
+// @ts-nocheck
+import React, { useEffect } from 'react';
+import {
+  usePlaidLink,
+  PlaidLinkOnSuccessMetadata,
+  PlaidLinkOnExitMetadata,
+  PlaidLinkError,
+  PlaidLinkOptionsWithLinkToken,
+  PlaidLinkOnEventMetadata,
+  PlaidLinkStableEvent,
+} from 'react-plaid-link';
+import { logEvent, logExit, logSuccess } from './_utils';
+import { usePlaidExchangeToken } from '@/hooks/query';
+import { useResetBankingPlaidToken } from '@/hooks/state/banking';
+
+interface PlaidLaunchLinkProps {
+  token: string;
+  itemId?: number | null;
+  children?: React.ReactNode;
+}
+
+/**
+ * Uses the usePlaidLink hook to manage the Plaid Link creation.
+ * See https://github.com/plaid/react-plaid-link for full usage instructions.
+ * The link token passed to usePlaidLink cannot be null.
+ * It must be generated outside of this component.  In this sample app, the link token
+ * is generated in the link context in client/src/services/link.js.
+ *
+ * @param {PlaidLaunchLinkProps} props
+ * @returns {React.ReactNode}
+ */
+export function LaunchLink(props: PlaidLaunchLinkProps) {
+  const resetPlaidToken = useResetBankingPlaidToken();
+  const { mutateAsync: exchangeAccessToken } = usePlaidExchangeToken();
+
+  // define onSuccess, onExit and onEvent functions as configs for Plaid Link creation
+  const onSuccess = async (
+    publicToken: string,
+    metadata: PlaidLinkOnSuccessMetadata,
+  ) => {
+    // log and save metatdata
+    logSuccess(metadata);
+    if (props.itemId != null) {
+      // update mode: no need to exchange public token
+      // await setItemState(props.itemId, 'good');
+      // deleteLinkToken(null, props.itemId);
+      // getItemById(props.itemId, true);
+      // regular link mode: exchange public token for access token
+    } else {
+      await exchangeAccessToken({
+        public_token: publicToken,
+        institution_id: metadata.institution.institution_id,
+      });
+    }
+    // resetError();
+    resetPlaidToken();
+  };
+
+  // Handle other error codes, see https://plaid.com/docs/errors/
+  const onExit = async (
+    error: PlaidLinkError | null,
+    metadata: PlaidLinkOnExitMetadata,
+  ) => {
+    // log and save error and metatdata
+    logExit(error, metadata, props.userId);
+    if (error != null) {
+      // setError(error.error_code, error.display_message || error.error_message);
+    }
+    resetPlaidToken();
+  };
+
+  const onEvent = async (
+    eventName: PlaidLinkStableEvent | string,
+    metadata: PlaidLinkOnEventMetadata,
+  ) => {
+    // handle errors in the event end-user does not exit with onExit function error enabled.
+    if (eventName === 'ERROR' && metadata.error_code != null) {
+      // setError(metadata.error_code, ' ');
+    }
+    logEvent(eventName, metadata);
+  };
+
+  const config: PlaidLinkOptionsWithLinkToken = {
+    onSuccess,
+    onExit,
+    onEvent,
+    token: props.token,
+  };
+
+  const { open, ready } = usePlaidLink(config);
+
+  useEffect(() => {
+    // initiallizes Link automatically
+    if (ready) {
+      open();
+    }
+  }, [ready, open, props.itemId, props.token]);
+
+  return <></>;
+}

packages/webapp/src/containers/Banking/Plaid/_utils.ts

@@ -0,0 +1,46 @@
+import {
+  PlaidLinkError,
+  PlaidLinkOnEventMetadata,
+  PlaidLinkOnExitMetadata,
+  PlaidLinkOnSuccessMetadata,
+  PlaidLinkStableEvent,
+} from 'react-plaid-link';
+
+export const logEvent = (
+  eventName: PlaidLinkStableEvent | string,
+  metadata:
+    | PlaidLinkOnEventMetadata
+    | PlaidLinkOnSuccessMetadata
+    | PlaidLinkOnExitMetadata,
+  error?: PlaidLinkError | null,
+) => {
+  console.log(`Link Event: ${eventName}`, metadata, error);
+};
+
+export const logSuccess = async ({
+  institution,
+  accounts,
+  link_session_id,
+}: PlaidLinkOnSuccessMetadata) => {
+  logEvent('onSuccess', {
+    institution,
+    accounts,
+    link_session_id,
+  });
+};
+
+export const logExit = async (
+  error: PlaidLinkError | null,
+  { institution, status, link_session_id, request_id }: PlaidLinkOnExitMetadata,
+) => {
+  logEvent(
+    'onExit',
+    {
+      institution,
+      status,
+      link_session_id,
+      request_id,
+    },
+    error,
+  );
+};

packages/webapp/src/containers/CashFlow/AccountTransactions/AccountTransactionsAllBoot.tsx

@@ -0,0 +1,78 @@
+// @ts-nocheck
+import React from 'react';
+import { flatten, map } from 'lodash';
+import { IntersectionObserver } from '@/components';
+import { useAccountTransactionsInfinity } from '@/hooks/query';
+import { useAccountTransactionsContext } from './AccountTransactionsProvider';
+
+const AccountTransactionsAllBootContext = React.createContext();
+
+function flattenInfinityPages(data) {
+  return flatten(map(data.pages, (page) => page.transactions));
+}
+
+interface AccountTransactionsAllPoviderProps {
+  children: React.ReactNode;
+}
+
+/**
+ * Account transctions all provider.
+ */
+function AccountTransactionsAllProvider({
+  children,
+}: AccountTransactionsAllPoviderProps) {
+  const { accountId } = useAccountTransactionsContext();
+
+  // Fetch cashflow account transactions list
+  const {
+    data: cashflowTransactionsPages,
+    isFetching: isCashFlowTransactionsFetching,
+    isLoading: isCashFlowTransactionsLoading,
+    isSuccess: isCashflowTransactionsSuccess,
+    fetchNextPage: fetchNextTransactionsPage,
+    isFetchingNextPage: isCashflowTransactionsFetchingNextPage,
+    hasNextPage: hasCashflowTransactionsNextPgae,
+  } = useAccountTransactionsInfinity(accountId, {
+    page_size: 50,
+    account_id: accountId,
+  });
+  // Memorized the cashflow account transactions.
+  const cashflowTransactions = React.useMemo(
+    () =>
+      isCashflowTransactionsSuccess
+        ? flattenInfinityPages(cashflowTransactionsPages)
+        : [],
+    [cashflowTransactionsPages, isCashflowTransactionsSuccess],
+  );
+  // Handle the observer ineraction.
+  const handleObserverInteract = React.useCallback(() => {
+    if (!isCashFlowTransactionsFetching && hasCashflowTransactionsNextPgae) {
+      fetchNextTransactionsPage();
+    }
+  }, [
+    isCashFlowTransactionsFetching,
+    hasCashflowTransactionsNextPgae,
+    fetchNextTransactionsPage,
+  ]);
+  // Provider payload.
+  const provider = {
+    cashflowTransactions,
+    isCashFlowTransactionsFetching,
+    isCashFlowTransactionsLoading,
+  };
+
+  return (
+    <AccountTransactionsAllBootContext.Provider value={provider}>
+      {children}
+      <IntersectionObserver
+        onIntersect={handleObserverInteract}
+        enabled={!isCashflowTransactionsFetchingNextPage}
+      />
+    </AccountTransactionsAllBootContext.Provider>
+  );
+}
+
+const useAccountTransactionsAllContext = () =>
+  React.useContext(AccountTransactionsAllBootContext);
+
+export { AccountTransactionsAllProvider, useAccountTransactionsAllContext };