taxtank-core 0.5.2 → 0.7.0

package/esm2015/lib/services/subscription/subscription.service.js

@@ -1,138 +1,138 @@
-import { __awaiter } from "tslib";
-import { Inject, Injectable } from '@angular/core';
-import { 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 { 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';
-import * as i0 from "@angular/core";
-import * as i1 from "@angular/common/http";
-import * as i2 from "../event/event-dispatcher.service";
-export class SubscriptionService {
-    constructor(http, eventDispatcherService, environment) {
-        this.http = http;
-        this.eventDispatcherService = eventDispatcherService;
-        this.environment = environment;
-        this.serviceSubscriptionSubject = new ReplaySubject(1);
-        this.serviceSubscriptionsSubject = new ReplaySubject(1);
-        this.servicePaymentsSubject = new ReplaySubject(1);
-    }
-    getSubscription() {
-        if (!this._serviceSubscription) {
-            this.http.get(`${this.environment.apiV2}/subscriptions/last`)
-                .pipe(map((response) => {
-                return plainToClass(ServiceSubscription, response);
-            }))
-                .subscribe((subsciption) => {
-                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() {
-        if (!this._serviceSubscriptions) {
-            this.http.get(`${this.environment.apiV2}/service-prices`)
-                .pipe(map((response) => {
-                return new ServicePriceCollection(response['hydra:member'].map((item) => plainToClass(ServicePrice, item)));
-            }))
-                .subscribe((prices) => {
-                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) => {
-                    subscription.items.push(plainToClass(ServiceSubscriptionItem, { price: prices.work, quantity: 1 }));
-                });
-                this.serviceSubscriptionsSubject.next(this._serviceSubscriptions);
-            });
-        }
-        return this.serviceSubscriptionsSubject.asObservable();
-    }
-    /**
-     * redirect to stripe payment page
-     */
-    checkoutRedirect(subscription, successUrl, cancelUrl) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const stripe = yield loadStripe(this.environment.stripePk);
-            // @TODO vik
-            const lineItems = subscription.items.map((item) => {
-                return { servicePriceId: item.price.id, quantity: item.quantity };
-            });
-            this.http.post(`${this.environment.apiV2}/stripe/checkout-session`, {
-                lineItems,
-                successUrl: successUrl,
-                cancelUrl: cancelUrl
-            })
-                .subscribe((session) => {
-                // @Todo remove user TRIAL status
-                stripe.redirectToCheckout({ sessionId: session });
-            });
-        });
-    }
-    /**
-     * redirect to stripe billing page
-     */
-    billingRedirect(returnUrl) {
-        this.http.get(`${this.environment.apiV2}/stripe/billing-portal-session`, {
-            params: { returnUrl }
-        }).subscribe((response) => {
-            window.location.replace(response.url);
-        });
-    }
-    getPayments() {
-        if (!this._servicePayments) {
-            this.http.get(`${this.environment.apiV2}/service-payments`).subscribe((response) => {
-                this._servicePayments = response.map((item) => plainToClass(ServicePayment, item));
-                this.servicePaymentsSubject.next(this._servicePayments);
-            });
-        }
-        return this.servicePaymentsSubject.asObservable();
-    }
-    /**
-     * Get difference between current subscription and selected new subscription
-     */
-    getProrationCost(items) {
-        return this.http.post(`${this.environment.apiV2}/subscriptions/proration-cost`, items).pipe(map((prorationCost) => {
-            return prorationCost;
-        }));
-    }
-    /**
-     * Change subscription plan
-     */
-    changeSubscription(items) {
-        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();
-        }));
-    }
-}
-SubscriptionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: SubscriptionService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
-SubscriptionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: SubscriptionService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: SubscriptionService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.EventDispatcherService }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: ['environment']
-                }] }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"subscription.service.js","sourceRoot":"","sources":["../../../../../../projects/tt-core/src/lib/services/subscription/subscription.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\r\nimport { HttpClient } from '@angular/common/http';\r\nimport { Observable, ReplaySubject } from 'rxjs';\r\nimport { map } from 'rxjs/operators';\r\nimport { loadStripe } from '@stripe/stripe-js';\r\nimport { ServicePriceCollection } from '../../collections/service-price.collection';\r\nimport { ServiceSubscriptionCollection } from '../../collections/service-subscription.collection';\r\nimport { plainToClass } from 'class-transformer';\r\nimport { ServiceSubscription } from '../../models/service-subscription/service-subscription';\r\nimport { ServicePayment } from '../../models/service-subscription/service-payment';\r\nimport { EventDispatcherService } from '../event/event-dispatcher.service';\r\nimport { ServicePrice } from '../../models/service-subscription/service-price';\r\nimport { ServiceSubscriptionItem } from '../../models/service-subscription/service-subscription-item';\r\nimport { AppEvent } from '../../models/event/app-event';\r\nimport { AppEventTypeEnum } from '../../models/event/app-event-type.enum';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class SubscriptionService {\r\n  _serviceSubscription: ServiceSubscription;\r\n  serviceSubscriptionSubject: ReplaySubject<ServiceSubscription> = new ReplaySubject<ServiceSubscription>(1);\r\n  _serviceSubscriptions: ServiceSubscriptionCollection;\r\n  serviceSubscriptionsSubject: ReplaySubject<ServiceSubscriptionCollection> = new ReplaySubject<ServiceSubscriptionCollection>(1);\r\n  stripe: any;\r\n  servicePaymentsSubject: ReplaySubject<ServicePayment[]> = new ReplaySubject<ServicePayment[]>(1);\r\n  _servicePayments: ServicePayment[];\r\n\r\n  constructor(\r\n    private http: HttpClient,\r\n    private eventDispatcherService: EventDispatcherService,\r\n    @Inject('environment') private environment: any\r\n  ) {\r\n  }\r\n\r\n  getSubscription(): Observable<ServiceSubscription> {\r\n    if (!this._serviceSubscription) {\r\n      this.http.get(`${this.environment.apiV2}/subscriptions/last`)\r\n        .pipe(\r\n          map((response: any) => {\r\n            return plainToClass(ServiceSubscription, response);\r\n          })\r\n        )\r\n        .subscribe((subsciption: ServiceSubscription) => {\r\n          this._serviceSubscription = subsciption;\r\n          this.serviceSubscriptionSubject.next(this._serviceSubscription);\r\n        });\r\n    }\r\n\r\n    return this.serviceSubscriptionSubject.asObservable();\r\n  }\r\n\r\n  /**\r\n   * @TODO right now we have only monthly prices, the function should be refactored to support other options in future\r\n   *\r\n   * create available subscription plans based on existing products\r\n   */\r\n  getSubscriptionPlans(): Observable<ServiceSubscriptionCollection> {\r\n    if (!this._serviceSubscriptions) {\r\n      this.http.get(`${this.environment.apiV2}/service-prices`)\r\n        .pipe(\r\n          map((response: any) => {\r\n            return new ServicePriceCollection(response['hydra:member'].map((item: object) => plainToClass(ServicePrice, item)));\r\n          })\r\n        )\r\n        .subscribe((prices: ServicePriceCollection) => {\r\n          this._serviceSubscriptions = new ServiceSubscriptionCollection([\r\n            plainToClass(ServiceSubscription, {items: []}),\r\n            plainToClass(ServiceSubscription, {items: [plainToClass(ServiceSubscriptionItem, {price: prices.property, quantity: 2})]}),\r\n            plainToClass(ServiceSubscription, {items: [plainToClass(ServiceSubscriptionItem, {price: prices.property, quantity: 3})]})\r\n          ]);\r\n          this._serviceSubscriptions.items.forEach((subscription: ServiceSubscription) => {\r\n            subscription.items.push(plainToClass(ServiceSubscriptionItem, {price: prices.work, quantity: 1}));\r\n          });\r\n\r\n          this.serviceSubscriptionsSubject.next(this._serviceSubscriptions);\r\n        });\r\n    }\r\n\r\n    return this.serviceSubscriptionsSubject.asObservable();\r\n  }\r\n\r\n  /**\r\n   * redirect to stripe payment page\r\n   */\r\n  async checkoutRedirect(subscription: ServiceSubscription, successUrl: string, cancelUrl: string): Promise<any> {\r\n    const stripe: any = await loadStripe(this.environment.stripePk);\r\n    // @TODO vik\r\n    const lineItems: any = subscription.items.map((item: ServiceSubscriptionItem) => {\r\n      return {servicePriceId: item.price.id, quantity: item.quantity};\r\n    });\r\n\r\n    this.http.post(`${this.environment.apiV2}/stripe/checkout-session`, {\r\n      lineItems,\r\n      successUrl: successUrl,\r\n      cancelUrl: cancelUrl\r\n    })\r\n      .subscribe((session: string) => {\r\n        // @Todo remove user TRIAL status\r\n        stripe.redirectToCheckout({sessionId: session});\r\n      });\r\n  }\r\n\r\n  /**\r\n   * redirect to stripe billing page\r\n   */\r\n  billingRedirect(returnUrl: string): void {\r\n    this.http.get(`${this.environment.apiV2}/stripe/billing-portal-session`, {\r\n      params: {returnUrl}\r\n    }).subscribe((response: any) => {\r\n      window.location.replace(response.url);\r\n    });\r\n  }\r\n\r\n  getPayments(): Observable<ServicePayment[]> {\r\n    if (!this._servicePayments) {\r\n      this.http.get(`${this.environment.apiV2}/service-payments`).subscribe((response: object[]) => {\r\n        this._servicePayments = response.map((item: object) => plainToClass(ServicePayment, item));\r\n        this.servicePaymentsSubject.next(this._servicePayments);\r\n      });\r\n    }\r\n\r\n    return this.servicePaymentsSubject.asObservable();\r\n  }\r\n\r\n  /**\r\n   * Get difference between current subscription and selected new subscription\r\n   */\r\n  getProrationCost(items: ServiceSubscriptionItem[]): Observable<number> {\r\n    return this.http.post(`${this.environment.apiV2}/subscriptions/proration-cost`, items).pipe(\r\n      map((prorationCost: number) => {\r\n        return prorationCost;\r\n      })\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Change subscription plan\r\n   */\r\n  changeSubscription(items: ServiceSubscriptionItem[]): Observable<void> {\r\n    return this.http.put(`${this.environment.apiV2}/subscriptions/items`, items).pipe(\r\n      map(() => {\r\n        // Set cache value as null and fire request to backend to get updated subscription value\r\n        this._serviceSubscription = null;\r\n        this.serviceSubscriptionSubject.next(this._serviceSubscription);\r\n        // update property list\r\n        this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.SERVICE_SUBSCRIPTION_UPDATED, null));\r\n\r\n        this.getSubscription().subscribe();\r\n      })\r\n    );\r\n  }\r\n}\r\n"]}
+import { __awaiter } from "tslib";
+import { Inject, Injectable } from '@angular/core';
+import { 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 { 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';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../event/event-dispatcher.service";
+export class SubscriptionService {
+    constructor(http, eventDispatcherService, environment) {
+        this.http = http;
+        this.eventDispatcherService = eventDispatcherService;
+        this.environment = environment;
+        this.serviceSubscriptionSubject = new ReplaySubject(1);
+        this.serviceSubscriptionsSubject = new ReplaySubject(1);
+        this.servicePaymentsSubject = new ReplaySubject(1);
+    }
+    getSubscription() {
+        if (!this._serviceSubscription) {
+            this.http.get(`${this.environment.apiV2}/subscriptions/last`)
+                .pipe(map((response) => {
+                return plainToClass(ServiceSubscription, response);
+            }))
+                .subscribe((subsciption) => {
+                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() {
+        if (!this._serviceSubscriptions) {
+            this.http.get(`${this.environment.apiV2}/service-prices`)
+                .pipe(map((response) => {
+                return new ServicePriceCollection(response['hydra:member'].map((item) => plainToClass(ServicePrice, item)));
+            }))
+                .subscribe((prices) => {
+                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) => {
+                    subscription.items.push(plainToClass(ServiceSubscriptionItem, { price: prices.work, quantity: 1 }));
+                });
+                this.serviceSubscriptionsSubject.next(this._serviceSubscriptions);
+            });
+        }
+        return this.serviceSubscriptionsSubject.asObservable();
+    }
+    /**
+     * redirect to stripe payment page
+     */
+    checkoutRedirect(subscription, successUrl, cancelUrl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stripe = yield loadStripe(this.environment.stripePk);
+            // @TODO vik
+            const lineItems = subscription.items.map((item) => {
+                return { servicePriceId: item.price.id, quantity: item.quantity };
+            });
+            this.http.post(`${this.environment.apiV2}/stripe/checkout-session`, {
+                lineItems,
+                successUrl: successUrl,
+                cancelUrl: cancelUrl
+            })
+                .subscribe((session) => {
+                // @Todo remove user TRIAL status
+                stripe.redirectToCheckout({ sessionId: session });
+            });
+        });
+    }
+    /**
+     * redirect to stripe billing page
+     */
+    billingRedirect(returnUrl) {
+        this.http.get(`${this.environment.apiV2}/stripe/billing-portal-session`, {
+            params: { returnUrl }
+        }).subscribe((response) => {
+            window.location.replace(response.url);
+        });
+    }
+    getPayments() {
+        if (!this._servicePayments) {
+            this.http.get(`${this.environment.apiV2}/service-payments`).subscribe((response) => {
+                this._servicePayments = response.map((item) => plainToClass(ServicePayment, item));
+                this.servicePaymentsSubject.next(this._servicePayments);
+            });
+        }
+        return this.servicePaymentsSubject.asObservable();
+    }
+    /**
+     * Get difference between current subscription and selected new subscription
+     */
+    getProrationCost(items) {
+        return this.http.post(`${this.environment.apiV2}/subscriptions/proration-cost`, items).pipe(map((prorationCost) => {
+            return prorationCost;
+        }));
+    }
+    /**
+     * Change subscription plan
+     */
+    changeSubscription(items) {
+        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();
+        }));
+    }
+}
+SubscriptionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: SubscriptionService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+SubscriptionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: SubscriptionService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: SubscriptionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.EventDispatcherService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"subscription.service.js","sourceRoot":"","sources":["../../../../../../projects/tt-core/src/lib/services/subscription/subscription.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport { Observable, ReplaySubject } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { loadStripe } from '@stripe/stripe-js';\nimport { ServicePriceCollection } from '../../collections/service-price.collection';\nimport { ServiceSubscriptionCollection } from '../../collections/service-subscription.collection';\nimport { plainToClass } from 'class-transformer';\nimport { ServiceSubscription } from '../../models/service-subscription/service-subscription';\nimport { ServicePayment } from '../../models/service-subscription/service-payment';\nimport { EventDispatcherService } from '../event/event-dispatcher.service';\nimport { ServicePrice } from '../../models/service-subscription/service-price';\nimport { ServiceSubscriptionItem } from '../../models/service-subscription/service-subscription-item';\nimport { AppEvent } from '../../models/event/app-event';\nimport { AppEventTypeEnum } from '../../models/event/app-event-type.enum';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class SubscriptionService {\n  _serviceSubscription: ServiceSubscription;\n  serviceSubscriptionSubject: ReplaySubject<ServiceSubscription> = new ReplaySubject<ServiceSubscription>(1);\n  _serviceSubscriptions: ServiceSubscriptionCollection;\n  serviceSubscriptionsSubject: ReplaySubject<ServiceSubscriptionCollection> = new ReplaySubject<ServiceSubscriptionCollection>(1);\n  stripe: any;\n  servicePaymentsSubject: ReplaySubject<ServicePayment[]> = new ReplaySubject<ServicePayment[]>(1);\n  _servicePayments: ServicePayment[];\n\n  constructor(\n    private http: HttpClient,\n    private eventDispatcherService: EventDispatcherService,\n    @Inject('environment') private environment: any\n  ) {\n  }\n\n  getSubscription(): Observable<ServiceSubscription> {\n    if (!this._serviceSubscription) {\n      this.http.get(`${this.environment.apiV2}/subscriptions/last`)\n        .pipe(\n          map((response: any) => {\n            return plainToClass(ServiceSubscription, response);\n          })\n        )\n        .subscribe((subsciption: ServiceSubscription) => {\n          this._serviceSubscription = subsciption;\n          this.serviceSubscriptionSubject.next(this._serviceSubscription);\n        });\n    }\n\n    return this.serviceSubscriptionSubject.asObservable();\n  }\n\n  /**\n   * @TODO right now we have only monthly prices, the function should be refactored to support other options in future\n   *\n   * create available subscription plans based on existing products\n   */\n  getSubscriptionPlans(): Observable<ServiceSubscriptionCollection> {\n    if (!this._serviceSubscriptions) {\n      this.http.get(`${this.environment.apiV2}/service-prices`)\n        .pipe(\n          map((response: any) => {\n            return new ServicePriceCollection(response['hydra:member'].map((item: object) => plainToClass(ServicePrice, item)));\n          })\n        )\n        .subscribe((prices: ServicePriceCollection) => {\n          this._serviceSubscriptions = new ServiceSubscriptionCollection([\n            plainToClass(ServiceSubscription, {items: []}),\n            plainToClass(ServiceSubscription, {items: [plainToClass(ServiceSubscriptionItem, {price: prices.property, quantity: 2})]}),\n            plainToClass(ServiceSubscription, {items: [plainToClass(ServiceSubscriptionItem, {price: prices.property, quantity: 3})]})\n          ]);\n          this._serviceSubscriptions.items.forEach((subscription: ServiceSubscription) => {\n            subscription.items.push(plainToClass(ServiceSubscriptionItem, {price: prices.work, quantity: 1}));\n          });\n\n          this.serviceSubscriptionsSubject.next(this._serviceSubscriptions);\n        });\n    }\n\n    return this.serviceSubscriptionsSubject.asObservable();\n  }\n\n  /**\n   * redirect to stripe payment page\n   */\n  async checkoutRedirect(subscription: ServiceSubscription, successUrl: string, cancelUrl: string): Promise<any> {\n    const stripe: any = await loadStripe(this.environment.stripePk);\n    // @TODO vik\n    const lineItems: any = subscription.items.map((item: ServiceSubscriptionItem) => {\n      return {servicePriceId: item.price.id, quantity: item.quantity};\n    });\n\n    this.http.post(`${this.environment.apiV2}/stripe/checkout-session`, {\n      lineItems,\n      successUrl: successUrl,\n      cancelUrl: cancelUrl\n    })\n      .subscribe((session: string) => {\n        // @Todo remove user TRIAL status\n        stripe.redirectToCheckout({sessionId: session});\n      });\n  }\n\n  /**\n   * redirect to stripe billing page\n   */\n  billingRedirect(returnUrl: string): void {\n    this.http.get(`${this.environment.apiV2}/stripe/billing-portal-session`, {\n      params: {returnUrl}\n    }).subscribe((response: any) => {\n      window.location.replace(response.url);\n    });\n  }\n\n  getPayments(): Observable<ServicePayment[]> {\n    if (!this._servicePayments) {\n      this.http.get(`${this.environment.apiV2}/service-payments`).subscribe((response: object[]) => {\n        this._servicePayments = response.map((item: object) => plainToClass(ServicePayment, item));\n        this.servicePaymentsSubject.next(this._servicePayments);\n      });\n    }\n\n    return this.servicePaymentsSubject.asObservable();\n  }\n\n  /**\n   * Get difference between current subscription and selected new subscription\n   */\n  getProrationCost(items: ServiceSubscriptionItem[]): Observable<number> {\n    return this.http.post(`${this.environment.apiV2}/subscriptions/proration-cost`, items).pipe(\n      map((prorationCost: number) => {\n        return prorationCost;\n      })\n    );\n  }\n\n  /**\n   * Change subscription plan\n   */\n  changeSubscription(items: ServiceSubscriptionItem[]): Observable<void> {\n    return this.http.put(`${this.environment.apiV2}/subscriptions/items`, items).pipe(\n      map(() => {\n        // Set cache value as null and fire request to backend to get updated subscription value\n        this._serviceSubscription = null;\n        this.serviceSubscriptionSubject.next(this._serviceSubscription);\n        // update property list\n        this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.SERVICE_SUBSCRIPTION_UPDATED, null));\n\n        this.getSubscription().subscribe();\n      })\n    );\n  }\n}\n"]}

package/esm2015/lib/services/tax-review/tax-review-history.service.js

@@ -1,41 +1,41 @@
-import { Inject, Injectable } from '@angular/core';
-import { BaseRestService } from '../base-rest.service';
-import { TaxReview } from '../../models/tax-review/tax-review';
-import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
-import _ from 'lodash';
-import * as i0 from "@angular/core";
-import * as i1 from "@angular/common/http";
-import * as i2 from "../event/event-dispatcher.service";
-/**
- * Service to work with tax review history
- */
-export class TaxReviewHistoryService extends BaseRestService {
-    constructor(http, eventDispatcherService, environment) {
-        super(http, eventDispatcherService, environment);
-        this.http = http;
-        this.eventDispatcherService = eventDispatcherService;
-        this.environment = environment;
-        this.url = 'tax-reviews/history';
-        this.modelClass = TaxReview;
-        // subscribe on tax review updating
-        eventDispatcherService.on(AppEventTypeEnum.TAX_REVIEW_UPDATED).subscribe((taxReview) => {
-            const tempCache = _.cloneDeep(this.cache);
-            // insert element at the beginning of the array
-            tempCache.unshift(taxReview);
-            this.cache = tempCache;
-            this.updateCache();
-        });
-    }
-}
-TaxReviewHistoryService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: TaxReviewHistoryService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
-TaxReviewHistoryService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: TaxReviewHistoryService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: TaxReviewHistoryService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.EventDispatcherService }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: ['environment']
-                }] }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+import { Inject, Injectable } from '@angular/core';
+import { BaseRestService } from '../base-rest.service';
+import { TaxReview } from '../../models/tax-review/tax-review';
+import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
+import _ from 'lodash';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../event/event-dispatcher.service";
+/**
+ * Service to work with tax review history
+ */
+export class TaxReviewHistoryService extends BaseRestService {
+    constructor(http, eventDispatcherService, environment) {
+        super(http, eventDispatcherService, environment);
+        this.http = http;
+        this.eventDispatcherService = eventDispatcherService;
+        this.environment = environment;
+        this.url = 'tax-reviews/history';
+        this.modelClass = TaxReview;
+        // subscribe on tax review updating
+        eventDispatcherService.on(AppEventTypeEnum.TAX_REVIEW_UPDATED).subscribe((taxReview) => {
+            const tempCache = _.cloneDeep(this.cache);
+            // insert element at the beginning of the array
+            tempCache.unshift(taxReview);
+            this.cache = tempCache;
+            this.updateCache();
+        });
+    }
+}
+TaxReviewHistoryService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: TaxReviewHistoryService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+TaxReviewHistoryService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: TaxReviewHistoryService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: TaxReviewHistoryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.EventDispatcherService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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