fix(biling): Subscription billing system.

fix(GeneralLedger): running balance.

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

@@ -1,4 +1,4 @@
-import { pick, get, last } from 'lodash';
+import { isEmpty, get, last } from 'lodash';
 import {
   IGeneralLedgerSheetQuery,
   IGeneralLedgerSheetAccount,
@@ -73,10 +73,9 @@ export default class GeneralLedgerSheet extends FinancialSheet {
   entryReducer(
     entries: IGeneralLedgerSheetAccountTransaction[],
     entry: IJournalEntry,
-    index: number
+    openingBalance: number
   ): IGeneralLedgerSheetAccountTransaction[] {
     const lastEntry = last(entries);
-    const openingBalance = 0;
 
     const contact = this.contactsMap.get(entry.contactId);
     const amount = this.getAmount(
@@ -85,11 +84,7 @@ export default class GeneralLedgerSheet extends FinancialSheet {
       entry.accountNormal
     );
     const runningBalance =
-      (entries.length === 0
-        ? openingBalance
-        : lastEntry
-        ? lastEntry.runningBalance
-          : 0) + amount;
+      amount + (!isEmpty(entries) ? lastEntry.runningBalance : openingBalance);
 
     const newEntry = {
       date: entry.date,
@@ -182,9 +177,7 @@ export default class GeneralLedgerSheet extends FinancialSheet {
    * @param {IAccount} account
    * @return {IGeneralLedgerSheetAccount}
    */
-  private accountMapper(
-    account: IAccount
-  ): IGeneralLedgerSheetAccount {
+  private accountMapper(account: IAccount): IGeneralLedgerSheetAccount {
     const openingBalance = this.accountOpeningBalance(account);
     const closingBalance = this.accountClosingBalance(account);
 
@@ -208,14 +201,10 @@ export default class GeneralLedgerSheet extends FinancialSheet {
    * @param {IAccount[]} accounts -
    * @return {IGeneralLedgerSheetAccount[]}
    */
-  private accountsWalker(
-    accounts: IAccount[]
-  ): IGeneralLedgerSheetAccount[] {
+  private accountsWalker(accounts: IAccount[]): IGeneralLedgerSheetAccount[] {
     return (
       accounts
-        .map((account: IAccount) =>
-          this.accountMapper(account)
-        )
+        .map((account: IAccount) => this.accountMapper(account))
         // Filter general ledger accounts that have no transactions
         // when`noneTransactions` is on.
         .filter(

server/src/services/Payment/License.ts

@@ -1,10 +1,18 @@
 import { Service, Container, Inject } from 'typedi';
 import cryptoRandomString from 'crypto-random-string';
 import { times } from 'lodash';
-import { License } from "system/models";
-import { ILicense } from 'interfaces';
+import { License, Plan } from 'system/models';
+import { ILicense, ISendLicenseDTO } from 'interfaces';
 import LicenseMailMessages from 'services/Payment/LicenseMailMessages';
 import LicenseSMSMessages from 'services/Payment/LicenseSMSMessages';
+import { ServiceError } from 'exceptions';
+
+const ERRORS = {
+  PLAN_NOT_FOUND: 'PLAN_NOT_FOUND',
+  LICENSE_NOT_FOUND: 'LICENSE_NOT_FOUND',
+  LICENSE_ALREADY_DISABLED: 'LICENSE_ALREADY_DISABLED',
+  NO_AVALIABLE_LICENSE_CODE: 'NO_AVALIABLE_LICENSE_CODE',
+};
 
 @Service()
 export default class LicenseService {
@@ -14,49 +22,99 @@ export default class LicenseService {
   @Inject()
   mailMessages: LicenseMailMessages;
 
+  /**
+   * Validate the plan existance on the storage.
+   * @param {number} tenantId -
+   * @param {string} planSlug - Plan slug.
+   */
+  private async getPlanOrThrowError(planSlug: string) {
+    const foundPlan = await Plan.query().where('slug', planSlug).first();
+
+    if (!foundPlan) {
+      throw new ServiceError(ERRORS.PLAN_NOT_FOUND);
+    }
+    return foundPlan;
+  }
+
+  /**
+   * Valdiate the license existance on the storage.
+   * @param {number} licenseId - License id.
+   */
+  private async getLicenseOrThrowError(licenseId: number) {
+    const foundLicense = await License.query().findById(licenseId);
+
+    if (!foundLicense) {
+      throw new ServiceError(ERRORS.LICENSE_NOT_FOUND);
+    }
+    return foundLicense;
+  }
+
+  /**
+   * Validates whether the license id is disabled.
+   * @param {ILicense} license
+   */
+  private validateNotDisabledLicense(license: ILicense) {
+    if (license.disabledAt) {
+      throw new ServiceError(ERRORS.LICENSE_ALREADY_DISABLED);
+    }
+  }
+
   /**
    * Generates the license code in the given period.
-   * @param {number} licensePeriod 
+   * @param  {number} licensePeriod
    * @return {Promise<ILicense>}
    */
-  async generateLicense(
+  public async generateLicense(
     licensePeriod: number,
     periodInterval: string = 'days',
-    planId: number,
+    planSlug: string
   ): ILicense {
     let licenseCode: string;
     let repeat: boolean = true;
 
-    while(repeat) {
-      licenseCode = cryptoRandomString({ length: 10, type: 'numeric' });
-      const foundLicenses = await License.query().where('license_code', licenseCode);
+    // Retrieve plan or throw not found error.
+    const plan = await this.getPlanOrThrowError(planSlug);
 
-  		if (foundLicenses.length === 0) {
-			  repeat = false;
+    while (repeat) {
+      licenseCode = cryptoRandomString({ length: 10, type: 'numeric' });
+      const foundLicenses = await License.query().where(
+        'license_code',
+        licenseCode
+      );
+
+      if (foundLicenses.length === 0) {
+        repeat = false;
       }
     }
     return License.query().insert({
-      licenseCode, licensePeriod, periodInterval, planId,
+      licenseCode,
+      licensePeriod,
+      periodInterval,
+      planId: plan.id,
     });
   }
 
   /**
-   * 
-   * @param {number} loop 
-   * @param {number} licensePeriod 
-   * @param {string} periodInterval 
-   * @param {number} planId 
+   * Generates licenses.
+   * @param {number} loop
+   * @param {number} licensePeriod
+   * @param {string} periodInterval
+   * @param {number} planId
    */
-  async generateLicenses(
+  public async generateLicenses(
     loop = 1,
     licensePeriod: number,
     periodInterval: string = 'days',
-    planId: number,
+    planSlug: string
   ) {
     const asyncOpers: Promise<any>[] = [];
 
     times(loop, () => {
-      const generateOper = this.generateLicense(licensePeriod, periodInterval, planId);
+      const generateOper = this.generateLicense(
+        licensePeriod,
+        periodInterval,
+        planSlug
+      );
       asyncOpers.push(generateOper);
     });
     return Promise.all(asyncOpers);
@@ -64,38 +122,64 @@ export default class LicenseService {
 
   /**
    * Disables the given license id on the storage.
-   * @param  {number} licenseId 
+   * @param  {string} licenseSlug - License slug.
    * @return {Promise}
    */
-  async disableLicense(licenseId: number) {
-    return License.markLicenseAsDisabled(licenseId, 'id');
+  public async disableLicense(licenseId: number) {
+    const license = await this.getLicenseOrThrowError(licenseId);
+
+    this.validateNotDisabledLicense(license);
+
+    return License.markLicenseAsDisabled(license.id, 'id');
   }
 
   /**
    * Deletes the given license id from the storage.
-   * @param licenseId 
+   * @param licenseSlug {string} - License slug.
    */
-  async deleteLicense(licenseId: number) {
-    return License.query().where('id', licenseId).delete();
+  public async deleteLicense(licenseSlug: string) {
+    const license = await this.getPlanOrThrowError(licenseSlug);
+
+    return License.query().where('id', license.id).delete();
   }
 
   /**
    * Sends license code to the given customer via SMS or mail message.
-   * @param {string} licenseCode - License code
-   * @param {string} phoneNumber - Phone number
+   * @param {string} licenseCode - License code.
+   * @param {string} phoneNumber - Phone number.
    * @param {string} email - Email address.
    */
-  async sendLicenseToCustomer(licenseCode: string, phoneNumber: string, email: string) {
+  public async sendLicenseToCustomer(sendLicense: ISendLicenseDTO) {
     const agenda = Container.get('agenda');
+    const { phoneNumber, email, period, periodInterval } = sendLicense;
 
+    // Retreive plan details byt the given plan slug.
+    const plan = await this.getPlanOrThrowError(sendLicense.planSlug);
+
+    const license = await License.query()
+      .modify('filterActiveLicense')
+      .where('license_period', period)
+      .where('period_interval', periodInterval)
+      .where('plan_id', plan.id)
+      .first();
+
+    if (!license) {
+      throw new ServiceError(ERRORS.NO_AVALIABLE_LICENSE_CODE)
+    }
     // Mark the license as used.
-    await License.markLicenseAsSent(licenseCode);
+    await License.markLicenseAsSent(license.licenseCode);
 
-    if (email) {
-      await agenda.schedule('1 second', 'send-license-via-email', { licenseCode, email });
+    if (sendLicense.email) {
+      await agenda.schedule('1 second', 'send-license-via-email', {
+        licenseCode: license.licenseCode,
+        email,
+      });
     }
     if (phoneNumber) {
-      await agenda.schedule('1 second', 'send-license-via-phone', { licenseCode, phoneNumber });
+      await agenda.schedule('1 second', 'send-license-via-phone', {
+        licenseCode: license.licenseCode,
+        phoneNumber,
+      });
     }
   }
-}
+}

server/src/services/Payment/LicensePaymentMethod.ts

@@ -1,16 +1,24 @@
-import { License } from "system/models";
+import { License } from 'system/models';
 import PaymentMethod from 'services/Payment/PaymentMethod';
 import { Plan } from 'system/models';
 import { IPaymentMethod, ILicensePaymentModel } from 'interfaces';
-import { ILicensePaymentModel } from "interfaces";
-import { PaymentInputInvalid, PaymentAmountInvalidWithPlan } from 'exceptions';
+import { ILicensePaymentModel } from 'interfaces';
+import {
+  PaymentInputInvalid,
+  PaymentAmountInvalidWithPlan,
+  VoucherCodeRequired,
+} from 'exceptions';
 
-export default class LicensePaymentMethod extends PaymentMethod implements IPaymentMethod {
+export default class LicensePaymentMethod
+  extends PaymentMethod
+  implements IPaymentMethod {
   /**
    * Payment subscription of organization via license code.
    * @param {ILicensePaymentModel} licensePaymentModel -
    */
   async payment(licensePaymentModel: ILicensePaymentModel, plan: Plan) {
+    this.validateLicensePaymentModel(licensePaymentModel);
+
     const license = await this.getLicenseOrThrowInvalid(licensePaymentModel);
     this.validatePaymentAmountWithPlan(license, plan);
 
@@ -36,12 +44,22 @@ export default class LicensePaymentMethod extends PaymentMethod implements IPaym
 
   /**
    * Validates the payment amount with given plan price.
-   * @param {License} license 
-   * @param {Plan} plan 
+   * @param {License} license
+   * @param {Plan} plan
    */
   validatePaymentAmountWithPlan(license: License, plan: Plan) {
     if (license.planId !== plan.id) {
       throw new PaymentAmountInvalidWithPlan();
     }
   }
-}
+
+  /**
+   * Validate voucher payload.
+   * @param {ILicensePaymentModel} licenseModel -
+   */
+  validateLicensePaymentModel(licenseModel: ILicensePaymentModel) {
+    if (!licenseModel || !licenseModel.licenseCode) {
+      throw new VoucherCodeRequired();
+    }
+  }
+}

server/src/services/Subscription/Subscription.ts

@@ -31,10 +31,8 @@ export default class Subscription<PaymentModel> {
   ) {
     this.validateIfPlanHasPriceNoPayment(plan, paymentModel);
 
-    // @todo
-    if (plan.price > 0) {
-      await this.paymentContext.makePayment(paymentModel, plan);
-    }
+    await this.paymentContext.makePayment(paymentModel, plan);
+
     const subscription = await tenant.$relatedQuery('subscriptions')
       .modify('subscriptionBySlug', subscriptionSlug)
       .first();