taxtank-core 0.0.1 → 0.1.1

package/src/lib/services/property/property-document.service.ts

@@ -0,0 +1,74 @@
+import { Inject, Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { PropertyDocument as PropertyDocumentBase } from '../../db/Models/property-document';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import { HttpClient } from '@angular/common/http';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import { PropertyDocument } from '../../models/property/property-document';
+import { BaseRestService } from '../base-rest.service';
+import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
+import { Property } from '../../models/property/property';
+
+/**
+ * Class for work with Property Documents
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class PropertyDocumentService extends BaseRestService<PropertyDocumentBase, PropertyDocument> {
+  modelClass: typeof PropertyDocument = PropertyDocument;
+  url: string = 'properties/documents';
+
+   constructor(
+     protected http: HttpClient,
+     protected eventDispatcherService: EventDispatcherService,
+     @Inject('environment') protected environment: any
+   ) {
+     super(http, eventDispatcherService, environment);
+     this.listenEvents();
+   }
+
+  /**
+   * Add new Property Document
+   */
+  upload(file: File, propertyId: number): Observable<PropertyDocument> {
+    // create formData object with provided file
+    const formDataDocument: FormData = new FormData();
+    formDataDocument.append('file', file);
+
+    return this.http.post(`${this.environment.apiV2}/properties/${propertyId}/documents`, formDataDocument).pipe(
+      map((documentBase: PropertyDocumentBase): PropertyDocument => {
+        const newDocument: PropertyDocument = plainToClass(PropertyDocument, documentBase);
+
+        this.cache.push(newDocument);
+        this.updateCache();
+        return newDocument;
+      })
+    );
+  }
+
+  /**
+   * Get documents by property id
+   * @param propertyId to get desired documents
+   */
+  getByPropertyId(propertyId: number): Observable<PropertyDocument[]> {
+    return this.get()
+      .pipe(
+        map((documents: PropertyDocument[]) => {
+          return documents
+            .filter((document: PropertyDocument) => document.property.id === propertyId);
+        })
+      );
+  }
+
+  private listenEvents(): void {
+    this.listenPropertyUpdateWithDocument();
+  }
+
+  private listenPropertyUpdateWithDocument(): void {
+    this.eventDispatcherService.on(AppEventTypeEnum.PROPERTY_UPDATED_WITH_DOCUMENT).subscribe((property: Property): void => {
+      this.upload(property.documentFile, property.id).subscribe();
+    });
+  }
+}

package/src/lib/services/property/property-owner.service.spec.ts

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

package/src/lib/services/property/property-owner.service.ts

@@ -0,0 +1,134 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { Observable } from 'rxjs';
+import { PropertyOwner as PropertyOwnerBase } from '../../db/Models/property-owner';
+import { replace } from '../../functions/array';
+import { HttpClient } from '@angular/common/http';
+import { plainToClass } from 'class-transformer';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import { PropertyOwner } from '../../models/property/property-owner';
+import { BaseRestService } from '../base-rest.service';
+import { AppEvent } from '../../models/event/app-event';
+import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
+
+// @TODO check and improve logic during refactoring
+@Injectable({
+  providedIn: 'root'
+})
+export class PropertyOwnerService extends BaseRestService<PropertyOwnerBase, PropertyOwner> {
+  // api url parameter for properties co-owners
+  url: string = 'properties/co-owners';
+  modelClass = PropertyOwner;
+
+  constructor(
+    protected http: HttpClient,
+    protected eventDispatcherService: EventDispatcherService,
+    @Inject('environment') protected environment: any
+  ) {
+    super(http, eventDispatcherService, environment);
+    this.listenEvents();
+  }
+
+  /**
+   * Listen to Event Dispatcher events
+   */
+  listenEvents(): void {
+    this.listenUserUpdated();
+  }
+
+  /**
+   * Updated loan
+   */
+  update(propertyOwner: PropertyOwner): Observable<PropertyOwner> {
+    return this.http.put(`${this.environment.apiV2}/${this.url}/${propertyOwner.id}`, propertyOwner)
+      .pipe(
+        map((updatedPropertyOwnerBase: PropertyOwnerBase) => {
+          const updatedPropertyOwner: PropertyOwner = plainToClass(PropertyOwner, updatedPropertyOwnerBase);
+          // if loan type is NOT vehicle - fire EventDispatcher event
+          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.PROPERTY_OWNER_UPDATED, null));
+
+          replace(this.cache, updatedPropertyOwner);
+          this.updateCache();
+          return updatedPropertyOwner;
+        })
+      );
+  }
+
+  /**
+   * Re-invite property owner
+   * @param share user to share property
+   */
+  reinvite(share: PropertyOwner): Observable<object> {
+    return this.http.post(`${this.environment.apiV2}/${this.url}/${share.id}/reinvite`, {});
+  }
+
+  /**
+   * Get incoming property owners list
+   */
+  getIncoming(): Observable<PropertyOwner[]> {
+    return this.get()
+      .pipe(map((propertyOwners: PropertyOwner[]) => {
+        const propertyOwnersIncoming: PropertyOwner[] = [];
+
+        propertyOwners.forEach((propertyOwner: PropertyOwner) => {
+          if (propertyOwner.user?.isLoggedIn() && propertyOwner.isPending() && propertyOwner.property.user.id !== +localStorage.getItem('userId')) {
+            propertyOwnersIncoming.push(propertyOwner);
+          }
+        });
+
+        return propertyOwnersIncoming;
+      }));
+  }
+
+  /**
+   * Get outcoming property owners list
+   */
+  getOutcoming(): Observable<PropertyOwner[]> {
+    return this.get().pipe(
+      map((propertyOwners: PropertyOwner[]): PropertyOwner[] => {
+        return this.filterOutcoming(propertyOwners);
+      })
+    );
+  }
+
+  /**
+   * Filter outcoming property owners
+   * @param propertyOwners which should be filtered
+   */
+  filterOutcoming(propertyOwners: PropertyOwner[]): PropertyOwner[] {
+    const propertyOwnersOutcoming: PropertyOwner[] = [];
+
+    propertyOwners.forEach((propertyOwner: PropertyOwner) => {
+      if (!propertyOwner.user?.isLoggedIn()) {
+        propertyOwnersOutcoming.push(propertyOwner);
+      }
+    });
+
+    return propertyOwnersOutcoming;
+  }
+
+  /**
+   * Get list of co-owners filtered by property id
+   * @param propertyId
+   */
+  getByPropertyId(propertyId: number): Observable<PropertyOwner[]> {
+    return this.get()
+      .pipe(
+        map((propertyOwners: PropertyOwner[]) => {
+        return propertyOwners.filter((propertyOwner: PropertyOwner) => propertyOwner.property.id === propertyId);
+      }));
+  }
+
+  /**
+   * Listen to User updated event
+   */
+  private listenUserUpdated(): void {
+    this.eventDispatcherService.on(AppEventTypeEnum.USER_UPDATED)
+      .subscribe((): void => {
+        this.fetch().subscribe((propertyOwners: PropertyOwner[]) => {
+          this.cache = propertyOwners;
+          this.updateCache();
+        });
+      });
+  }
+}

package/src/lib/services/property/property-sold.service.spec.ts

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

package/src/lib/services/property/property-sold.service.ts

@@ -0,0 +1,15 @@
+import { Injectable } from '@angular/core';
+import { PropertySold as PropertySoldBase } from '../../db/Models/property-sold';
+import { PropertySold } from '../../models/property/property-sold';
+import { BaseRestService } from '../base-rest.service';
+
+/**
+ * Service for work with Property Sold
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class PropertySoldService extends BaseRestService<PropertySoldBase, PropertySold> {
+  modelClass: typeof PropertySold = PropertySold;
+  url: string = 'properties/sold';
+}

package/src/lib/services/property/property.service.spec.ts

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

package/src/lib/services/property/property.service.ts

@@ -0,0 +1,136 @@
+import { Inject, Injectable } from '@angular/core';
+import { Property as PropertyBase } from '../../db/Models/property';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { replace } from '../../functions/array';
+import { HttpClient } from '@angular/common/http';
+import { plainToClass } from 'class-transformer';
+import { PropertySubscription as PropertySubscriptionBase } from '../../db/Models/property-subscription';
+import { BaseRestService } from '../base-rest.service';
+import { Property } from '../../models/property/property';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
+import { AppEvent } from '../../models/event/app-event';
+import { PropertySubscription } from '../../models/property/property-subscription';
+
+/**
+ * Service for work with Property
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class PropertyService extends BaseRestService<PropertyBase, Property> {
+  modelClass: typeof Property = Property;
+  url: string = 'properties';
+
+  constructor(
+    protected http: HttpClient,
+    protected eventDispatcherService: EventDispatcherService,
+    @Inject('environment') protected environment: any
+  ) {
+    super(http, eventDispatcherService, environment);
+    this.listenEvents();
+  }
+
+  listenEvents(): void {
+    this.listenCoOwnerInviteAccepted();
+    this.listenServiceSubscriptionUpdated();
+  }
+
+  /**
+   * Update cache when owner invitation accepted
+   */
+  private listenCoOwnerInviteAccepted(): void {
+    this.eventDispatcherService.on(AppEventTypeEnum.PROPERTY_OWNER_UPDATED).subscribe(() => this.resetCache());
+  }
+
+  /**
+   * Update cache when user's service subscription is updated
+   */
+  private listenServiceSubscriptionUpdated(): void {
+    this.eventDispatcherService.on(AppEventTypeEnum.SERVICE_SUBSCRIPTION_UPDATED).subscribe(() => this.resetCache());
+  }
+
+  update(property: Property): Observable<Property> {
+    return super.update(property).pipe(
+      map((updatedProperty: Property): Property => {
+        if (property.documentFile) {
+          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.PROPERTY_UPDATED_WITH_DOCUMENT, property));
+        }
+        return updatedProperty;
+      })
+    );
+  }
+
+  getByCategoryId(id: number): Observable<Property[]> {
+    return this.get().pipe(
+      map((properties: Property[]): Property[] => {
+        return properties.filter((property: Property): boolean => property.category.id === id);
+      })
+    );
+  }
+
+  /**
+   * Activate deactivated property
+   */
+  activate(property: Property): Observable<void> {
+    return this.http.post(`${this.environment.apiV2}/property-subscriptions`, {user: property.user, property})
+      .pipe(
+        map((propertySubscriptionBase: PropertySubscriptionBase) => {
+          const newPropertySubscription: PropertySubscription = plainToClass(PropertySubscription, propertySubscriptionBase);
+          const activatedProperty: Property = plainToClass(Property, Object.assign({}, property, {subscriptions: [newPropertySubscription]}));
+
+          replace(this.cache, activatedProperty);
+          this.updateCache();
+        })
+      );
+  }
+
+  /**
+   * Deactivate activated property
+   */
+  deactivate(property: Property): Observable<void> {
+    return this.http.delete(`${this.environment.apiV2}/property-subscriptions/${property.getCurrentSubscription().id}`)
+      .pipe(
+        map(() => {
+          const deactivatedProperty: Property = plainToClass(Property, Object.assign({}, property, {subscriptions: []}));
+          replace(this.cache, deactivatedProperty);
+          this.updateCache();
+        })
+      );
+  }
+
+  /**
+   * Update property photo
+   * @param property Property instance for photo update
+   * @param photoFormData FormData with property photo image
+   */
+  updatePhoto(property: Property, photoFormData: FormData): Observable<void> {
+    return this.http.post(`${this.environment.apiV2}/properties/${property.id}/photo?_method=PUT`, photoFormData)
+      .pipe(
+        map((photoLink: string): void => {
+          property.photo = photoLink;
+          // update properties cache
+          replace(this.cache, property);
+          this.updateCache();
+        })
+      );
+  }
+
+  getByCoOwnerId(id: number): Observable<Property[]> {
+    return this.get().pipe(
+      map((properties: Property[]): Property[] => {
+        return properties.filter((property: Property): boolean => property.user.id === id);
+      })
+    );
+  }
+
+  /**
+   * Get list of active user's properties
+   */
+  getActive(): Observable<Property[]> {
+    return this.get().pipe(
+      map((properties: Property[]): Property[] => properties.filter((property: Property): boolean => property.isActive))
+    );
+  }
+}

package/src/lib/services/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();
+  });
+});

package/src/lib/services/subscription/subscription.service.ts

@@ -0,0 +1,153 @@
+import { Inject, Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { Observable, ReplaySubject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { loadStripe } from '@stripe/stripe-js';
+import { ServicePriceCollection } from '../../collections/service-price.collection';
+import { ServiceSubscriptionCollection } from '../../collections/service-subscription.collection';
+import { plainToClass } from 'class-transformer';
+import { ServiceSubscription } from '../../models/service-subscription/service-subscription';
+import { ServicePayment } from '../../models/service-subscription/service-payment';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import { ServicePrice } from '../../models/service-subscription/service-price';
+import { ServiceSubscriptionItem } from '../../models/service-subscription/service-subscription-item';
+import { AppEvent } from '../../models/event/app-event';
+import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class SubscriptionService {
+  _serviceSubscription: ServiceSubscription;
+  serviceSubscriptionSubject: ReplaySubject<ServiceSubscription> = new ReplaySubject<ServiceSubscription>(1);
+  _serviceSubscriptions: ServiceSubscriptionCollection;
+  serviceSubscriptionsSubject: ReplaySubject<ServiceSubscriptionCollection> = new ReplaySubject<ServiceSubscriptionCollection>(1);
+  stripe: any;
+  servicePaymentsSubject: ReplaySubject<ServicePayment[]> = new ReplaySubject<ServicePayment[]>(1);
+  _servicePayments: ServicePayment[];
+
+  constructor(
+    private http: HttpClient,
+    private eventDispatcherService: EventDispatcherService,
+    @Inject('environment') private environment: any
+  ) {
+  }
+
+  getSubscription(): Observable<ServiceSubscription> {
+    if (!this._serviceSubscription) {
+      this.http.get(`${this.environment.apiV2}/subscriptions/last`)
+        .pipe(
+          map((response: any) => {
+            return plainToClass(ServiceSubscription, response);
+          })
+        )
+        .subscribe((subsciption: ServiceSubscription) => {
+          this._serviceSubscription = subsciption;
+          this.serviceSubscriptionSubject.next(this._serviceSubscription);
+        });
+    }
+
+    return this.serviceSubscriptionSubject.asObservable();
+  }
+
+  /**
+   * @TODO right now we have only monthly prices, the function should be refactored to support other options in future
+   *
+   * create available subscription plans based on existing products
+   */
+  getSubscriptionPlans(): Observable<ServiceSubscriptionCollection> {
+    if (!this._serviceSubscriptions) {
+      this.http.get(`${this.environment.apiV2}/service-prices`)
+        .pipe(
+          map((response: any) => {
+            return new ServicePriceCollection(response['hydra:member'].map((item: object) => plainToClass(ServicePrice, item)));
+          })
+        )
+        .subscribe((prices: ServicePriceCollection) => {
+          this._serviceSubscriptions = new ServiceSubscriptionCollection([
+            plainToClass(ServiceSubscription, {items: []}),
+            plainToClass(ServiceSubscription, {items: [plainToClass(ServiceSubscriptionItem, {price: prices.property, quantity: 2})]}),
+            plainToClass(ServiceSubscription, {items: [plainToClass(ServiceSubscriptionItem, {price: prices.property, quantity: 3})]})
+          ]);
+          this._serviceSubscriptions.items.forEach((subscription: ServiceSubscription) => {
+            subscription.items.push(plainToClass(ServiceSubscriptionItem, {price: prices.work, quantity: 1}));
+          });
+
+          this.serviceSubscriptionsSubject.next(this._serviceSubscriptions);
+        });
+    }
+
+    return this.serviceSubscriptionsSubject.asObservable();
+  }
+
+  /**
+   * redirect to stripe payment page
+   */
+  async checkoutRedirect(subscription: ServiceSubscription, successUrl: string, cancelUrl: string): Promise<any> {
+    const stripe: any = await loadStripe(this.environment.stripePk);
+    // @TODO vik
+    const lineItems: any = subscription.items.map((item: ServiceSubscriptionItem) => {
+      return {servicePriceId: item.price.id, quantity: item.quantity};
+    });
+
+    this.http.post(`${this.environment.apiV2}/stripe/checkout-session`, {
+      lineItems,
+      successUrl: successUrl,
+      cancelUrl: cancelUrl
+    })
+      .subscribe((session: string) => {
+        // @Todo remove user TRIAL status
+        stripe.redirectToCheckout({sessionId: session});
+      });
+  }
+
+  /**
+   * redirect to stripe billing page
+   */
+  billingRedirect(returnUrl: string): void {
+    this.http.get(`${this.environment.apiV2}/stripe/billing-portal-session`, {
+      params: {returnUrl}
+    }).subscribe((response: any) => {
+      window.location.replace(response.url);
+    });
+  }
+
+  getPayments(): Observable<ServicePayment[]> {
+    if (!this._servicePayments) {
+      this.http.get(`${this.environment.apiV2}/service-payments`).subscribe((response: object[]) => {
+        this._servicePayments = response.map((item: object) => plainToClass(ServicePayment, item));
+        this.servicePaymentsSubject.next(this._servicePayments);
+      });
+    }
+
+    return this.servicePaymentsSubject.asObservable();
+  }
+
+  /**
+   * Get difference between current subscription and selected new subscription
+   */
+  getProrationCost(items: ServiceSubscriptionItem[]): Observable<number> {
+    return this.http.post(`${this.environment.apiV2}/subscriptions/proration-cost`, items).pipe(
+      map((prorationCost: number) => {
+        return prorationCost;
+      })
+    );
+  }
+
+  /**
+   * Change subscription plan
+   */
+  changeSubscription(items: ServiceSubscriptionItem[]): Observable<void> {
+    return this.http.put(`${this.environment.apiV2}/subscriptions/items`, items).pipe(
+      map(() => {
+        // Set cache value as null and fire request to backend to get updated subscription value
+        this._serviceSubscription = null;
+        this.serviceSubscriptionSubject.next(this._serviceSubscription);
+        // update property list
+        this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.SERVICE_SUBSCRIPTION_UPDATED, null));
+
+        this.getSubscription().subscribe();
+      })
+    );
+  }
+}

package/src/lib/services/tax-review/tax-review-history.service.spec.ts

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

package/src/lib/services/tax-review/tax-review-history.service.ts

@@ -0,0 +1,35 @@
+import { Inject, Injectable } from '@angular/core';
+import { TaxReview as TaxReviewBase } from '../../db/Models/tax-review';
+import { HttpClient } from '@angular/common/http';
+import { BaseRestService } from '../base-rest.service';
+import { TaxReview } from '../../models/tax-review/tax-review';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
+import _ from 'lodash';
+
+/**
+ * Service to work with tax review history
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class TaxReviewHistoryService extends BaseRestService<TaxReviewBase, TaxReview> {
+  url: string = 'tax-reviews/history';
+  modelClass: typeof TaxReview = TaxReview;
+
+  constructor(
+    protected http: HttpClient,
+    protected eventDispatcherService: EventDispatcherService,
+    @Inject('environment') protected environment: any
+  ) {
+    super(http, eventDispatcherService, environment);
+    // subscribe on tax review updating
+    eventDispatcherService.on(AppEventTypeEnum.TAX_REVIEW_UPDATED).subscribe((taxReview: TaxReview): void => {
+      const tempCache: TaxReview[] = _.cloneDeep(this.cache);
+      // insert element at the beginning of the array
+      tempCache.unshift(taxReview);
+      this.cache = tempCache;
+      this.updateCache();
+    });
+  }
+}

package/src/lib/services/tax-review/tax-review.service.spec.ts

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