add server to monorepo.

packages/server/src/services/Payment/License.ts

@@ -0,0 +1,185 @@
+import { Service, Container, Inject } from 'typedi';
+import cryptoRandomString from 'crypto-random-string';
+import { times } from 'lodash';
+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 {
+  @Inject()
+  smsMessages: LicenseSMSMessages;
+
+  @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
+   * @return {Promise<ILicense>}
+   */
+  public async generateLicense(
+    licensePeriod: number,
+    periodInterval: string = 'days',
+    planSlug: string
+  ): ILicense {
+    let licenseCode: string;
+    let repeat: boolean = true;
+
+    // Retrieve plan or throw not found error.
+    const plan = await this.getPlanOrThrowError(planSlug);
+
+    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: plan.id,
+    });
+  }
+
+  /**
+   * Generates licenses.
+   * @param {number} loop
+   * @param {number} licensePeriod
+   * @param {string} periodInterval
+   * @param {number} planId
+   */
+  public async generateLicenses(
+    loop = 1,
+    licensePeriod: number,
+    periodInterval: string = 'days',
+    planSlug: string
+  ) {
+    const asyncOpers: Promise<any>[] = [];
+
+    times(loop, () => {
+      const generateOper = this.generateLicense(
+        licensePeriod,
+        periodInterval,
+        planSlug
+      );
+      asyncOpers.push(generateOper);
+    });
+    return Promise.all(asyncOpers);
+  }
+
+  /**
+   * Disables the given license id on the storage.
+   * @param  {string} licenseSlug - License slug.
+   * @return {Promise}
+   */
+  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 licenseSlug {string} - License slug.
+   */
+  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} email - Email address.
+   */
+  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(license.licenseCode);
+
+    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: license.licenseCode,
+        phoneNumber,
+      });
+    }
+  }
+}

packages/server/src/services/Payment/LicenseMailMessages.ts

@@ -0,0 +1,26 @@
+import { Container } from 'typedi';
+import Mail from '@/lib/Mail';
+import config from '@/config';
+export default class SubscriptionMailMessages {
+  /**
+   * Send license code to the given mail address.
+   * @param {string} licenseCode 
+   * @param {email} email 
+   */
+  public async sendMailLicense(licenseCode: string, email: string) {
+    const Logger = Container.get('logger');
+    
+    const mail = new Mail()
+      .setView('mail/LicenseReceive.html')
+      .setSubject('Bigcapital - License code')
+      .setTo(email)
+      .setData({
+        licenseCode,
+        successEmail: config.customerSuccess.email,
+        successPhoneNumber: config.customerSuccess.phoneNumber,
+      });
+    
+    await mail.send();
+    Logger.info('[license_mail] sent successfully.');
+  }
+}

packages/server/src/services/Payment/LicensePaymentMethod.ts

@@ -0,0 +1,67 @@
+import { License } from '@/system/models';
+import PaymentMethod from '@/services/Payment/PaymentMethod';
+import { Plan } from '@/system/models';
+import { IPaymentMethod, ILicensePaymentModel } from '@/interfaces';
+import {
+  PaymentInputInvalid,
+  PaymentAmountInvalidWithPlan,
+  VoucherCodeRequired,
+} from '@/exceptions';
+
+export default class LicensePaymentMethod
+  extends PaymentMethod
+  implements IPaymentMethod
+{
+  /**
+   * Payment subscription of organization via license code.
+   * @param {ILicensePaymentModel} licensePaymentModel -
+   */
+  public async payment(licensePaymentModel: ILicensePaymentModel, plan: Plan) {
+    this.validateLicensePaymentModel(licensePaymentModel);
+
+    const license = await this.getLicenseOrThrowInvalid(licensePaymentModel);
+    this.validatePaymentAmountWithPlan(license, plan);
+
+    // Mark the license code as used.
+    return License.markLicenseAsUsed(licensePaymentModel.licenseCode);
+  }
+
+  /**
+   * Validates the license code activation on the storage.
+   * @param {ILicensePaymentModel} licensePaymentModel -
+   */
+  private async getLicenseOrThrowInvalid(
+    licensePaymentModel: ILicensePaymentModel
+  ) {
+    const foundLicense = await License.query()
+      .modify('filterActiveLicense')
+      .where('license_code', licensePaymentModel.licenseCode)
+      .first();
+
+    if (!foundLicense) {
+      throw new PaymentInputInvalid();
+    }
+    return foundLicense;
+  }
+
+  /**
+   * Validates the payment amount with given plan price.
+   * @param {License} license
+   * @param {Plan} plan
+   */
+  private validatePaymentAmountWithPlan(license: License, plan: Plan) {
+    if (license.planId !== plan.id) {
+      throw new PaymentAmountInvalidWithPlan();
+    }
+  }
+
+  /**
+   * Validate voucher payload.
+   * @param {ILicensePaymentModel} licenseModel -
+   */
+  private validateLicensePaymentModel(licenseModel: ILicensePaymentModel) {
+    if (!licenseModel || !licenseModel.licenseCode) {
+      throw new VoucherCodeRequired();
+    }
+  }
+}

packages/server/src/services/Payment/LicenseSMSMessages.ts

@@ -0,0 +1,17 @@
+import { Container, Inject } from 'typedi';
+import SMSClient from '@/services/SMSClient';
+
+export default class SubscriptionSMSMessages {
+  @Inject('SMSClient')
+  smsClient: SMSClient;
+
+  /**
+   * Sends license code to the given phone number via SMS message.
+   * @param {string} phoneNumber 
+   * @param {string} licenseCode 
+   */
+  public async sendLicenseSMSMessage(phoneNumber: string, licenseCode: string) {
+    const message: string = `Your license card number: ${licenseCode}. If you need any help please contact us. Bigcapital.`;
+    return this.smsClient.sendMessage(phoneNumber, message);
+  }
+}

packages/server/src/services/Payment/PaymentMethod.ts

@@ -0,0 +1,6 @@
+import moment from 'moment';
+import { IPaymentModel } from '@/interfaces';
+
+export default class PaymentMethod implements IPaymentModel {
+
+}

packages/server/src/services/Payment/index.ts

@@ -0,0 +1,22 @@
+import { IPaymentMethod, IPaymentContext } from "interfaces";
+import { Plan } from '@/system/models';
+
+export default class PaymentContext<PaymentModel> implements IPaymentContext{
+  paymentMethod: IPaymentMethod;
+
+  /**
+   * Constructor method. 
+   * @param {IPaymentMethod} paymentMethod 
+   */
+  constructor(paymentMethod: IPaymentMethod) {
+    this.paymentMethod = paymentMethod;
+  }
+
+  /**
+   * 
+   * @param {<PaymentModel>} paymentModel 
+   */
+  makePayment(paymentModel: PaymentModel, plan: Plan) {
+    return this.paymentMethod.payment(paymentModel, plan);
+  }
+}