refactor(all-services): remove extra code from controllers and used by injecting service in it

GH-88
GH-88

GH-88

Author: Vaibhav Bhalla

services/subscription-service/src/component.ts

@@ -3,7 +3,7 @@
 // This software is released under the MIT License.
 // https://opensource.org/licenses/MIT
 
-import {inject, Binding} from '@loopback/context';
+import {inject, Binding, createBindingFromClass} from '@loopback/context';
 import {
   Component,
   CoreBindings,
@@ -79,6 +79,13 @@ import {BillingCustomerController} from './controllers/billing-customer.controll
 import {BillingInvoiceController} from './controllers/billing-invoice.controller';
 import {BillingPaymentSourceController} from './controllers/billing-payment-source.controller';
 import {WebhookController} from './controllers/webhook.controller';
+import {
+  BillingCustomerService,
+  BillingInvoiceService,
+  BillingPaymentSourceService,
+  PlanFeaturesService,
+  SubscriptionService,
+} from './services';
 
 export class SubscriptionServiceComponent implements Component {
   constructor(
@@ -143,6 +150,12 @@ export class SubscriptionServiceComponent implements Component {
       Binding.bind(WEBHOOK_VERIFIER).toProvider(WebhookVerifierProvider),
 
       Binding.bind(SYSTEM_USER).toProvider(SystemUserProvider),
+      createBindingFromClass(SubscriptionService),
+      createBindingFromClass(BillingCustomerService),
+      createBindingFromClass(BillingInvoiceService),
+      createBindingFromClass(BillingPaymentSourceService),
+      createBindingFromClass(PlanFeaturesService),
+      createBindingFromClass(BillingPaymentSourceService),
     ];
 
     this.controllers = [

services/subscription-service/src/controllers/billing-customer.controller.ts

@@ -1,6 +1,5 @@
-import {BillingComponentBindings, IService} from 'loopback4-billing';
-import {inject} from '@loopback/core';
-import {Filter, repository} from '@loopback/repository';
+import {service} from '@loopback/core';
+import {Filter} from '@loopback/repository';
 import {
   del,
   get,
@@ -13,22 +12,16 @@ import {
 import {OPERATION_SECURITY_SPEC, STATUS_CODE} from '@sourceloop/core';
 import {authenticate, STRATEGY} from 'loopback4-authentication';
 import {authorize} from 'loopback4-authorization';
-import {AddressDto} from '../models';
 import {BillingCustomer} from '../models/billing-customer.model';
 import {CustomerDto} from '../models/dto/customer-dto.model';
 import {PermissionKey} from '../permissions';
-import {InvoiceRepository} from '../repositories';
-import {BillingCustomerRepository} from '../repositories/billing-customer.repository';
+import {BillingCustomerService} from '../services/billing-customer.service';
 
 const basePath = '/billing-customer';
 export class BillingCustomerController {
   constructor(
-    @repository(BillingCustomerRepository)
-    public billingCustomerRepository: BillingCustomerRepository,
-    @repository(InvoiceRepository)
-    public invoiceRepository: InvoiceRepository,
-    @inject(BillingComponentBindings.BillingProvider)
-    private readonly billingProvider: IService,
+    @service(BillingCustomerService)
+    public billingCustomerService: BillingCustomerService,
   ) {}
 
   @authorize({
@@ -66,32 +59,7 @@ export class BillingCustomerController {
     customerDto: Omit<CustomerDto, 'id'>,
     @param.header.string('tenantId') tenantId: string,
   ): Promise<CustomerDto> {
-    const customer = await this.billingProvider.createCustomer(customerDto);
-    await this.billingCustomerRepository.create(
-      new BillingCustomer({
-        tenantId,
-        customerId: customer.id,
-      }),
-    );
-    return new CustomerDto({
-      id: customer.id,
-      firstName: customer.firstName,
-      lastName: customer.lastName,
-      email: customer.email,
-      company: customer.company,
-      phone: customer.phone,
-      billingAddress: new AddressDto({
-        firstName: customer.billingAddress?.firstName,
-        lastName: customer.billingAddress?.lastName,
-        email: customer.billingAddress?.email,
-        company: customer.billingAddress?.company,
-        phone: customer.billingAddress?.phone,
-        city: customer.billingAddress?.city,
-        state: customer.billingAddress?.state,
-        zip: customer.billingAddress?.zip,
-        country: customer.billingAddress?.country,
-      }),
-    });
+    return this.billingCustomerService.createCustomer(customerDto, tenantId);
   }
 
   @authorize({
@@ -112,35 +80,7 @@ export class BillingCustomerController {
   async getCustomer(
     @param.filter(BillingCustomer) filter?: Filter<BillingCustomer>,
   ): Promise<{customerDetails: CustomerDto; info: BillingCustomer}> {
-    const customers = await this.billingCustomerRepository.find(filter);
-    if (customers.length === 0) {
-      throw new Error('Customer is not present');
-    }
-
-    const customer = await this.billingProvider.getCustomers(
-      customers[0].customerId,
-    );
-    return {
-      customerDetails: new CustomerDto({
-        firstName: customer.firstName,
-        lastName: customer.lastName,
-        email: customer.email,
-        company: customer.company,
-        phone: customer.phone,
-        billingAddress: new AddressDto({
-          firstName: customer.billingAddress?.firstName,
-          lastName: customer.billingAddress?.lastName,
-          email: customer.billingAddress?.email,
-          company: customer.billingAddress?.company,
-          phone: customer.billingAddress?.phone,
-          city: customer.billingAddress?.city,
-          state: customer.billingAddress?.state,
-          zip: customer.billingAddress?.zip,
-          country: customer.billingAddress?.country,
-        }),
-      }),
-      info: customers[0],
-    };
+    return this.billingCustomerService.getCustomer(filter);
   }
 
   @authorize({
@@ -168,15 +108,8 @@ export class BillingCustomerController {
     })
     customerDto: Partial<CustomerDto>,
   ): Promise<void> {
-    const customers = await this.billingCustomerRepository.find({
-      where: {tenantId: tenantId},
-    });
-
-    if (customers.length === 0) {
-      throw new Error(`Customer with tenantId ${tenantId} is not present`);
-    }
-    await this.billingProvider.updateCustomerById(
-      customers[0].customerId,
+    return this.billingCustomerService.updateCustomerByTenantId(
+      tenantId,
       customerDto,
     );
   }
@@ -198,14 +131,6 @@ export class BillingCustomerController {
   async deleteById(
     @param.path.string('tenantId') tenantId: string,
   ): Promise<void> {
-    const customer = await this.billingCustomerRepository.find({
-      where: {tenantId: tenantId},
-    });
-    if (customer.length === 0) {
-      throw new Error(' Customer with tenantId is not present');
-    }
-    await this.billingProvider.deleteCustomer(customer[0].customerId);
-    await this.invoiceRepository.deleteAll({billingCustomerId: customer[0].id});
-    await this.billingCustomerRepository.deleteById(customer[0].id);
+    return this.billingCustomerService.deleteCustomerByTenantId(tenantId);
   }
 }

services/subscription-service/src/controllers/billing-invoice.controller.ts

@@ -1,6 +1,5 @@
 import {BillingComponentBindings, IService} from 'loopback4-billing';
-import {inject} from '@loopback/core';
-import {repository} from '@loopback/repository';
+import {inject, service} from '@loopback/core';
 import {
   del,
   get,
@@ -13,22 +12,18 @@ import {
 import {OPERATION_SECURITY_SPEC, STATUS_CODE} from '@sourceloop/core';
 import {authenticate, STRATEGY} from 'loopback4-authentication';
 import {authorize} from 'loopback4-authorization';
-import {AddressDto, ChargeDto} from '../models';
 import {InvoiceDto} from '../models/dto/invoice-dto.model';
 import {TransactionDto} from '../models/dto/transaction-dto.model';
 import {PermissionKey} from '../permissions';
-import {InvoiceRepository} from '../repositories';
-import {BillingCustomerRepository} from '../repositories/billing-customer.repository';
+import {BillingInvoiceService} from '../services/billing-invoice.service';
 
 const basePath = '/billing-invoice';
 export class BillingInvoiceController {
   constructor(
-    @repository(BillingCustomerRepository)
-    public billingCustomerRepository: BillingCustomerRepository,
-    @repository(InvoiceRepository)
-    public invoiceRepository: InvoiceRepository,
     @inject(BillingComponentBindings.BillingProvider)
     private readonly billingProvider: IService,
+    @service(BillingInvoiceService)
+    public billingInvoiceService: BillingInvoiceService,
   ) {}
 
   @authorize({
@@ -59,43 +54,7 @@ export class BillingInvoiceController {
     })
     invoiceDto: Omit<InvoiceDto, 'id' | 'status'>,
   ): Promise<InvoiceDto> {
-    const customer = await this.billingCustomerRepository.find({
-      where: {customerId: invoiceDto.customerId},
-    });
-
-    if (customer.length === 0) {
-      throw new Error(' Customer with tenantId is not present');
-    }
-    const invoice = await this.billingProvider.createInvoice(invoiceDto);
-    const charges = invoice.charges?.map(
-      charge =>
-        new ChargeDto({amount: charge.amount, description: charge.description}),
-    );
-
-    const invoiceInfo = await this.invoiceRepository.create({
-      invoiceId: invoice.id,
-      invoiceStatus: invoice.status,
-      billingCustomerId: customer[0].id,
-    });
-    return new InvoiceDto({
-      id: invoiceInfo.id, // passed the id of invoice info created in our db, to setup relation between subscription and invoice
-      customerId: invoice.customerId,
-      charges: charges,
-      status: invoice.status,
-      shippingAddress: new AddressDto({
-        firstName: invoice.shippingAddress?.firstName ?? '',
-        lastName: invoice.shippingAddress?.lastName ?? '',
-        email: invoice.shippingAddress?.email ?? '',
-        company: invoice.shippingAddress?.company,
-        phone: invoice.shippingAddress?.phone,
-        city: invoice.shippingAddress?.city ?? '',
-        state: invoice.shippingAddress?.state ?? '',
-        zip: invoice.shippingAddress?.zip ?? '',
-        country: invoice.shippingAddress?.country ?? '',
-      }),
-      options: invoice.options,
-      currencyCode: invoice.currencyCode,
-    });
+    return this.billingInvoiceService.createInvoice(invoiceDto);
   }
 
   @authorize({
@@ -116,28 +75,7 @@ export class BillingInvoiceController {
   async getInvoice(
     @param.path.string('invoiceId') invoiceId: string,
   ): Promise<InvoiceDto> {
-    const invoice = await this.billingProvider.retrieveInvoice(invoiceId);
-    const charges = invoice.charges?.map(
-      charge =>
-        new ChargeDto({amount: charge.amount, description: charge.description}),
-    );
-    return new InvoiceDto({
-      customerId: invoice.customerId,
-      charges: charges,
-      status: invoice.status,
-      shippingAddress: new AddressDto({
-        firstName: invoice.shippingAddress?.firstName ?? '',
-        lastName: invoice.shippingAddress?.lastName ?? '',
-        email: invoice.shippingAddress?.email ?? '',
-        company: invoice.shippingAddress?.company,
-        phone: invoice.shippingAddress?.phone,
-        city: invoice.shippingAddress?.city ?? '',
-        state: invoice.shippingAddress?.state ?? '',
-        zip: invoice.shippingAddress?.zip ?? '',
-        country: invoice.shippingAddress?.country ?? '',
-      }),
-      options: invoice.options,
-    });
+    return this.billingInvoiceService.getInvoice(invoiceId);
   }
 
   @authorize({
@@ -193,11 +131,7 @@ export class BillingInvoiceController {
     })
     transactionDto: TransactionDto,
   ): Promise<void> {
-    const invoiceInfo = await this.invoiceRepository.findById(invoiceId);
-    await this.billingProvider.applyPaymentSourceForInvoice(
-      invoiceInfo.invoiceId,
-      transactionDto,
-    );
+    return this.billingInvoiceService.applyPayment(invoiceId, transactionDto);
   }
 
   @authorize({
@@ -217,12 +151,6 @@ export class BillingInvoiceController {
   async deleteById(
     @param.path.string('invoiceId') invoiceId: string,
   ): Promise<void> {
-    const invoice = await this.invoiceRepository.find({
-      where: {invoiceId: invoiceId},
-    });
-    if (invoice.length === 0)
-      throw new Error(' invoice with invoiceId is not present');
-    await this.billingProvider.deleteInvoice(invoiceId);
-    await this.invoiceRepository.deleteById(invoice[0].id);
+    return this.billingInvoiceService.deleteInvoice(invoiceId);
   }
 }