taxtank 0.1.0

package/projects/tt-core/src/lib/services/http/sole/bas-report/index.ts

@@ -0,0 +1,2 @@
+export * from './bas-report-messages.enum';
+export * from './bas-report.service';

package/projects/tt-core/src/lib/services/http/sole/index.ts

@@ -0,0 +1,10 @@
+export * from './sole-business';
+export * from './sole-business-activity/sole-business-activity.service';
+export * from './sole-business-loss/sole-business-loss.service';
+export * from './sole-business-loss/sole-business-loss-rules/sole-business-loss-offset-rule.service';
+export * from './sole-contact/sole-contact.service';
+export * from './sole-depreciation-method/sole-depreciation-method.service';
+export * from './sole-details/sole-details.service';
+export * from './sole-invoice/sole-invoice.service';
+export * from './sole-invoice-template/sole-invoice-template.service';
+export * from './bas-report';

package/projects/tt-core/src/lib/services/http/sole/sole-business/index.ts

@@ -0,0 +1,2 @@
+export * from './sole-business-messages.enum';
+export * from './sole-business.service';

package/projects/tt-core/src/lib/services/http/sole/sole-business/sole-business-messages.enum.ts

@@ -0,0 +1,3 @@
+export enum SoleBusinessMessagesEnum {
+  LOGO_UPDATED = 'Logo updated successfully'
+}

package/projects/tt-core/src/lib/services/http/sole/sole-business/sole-business.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { SoleBusinessService } from './sole-business.service';
+
+describe('SoleBusinessService', () => {
+  let service: SoleBusinessService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(SoleBusinessService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/projects/tt-core/src/lib/services/http/sole/sole-business/sole-business.service.ts

@@ -0,0 +1,16 @@
+import { Injectable } from '@angular/core';
+import { RestService } from '../../rest';
+import { SoleBusiness as SoleBusinessBase } from '../../../../db/Models/sole/sole-business';
+import { SoleBusiness } from '../../../../models';
+import { Collection } from '../../../../collections';
+import { UserRolesEnum } from 'taxtank-core/common';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class SoleBusinessService extends RestService<SoleBusinessBase, SoleBusiness, Collection<SoleBusiness>> {
+  modelClass: typeof SoleBusiness = SoleBusiness;
+  collectionClass: typeof Collection = Collection;
+  endpointUri = 'sole-businesses';
+  roles = [UserRolesEnum.SOLE_TANK];
+}

package/projects/tt-core/src/lib/services/http/sole/sole-business-activity/sole-business-activity.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { SoleBusinessActivityService } from './sole-business-activity.service';
+
+describe('SoleBusinessActivityService', () => {
+  let service: SoleBusinessActivityService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(SoleBusinessActivityService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/projects/tt-core/src/lib/services/http/sole/sole-business-activity/sole-business-activity.service.ts

@@ -0,0 +1,12 @@
+import { Injectable } from '@angular/core';
+import { RestService } from '../../rest/rest-old.service';
+import { SoleBusinessActivity as SoleBusinessActivityBase } from '../../../../db/Models/sole/sole-business-activity';
+import { SoleBusinessActivity } from '../../../../models';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class SoleBusinessActivityService extends RestService<SoleBusinessActivityBase, SoleBusinessActivity>{
+  modelClass: typeof SoleBusinessActivity = SoleBusinessActivity;
+  url = 'sole-business-activities';
+}

package/projects/tt-core/src/lib/services/http/sole/sole-business-loss/sole-business-loss-rules/sole-business-loss-offset-rule.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { SoleBusinessLossOffsetRuleService } from './sole-business-loss-offset-rule.service';
+
+describe('SoleBusinessLossOffsetRuleService', () => {
+  let service: SoleBusinessLossOffsetRuleService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(SoleBusinessLossOffsetRuleService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/projects/tt-core/src/lib/services/http/sole/sole-business-loss/sole-business-loss-rules/sole-business-loss-offset-rule.service.ts

@@ -0,0 +1,14 @@
+import { Injectable } from '@angular/core';
+import { RestService } from '../../../rest/rest-old.service';
+import { SoleBusinessLossOffsetRule } from '../../../../../models';
+
+/**
+ * @TODO vik replace with json when the final list is confirmed
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class SoleBusinessLossOffsetRuleService extends RestService<SoleBusinessLossOffsetRule, SoleBusinessLossOffsetRule> {
+  modelClass: typeof SoleBusinessLossOffsetRule = SoleBusinessLossOffsetRule;
+  url = 'sole-business-loss-offset-rules';
+}

package/projects/tt-core/src/lib/services/http/sole/sole-business-loss/sole-business-loss.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { SoleBusinessLossService } from './sole-business-loss.service';
+
+describe('SoleBusinessLossService', () => {
+  let service: SoleBusinessLossService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(SoleBusinessLossService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/projects/tt-core/src/lib/services/http/sole/sole-business-loss/sole-business-loss.service.ts

@@ -0,0 +1,36 @@
+import { Inject, Injectable } from '@angular/core';
+import { SoleBusinessLoss as SoleBusinessLossBase } from '../../../../db/Models/sole/sole-business-loss';
+import { SoleBusiness, SoleBusinessLoss } from '../../../../models';
+import { IEventListener } from '../../../../interfaces';
+import { SoleBusinessLossCollection } from '../../../../collections';
+import { RestMethod, RestService } from '../../rest';
+import { UserRolesEnum } from 'taxtank-core/common';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class SoleBusinessLossService extends RestService<SoleBusinessLossBase, SoleBusinessLoss, SoleBusinessLossCollection> implements IEventListener {
+  modelClass = SoleBusinessLoss;
+  collectionClass = SoleBusinessLossCollection;
+  endpointUri = 'sole-business-losses';
+  disabledMethods: RestMethod[] = ['postBatch', 'putBatch', 'deleteBatch', 'delete'];
+  roles = [UserRolesEnum.SOLE_TANK];
+
+  constructor(@Inject('environment') protected environment: any) {
+    super(environment);
+    this.listenEvents();
+  }
+
+  listenEvents(): void {
+    this.listenBusinessCreated();
+  }
+
+  /**
+   * Listen business created because we create prior year losses together with business
+   */
+  private listenBusinessCreated() {
+    this.eventDispatcherService.on2(SoleBusiness.getEventName('post')).subscribe(() => {
+      this.refreshCache();
+    })
+  }
+}

package/projects/tt-core/src/lib/services/http/sole/sole-contact/sole-contact.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { SoleContactService } from './sole-contact.service';
+
+describe('SoleContactService', () => {
+  let service: SoleContactService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(SoleContactService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/projects/tt-core/src/lib/services/http/sole/sole-contact/sole-contact.service.ts

@@ -0,0 +1,12 @@
+import { Injectable } from '@angular/core';
+import { RestService } from '../../rest/rest-old.service';
+import { SoleContact as SoleContactBase } from '../../../../db/Models/sole/sole-contact';
+import { SoleContact } from '../../../../models';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class SoleContactService extends RestService<SoleContactBase, SoleContact> {
+  modelClass: typeof SoleContact = SoleContact;
+  url = 'sole-contacts';
+}

package/projects/tt-core/src/lib/services/http/sole/sole-depreciation-method/sole-depreciation-method.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { SoleDepreciationMethodService } from './sole-depreciation-method.service';
+
+describe('SoleDepreciationMethodService', () => {
+  let service: SoleDepreciationMethodService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(SoleDepreciationMethodService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/projects/tt-core/src/lib/services/http/sole/sole-depreciation-method/sole-depreciation-method.service.ts

@@ -0,0 +1,84 @@
+import { Inject, Injectable } from '@angular/core';
+import { HttpClient, HttpErrorResponse } from '@angular/common/http';
+import { SoleDepreciationMethod, SoleDetails } from '../../../../models';
+import { SoleDepreciationMethod as SoleDepreciationMethodBase } from '../../../../db/Models/sole/sole-depreciation-method';
+import { Observable, ReplaySubject } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import { EventDispatcherService } from '../../../event';
+import { AppEvent, AppEventTypeEnum } from '../../../../models';
+import { throwError as observableThrowError } from 'rxjs';
+import { ToastService } from '../../../toast';
+import { IEventListener } from '../../../../interfaces';
+
+/**
+ * @TODO Alex: extend rest service when refactored
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class SoleDepreciationMethodService implements IEventListener {
+  cache: SoleDepreciationMethod;
+  cacheSubject: ReplaySubject<SoleDepreciationMethod> = new ReplaySubject<SoleDepreciationMethod>(1);
+  url = 'sole-depreciation-methods';
+
+  constructor(
+    private http: HttpClient,
+    @Inject('environment') private environment: any,
+    private eventDispatcherService: EventDispatcherService,
+    private toastService: ToastService
+  ) {
+    this.listenEvents();
+  }
+
+  listenEvents(): void {
+    this.listenSoleDetailsChanges();
+  }
+
+  get(): Observable<SoleDepreciationMethod> {
+    if (!this.cache) {
+      this.http.get(`${this.environment.apiV2}/${this.url}`)
+        .pipe(
+          map((response: object[]): SoleDepreciationMethod => plainToClass(SoleDepreciationMethod, response[0]))
+        )
+        .subscribe((soleDepreciationMethod: SoleDepreciationMethod): SoleDepreciationMethod => {
+          this.cache = soleDepreciationMethod;
+          this.cacheSubject.next(this.cache);
+
+          return soleDepreciationMethod;
+        });
+    }
+
+    return this.cacheSubject.asObservable();
+  }
+
+  update(soleDepreciationMethod: SoleDepreciationMethod): Observable<SoleDepreciationMethod> {
+    return this.http.put(`${this.environment.apiV2}/${this.url}/${soleDepreciationMethod.id}`, soleDepreciationMethod)
+      .pipe(
+        map((soleDepreciationMethodBase: SoleDepreciationMethodBase): SoleDepreciationMethod => {
+          const method: SoleDepreciationMethod = plainToClass(SoleDepreciationMethod, soleDepreciationMethodBase);
+
+          this.cache = method;
+          this.cacheSubject.next(this.cache);
+
+          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.SOLE_DEPRECIATION_METHOD_UPDATED, method));
+
+          return this.cache;
+        }),
+        catchError((error: HttpErrorResponse) => {
+          // @TODO test
+          this.toastService.error(error.error['detail']);
+
+          return observableThrowError(error);
+        })
+      );
+  }
+
+  private listenSoleDetailsChanges(): void {
+    this.eventDispatcherService.on2(...SoleDetails.getEventNames('post', 'put'))
+      .subscribe(() => {
+        this.cache = null;
+        this.get().subscribe();
+      });
+  }
+}

package/projects/tt-core/src/lib/services/http/sole/sole-details/sole-details.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { SoleDetailsService } from './sole-details.service';
+
+describe('SoleDetailsService', () => {
+  let service: SoleDetailsService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(SoleDetailsService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/projects/tt-core/src/lib/services/http/sole/sole-details/sole-details.service.ts

@@ -0,0 +1,27 @@
+import { Injectable } from '@angular/core';
+import { SoleDetails } from '../../../../models';
+import { SoleDetails as SoleDetailsBase } from '../../../../db/Models/sole/sole-details';
+import { RestMethod, RestService } from '../../rest';
+import { Collection } from '../../../../collections';
+import { UserRolesEnum } from 'taxtank-core/common';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+
+/**
+ * @TODO TT-1777 Alex: extend from rest service when it refactored
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class SoleDetailsService extends RestService<SoleDetailsBase, SoleDetails, Collection<SoleDetails>> {
+  modelClass = SoleDetails;
+  collectionClass = Collection;
+  endpointUri = 'sole-details';
+  disabledMethods: RestMethod[] = ['postBatch', 'putBatch', 'deleteBatch'];
+  roles = [UserRolesEnum.SOLE_TANK];
+
+  get(): Observable<Collection<SoleDetails>> {
+    return super.get().pipe(map(soleDetails => soleDetails.length ? soleDetails : new Collection([plainToClass(SoleDetails, {})])));
+  }
+}

package/projects/tt-core/src/lib/services/http/sole/sole-invoice/sole-invoice.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { SoleInvoiceService } from './sole-invoice.service';
+
+describe('SoleInvoiceService', () => {
+  let service: SoleInvoiceService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(SoleInvoiceService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/projects/tt-core/src/lib/services/http/sole/sole-invoice/sole-invoice.service.ts

@@ -0,0 +1,45 @@
+import { Inject, Injectable } from '@angular/core';
+import { RestService } from '../../rest';
+import { SoleInvoice as SoleInvoiceBase } from '../../../../db/Models/sole/sole-invoice';
+import { SoleInvoice } from '../../../../models';
+import { SoleInvoiceStatusesEnum } from '../../../../db/Enums';
+import { Observable } from 'rxjs';
+import { UserRolesEnum } from 'taxtank-core/common';
+import { SoleInvoiceCollection } from '../../../../collections';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class SoleInvoiceService extends RestService<SoleInvoiceBase, SoleInvoice, SoleInvoiceCollection> {
+  endpointUri = 'sole-invoices';
+  modelClass: typeof SoleInvoice = SoleInvoice;
+  collectionClass = SoleInvoiceCollection;
+  roles = [UserRolesEnum.SOLE_TANK];
+
+  constructor(@Inject('environment') protected environment: any) {
+    super(environment);
+  }
+
+  updateStatus(invoice: SoleInvoice, status: SoleInvoiceStatusesEnum): Observable<SoleInvoice> {
+    // @TODO use id only to avoid unexpected changes
+    return this.put(Object.assign({}, invoice, { status }));
+  }
+
+  send(invoice: SoleInvoice, file: File) {
+    const formData: FormData = new FormData();
+    formData.append('file', file);
+
+    return this.http.post(`${this.environment.apiV2}/${this.endpointUri}/${invoice.id}/send`, formData);
+  }
+
+  /**
+   * Return the next number from the last invoice
+   */
+  getNewInvoiceNumber(): number {
+    if (!this.cache.length) {
+      return 1;
+    }
+
+    return this.cache.last.number + 1;
+  }
+}

package/projects/tt-core/src/lib/services/http/sole/sole-invoice-template/sole-invoice-template.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { SoleInvoiceTemplateService } from './sole-invoice-template.service';
+
+describe('SoleInvoiceTemplateService', () => {
+  let service: SoleInvoiceTemplateService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(SoleInvoiceTemplateService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/projects/tt-core/src/lib/services/http/sole/sole-invoice-template/sole-invoice-template.service.ts

@@ -0,0 +1,12 @@
+import { Injectable } from '@angular/core';
+import { RestService } from '../../rest/rest-old.service';
+import { SoleInvoiceTemplate as SoleInvoiceTemplateBase } from '../../../../db/Models/sole/sole-invoice-template';
+import { SoleInvoiceTemplate } from '../../../../models';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class SoleInvoiceTemplateService extends RestService<SoleInvoiceTemplateBase, SoleInvoiceTemplate>{
+  modelClass: typeof SoleInvoiceTemplate = SoleInvoiceTemplate;
+  url = 'sole-invoice-templates';
+}

package/projects/tt-core/src/lib/services/http/subscription/index.ts

@@ -0,0 +1,6 @@
+export * from './service-payment/service-payment.service';
+export * from './service-payment-method/service-payment-method.service';
+export * from './service-price/service-price.service';
+export * from './service-subscription/subscription.service';
+export * from './service-subscription/subscription-messages.enum';
+export * from './service-product/service-product.service';

package/projects/tt-core/src/lib/services/http/subscription/service-payment/service-payment.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { ServicePaymentService } from './service-payment.service';
+
+describe('ServicePaymentService', () => {
+  let service: ServicePaymentService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(ServicePaymentService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/projects/tt-core/src/lib/services/http/subscription/service-payment/service-payment.service.ts

@@ -0,0 +1,27 @@
+import { Injectable } from '@angular/core';
+import { Collection } from '../../../../collections';
+import { RestMethod, RestService } from '../../rest';
+import { ServicePayment } from '../../../../models';
+import { ServicePayment as ServicePaymentBase } from '../../../../db/Models';
+import { Observable, of } from 'rxjs';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class ServicePaymentService extends RestService<ServicePaymentBase, ServicePayment, Collection<ServicePayment>>{
+  endpointUri = 'service-payments';
+  modelClass: typeof ServicePayment = ServicePayment;
+  collectionClass: typeof Collection = Collection;
+  disabledMethods: RestMethod[] = ['post', 'put', 'putBatch', 'delete', 'deleteBatch'];
+
+  /**
+   * Stripe stores actual links to payment invoices for 30 days. After that, we need to request an actual link
+   */
+  getInvoiceUrl(payment: ServicePayment): Observable<string> {
+    if (!payment.isInvoiceLinkExpired()) {
+      return of(payment.receipt);
+    }
+
+    return this.http.get(`${this.environment.apiV2}/service-payments/${payment.id}/invoice-url`) as Observable<string>;
+  }
+}

package/projects/tt-core/src/lib/services/http/subscription/service-payment-method/service-payment-method.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { ServicePaymentMethodService } from './service-payment-method.service';
+
+describe('ServicePaymentMethodService', () => {
+  let service: ServicePaymentMethodService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(ServicePaymentMethodService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/projects/tt-core/src/lib/services/http/subscription/service-payment-method/service-payment-method.service.ts

@@ -0,0 +1,46 @@
+import { Inject, Injectable } from '@angular/core';
+import { RestService } from '../../rest';
+import { ServicePaymentMethod as ServicePaymentMethodBase } from '../../../../db/Models/subscription/service-payment-method';
+import { ServicePaymentMethod } from '../../../../models';
+import { Collection } from '../../../../collections';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import { IEventListener } from '../../../../interfaces';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class ServicePaymentMethodService extends RestService<ServicePaymentMethodBase, ServicePaymentMethod, Collection<ServicePaymentMethod>> implements IEventListener {
+  protected endpointUri = 'service-payment-methods';
+  collectionClass: typeof Collection = Collection;
+  modelClass: typeof ServicePaymentMethod = ServicePaymentMethod;
+  mercureTopic = 'servicePaymentMethods';
+
+  constructor(@Inject('environment') protected environment: any) {
+    super(environment);
+    this.listenEvents();
+  }
+
+  listenEvents() {
+    // @TODO remove when TT-3826 is ready
+    this.listenSSE();
+  }
+
+  /**
+   * Get Stripe client secret required for Payment form initialization
+   */
+  getSecret(): Observable<string> {
+    return this.http.get(`${this.apiUrl}/setup-intent-secret`)
+      .pipe(
+        map((response) => response as string)
+      );
+  }
+
+  setAsDefault(paymentMethod: ServicePaymentMethod): Observable<ServicePaymentMethod> {
+    return this.http.put(`${this.apiUrl}/${paymentMethod.id}/default`, {})
+      .pipe(
+        map((updatedPaymentMethod: ServicePaymentMethodBase) => plainToClass(ServicePaymentMethod, updatedPaymentMethod))
+      );
+  }
+}

package/projects/tt-core/src/lib/services/http/subscription/service-price/service-price.service.ts

@@ -0,0 +1,18 @@
+import { Injectable } from '@angular/core';
+import { ServicePrice as ServicePriceBase } from '../../../../db/Models';
+import { ServicePrice } from '../../../../models';
+import { RestMethod, RestService } from '../../rest';
+import { ServicePriceCollection } from '../../../../collections';
+
+/**
+ * Service that handling banks logic
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class ServicePriceService extends RestService<ServicePriceBase, ServicePrice, ServicePriceCollection> {
+  protected endpointUri = 'service-prices';
+  modelClass: typeof ServicePrice = ServicePrice;
+  collectionClass: typeof ServicePriceCollection = ServicePriceCollection;
+  disabledMethods: RestMethod[] = ['post', 'postBatch', 'put', 'putBatch', 'delete', 'deleteBatch'];
+}

package/projects/tt-core/src/lib/services/http/subscription/service-product/service-product.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { ServiceProductService } from './service-product.service';
+
+describe('ServiceProductService', () => {
+  let service: ServiceProductService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(ServiceProductService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/projects/tt-core/src/lib/services/http/subscription/service-product/service-product.service.ts

@@ -0,0 +1,15 @@
+import { Injectable } from '@angular/core';
+import { RestMethod, RestService } from '../../rest';
+import { ServiceProduct as ServiceProductBase } from '../../../../db/Models';
+import { ServiceProduct } from '../../../../models';
+import { ServiceProductCollection } from '../../../../collections';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class ServiceProductService extends RestService<ServiceProductBase, ServiceProduct, ServiceProductCollection>{
+  collectionClass: typeof ServiceProductCollection = ServiceProductCollection;
+  modelClass: typeof ServiceProduct = ServiceProduct;
+  protected endpointUri = 'service-products';
+  disabledMethods: RestMethod[] = ['post', 'postBatch', 'put', 'putBatch', 'delete', 'deleteBatch'];
+}

package/projects/tt-core/src/lib/services/http/subscription/service-subscription/subscription-messages.enum.ts

@@ -0,0 +1,8 @@
+export enum SubscriptionMessagesEnum {
+  PROMOCODE_ERROR = 'This promo code can’t be applied to your subscription. Please contact support.',
+  SUCCEEDED = 'Success! Payment received.',
+  SUCCEEDED_FREE = `Success! We'll update you soon.`,
+  PROCESSING = `Payment processing. We'll update you when payment is received.`,
+  REQUIRES_PAYMENT_METHOD = 'Payment failed. Please try another payment method.',
+  ERROR = 'Something went wrong.'
+}

package/projects/tt-core/src/lib/services/http/subscription/service-subscription/subscription.service.spec.ts

@@ -0,0 +1,12 @@
+import { TestBed } from '@angular/core/testing';
+
+import { SubscriptionService } from './subscription.service';
+
+describe('SubscriptionService', () => {
+  beforeEach(() => TestBed.configureTestingModule({}));
+
+  it('should be created', () => {
+    const service: SubscriptionService = TestBed.get(SubscriptionService);
+    expect(service).toBeTruthy();
+  });
+});