taxtank-core 0.1.0 → 0.1.1

package/src/lib/services/user-event/user-event-type.service.spec.ts

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

package/src/lib/services/user-event/user-event-type.service.ts

@@ -0,0 +1,24 @@
+import { Inject, Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { UserEventType as UserEventTypeBase } from '../../db/Models/user-event-type';
+import { UserEventType } from '../../models/user-event/user-event-type';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import { BaseRestService } from '../base-rest.service';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class UserEventTypeService extends BaseRestService<UserEventTypeBase, UserEventType> {
+  modelClass: typeof UserEventType = UserEventType;
+  url: string = 'user-event-types';
+  isHydra: boolean = true;
+
+  constructor(
+    protected http: HttpClient,
+    protected eventDispatcherService: EventDispatcherService,
+    @Inject('environment') protected environment: any
+  ) {
+    super(http, eventDispatcherService, environment);
+  }
+}
+

package/src/lib/services/work/work-tank.service.spec.ts

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

package/src/lib/services/work/work-tank.service.ts

@@ -0,0 +1,277 @@
+import { Inject, Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { combineLatest, Observable, ReplaySubject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { ChartAccountsHeadingVehicleListEnum } from '../../db/Enums/chart-accounts-heading-vehicle-list.enum';
+import { ChartAccountsListEnum } from '../../db/Enums/chart-accounts-list.enum';
+import { plainToClass } from 'class-transformer';
+import { TransactionService } from '../transaction/transaction.service';
+import { enumToList } from '../../functions/enum-to-list';
+import { Vehicle } from '../../models/logbook/vehicle';
+import { VehicleClaim } from '../../models/logbook/vehicle-claim';
+import { VehicleLogbook } from '../../models/logbook/vehicle-logbook';
+import { IncomePosition } from '../../models/income-position/income-position';
+import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
+import { AppEvent } from '../../models/event/app-event';
+import { FinancialYear } from '../../models/financial-year/financial-year';
+import { Transaction } from '../../models/transaction/transaction';
+import { Depreciation } from '../../models/depreciation/depreciation';
+import { DepreciationService } from '../depreciation/depreciation.service';
+import { ChartAccountsService } from '../chart-accounts/chart-accounts.service';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+
+/**
+ * Service that allows to work with WorkTank operations
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class WorkTankService {
+  // @TODO refactor and maybe break to separated services
+  _vehicles: Vehicle[];
+  vehiclesSubject: ReplaySubject<Vehicle[]> = new ReplaySubject<Vehicle[]>(1);
+  _vehicleClaim: VehicleClaim;
+  vehicleClaimSubject: ReplaySubject<VehicleClaim> = new ReplaySubject<VehicleClaim>(1);
+  _vehicleClaimRate: number;
+  vehicleClaimRateSubject: ReplaySubject<number> = new ReplaySubject<number>(1);
+  _vehicleTaxReturn: number;
+  vehicleTaxReturnSubject: ReplaySubject<number> = new ReplaySubject<number>(1);
+  _incomePositions: IncomePosition[];
+  incomePositionsSubject: ReplaySubject<IncomePosition[]> = new ReplaySubject<IncomePosition[]>(1);
+
+  constructor(
+    private http: HttpClient,
+    private transactionService: TransactionService,
+    private depreciationService: DepreciationService,
+    private chartAccountsService: ChartAccountsService,
+    private eventDispatcherService: EventDispatcherService,
+    @Inject('environment') private environment: any
+  ) {
+  }
+
+  getVehicles(): Observable<Vehicle[]> {
+    // @TODO create backend for get logbook
+    if (!this._vehicles) {
+      this.http.get(`${this.environment.apiV2}/vehicles`)
+        .pipe(
+          map((response: any) => {
+            return response.map((item: any) => plainToClass(Vehicle, item));
+          })
+        )
+        .subscribe((vehicles: Vehicle[]) => {
+          this._vehicles = vehicles;
+          this.vehiclesSubject.next(vehicles);
+        });
+    }
+
+    return this.vehiclesSubject.asObservable();
+  }
+
+  /**
+   * Get vehicles claim amount
+   */
+  getVehiclesClaim(): Observable<VehicleClaim> {
+    if (!this._vehicleClaim) {
+      this.http.get(`${this.environment.apiV2}/vehicle-claims`)
+        .pipe(
+          map((response: any) => {
+            // return Vehicle claim from backend or create new if it not exist
+            return response.length ? response.map((item: any) => plainToClass(VehicleClaim, item))[0] : plainToClass(VehicleClaim, {});
+          })
+        )
+        .subscribe((vehicleClaim: VehicleClaim) => {
+          this._vehicleClaim = vehicleClaim;
+          this.vehicleClaimSubject.next(vehicleClaim);
+        });
+    }
+
+    return this.vehicleClaimSubject.asObservable();
+  }
+
+  /**
+   * Add new vehicle claim
+   * @param claim object which should be added
+   */
+  addVehicleClaim(claim: VehicleClaim): Observable<any> {
+    return this.http.post(`${this.environment.apiV2}/vehicle-claims`, claim).pipe(
+      map((response: any) => {
+        this._vehicleClaim = plainToClass(VehicleClaim, response);
+        this.vehicleClaimSubject.next(this._vehicleClaim);
+        this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.VEHICLE_CLAIM_CREATED, null));
+      }));
+  }
+
+  /**
+   * Get vehicles claim rate for current financial year
+   */
+  getVehiclesClaimRate(): Observable<number> {
+    if (!this._vehicleClaimRate) {
+      this.chartAccountsService.getChartAccountsById(ChartAccountsListEnum.KLMS_TRAVELLED_FOR_WORK)
+        .pipe(
+          map((response: any) => {
+            return response.values.find((chartAccount: any) => chartAccount.financialYear === new FinancialYear().year).value;
+          })
+        )
+        .subscribe((claimRate: number) => {
+          this._vehicleClaimRate = claimRate;
+          this.vehicleClaimRateSubject.next(this._vehicleClaimRate);
+        });
+    }
+
+    return this.vehicleClaimRateSubject.asObservable();
+  }
+
+  /**
+   * Get vehicles tax return for vehicle transactions & depreciations
+   */
+  getVehiclesTaxReturn(): Observable<number> {
+    if (!this._vehicleTaxReturn) {
+      combineLatest([
+        // @Todo refactor to avoid injection of another services
+        this.transactionService.get(),
+        this.depreciationService.get(),
+        this.getVehiclesClaim()
+      ]).pipe(
+          map(([transactions, depreciations, vehicleClaim]: [Transaction[], Depreciation[], VehicleClaim]) => {
+            const chartAccountsHeadingsIds: number[] = enumToList(ChartAccountsHeadingVehicleListEnum)
+              .map((item: { label: string, value: number }) => item.value);
+            // get transactions & depreciations which chart accounts headings are belong to vehicle category
+            // but except KLMS transaction
+            const filteredItems: Array<Transaction | Depreciation> = [...transactions, ...depreciations].filter((item: Transaction | Depreciation) => {
+              return chartAccountsHeadingsIds.includes(item.chartAccounts.heading?.id) && !item.chartAccounts.isKlmsForWork();
+            });
+
+            // get claim amount sum
+            return filteredItems.reduce((sum: number, item: Transaction | Depreciation) =>
+              // @Todo remove item.amount negative sign when depreciations will be refactored and will have negative sign
+              sum + ((item instanceof Depreciation ? item.currentYearForecast.amount : -item.amount) * (vehicleClaim.workUsage / 100)), 0);
+          })
+        )
+      .subscribe((taxReturn: number) => {
+        this._vehicleTaxReturn = taxReturn;
+        this.vehicleTaxReturnSubject.next(this._vehicleTaxReturn);
+      });
+    }
+
+    return this.vehicleTaxReturnSubject.asObservable();
+  }
+
+  /**
+   * Update vehicle claim
+   * @param claim which should be updated
+   *
+   * @TODO alex refresh depreciation/transaction cache
+   */
+  updateVehicleClaim(claim: VehicleClaim): Observable<any> {
+    return this.http.put(`${this.environment.apiV2}/vehicle-claims/${claim.id}`, claim).pipe(
+      map((response: any) => {
+        const updatedVehicleClaim: VehicleClaim = plainToClass(VehicleClaim, response);
+        this._vehicleClaim = updatedVehicleClaim;
+        this.vehicleClaimSubject.next(this._vehicleClaim);
+
+        this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.VEHICLE_CLAIM_UPDATED, null));
+
+        return updatedVehicleClaim;
+      }));
+  }
+
+  /**
+   * Add new logbook for desired vehicle
+   * @param logbook which should be added
+   * @param vehicle for which logbook object should be added
+   */
+  addLogbook(logbook: VehicleLogbook, vehicle: Vehicle): Observable<void> {
+    return this.http.post(`${this.environment.apiV2}/vehicles/${vehicle.id}/logbooks`, logbook)
+      .pipe(
+        map((response: any) => {
+          this._vehicles.find((v: Vehicle) => v.id === vehicle.id).logbook.push(response);
+          // we update nested logbook object inside vehicles list. So list is not changed and next not emit subscriptions updates.
+          // that is why we recreate vehicles array
+          this.vehiclesSubject.next(this._vehicles.map((item: object) => plainToClass(Vehicle, item)));
+        })
+      );
+  }
+
+  /**
+   * Update logbook
+   * @param logbook which should be updated
+   * @param vehicle for which logbook object should be updated
+   */
+  updateLogbook(logbook: VehicleLogbook, vehicle: Vehicle): Observable<any> {
+    return this.http.put(`${this.environment.apiV2}/vehicles/${vehicle.id}/logbooks/${logbook.id}`, logbook).pipe(
+      map((response: any) => {
+        const editedVehicle: Vehicle = this._vehicles.find((v: Vehicle) => v.id === vehicle.id);
+        const editedLogbookIndex: number = editedVehicle.logbook.findIndex((l: VehicleLogbook) => l.id === logbook.id);
+        editedVehicle.logbook.splice(editedLogbookIndex, 1, plainToClass(VehicleLogbook, response));
+        // we update nested logbook object inside vehicles list. So list is not changed and next not emit subscriptions updates.
+        // that is why we recreate vehicles array
+        this.vehiclesSubject.next(this._vehicles.map((item: object) => plainToClass(Vehicle, item)));
+      })
+    );
+  }
+
+  /**
+   * Delete trip
+   * @param logbook for which trip should be deleted
+   * @param vehicle for which trip should be deleted
+   */
+  deleteTrip(logbook: VehicleLogbook, vehicle: Vehicle): Observable<any> {
+    return this.http.delete(`${this.environment.apiV2}/vehicles/${vehicle.id}/logbooks/${logbook.id}`)
+      .pipe(
+        map(() => {
+          const editedVehicle: Vehicle = this._vehicles.find((v: Vehicle) => v.id === vehicle.id);
+          const deletedLogbookIndex: number = editedVehicle.logbook.findIndex((l: VehicleLogbook) => l.id === logbook.id);
+          editedVehicle.logbook.splice(deletedLogbookIndex, 1);
+          // we update nested logbook object inside vehicles list. So list is not changed and next not emit subscriptions updates.
+          // that is why we recreate vehicles array
+          this.vehiclesSubject.next(this._vehicles.map((item: object) => plainToClass(Vehicle, item)));
+        })
+      );
+  }
+
+  /**
+   * Add new vehicle
+   * @param vehicle which should be added
+   */
+  addVehicle(vehicle: Vehicle): Observable<any> {
+    return this.http.post(`${this.environment.apiV2}/vehicles`, {name: vehicle.name})
+      .pipe(
+        map((response: any) => {
+          this._vehicles.push(plainToClass(Vehicle, response));
+          this.vehiclesSubject.next(this._vehicles);
+        })
+      );
+  }
+
+  /**
+   * Update vehicle
+   * @param vehicle which should be updated
+   */
+  updateVehicle(vehicle: Vehicle): Observable<any> {
+    return this.http.put(`${this.environment.apiV2}/vehicles/${vehicle.id}`, {name: vehicle.name})
+      .pipe(
+        map((response: any) => {
+          const editedVehicleIndex: number = this._vehicles.findIndex((v: Vehicle) => v.id === vehicle.id);
+          this._vehicles.splice(editedVehicleIndex, 1, plainToClass(Vehicle, response));
+          this.vehiclesSubject.next(this._vehicles);
+        })
+      );
+  }
+
+  /**
+   * Delete vehicle
+   * @param vehicle which should be deleted
+   */
+  deleteVehicle(vehicle: Vehicle): Observable<void> {
+    return this.http.delete(`${this.environment.apiV2}/vehicles/${vehicle.id}`)
+      .pipe(
+        map(() => {
+          const deletedVehicleIndex: number = this._vehicles.findIndex((v: Vehicle) => v.id === vehicle.id);
+          this._vehicles.splice(deletedVehicleIndex, 1);
+          // we update nested logbook object inside vehicles list. So list is not changed and next not emit subscriptions updates.
+          // that is why we recreate vehicles array
+          this.vehiclesSubject.next(this._vehicles.map((item: object) => plainToClass(Vehicle, item)));
+        })
+      );
+  }
+}

package/src/lib/tt-core.module.ts

@@ -0,0 +1,22 @@
+import { ModuleWithProviders, NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+
+@NgModule({
+  declarations: [],
+  imports: [
+    CommonModule
+  ]
+})
+export class TtCoreModule {
+  public static forRoot(environment: object): ModuleWithProviders<TtCoreModule> {
+    return {
+      ngModule: TtCoreModule,
+      providers: [
+        {
+          provide: 'environment',
+          useValue: environment
+        }
+      ]
+    };
+  }
+}

package/src/lib/tt-core.service.spec.ts

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

package/src/lib/tt-core.service.ts

@@ -0,0 +1,17 @@
+import { Inject, Injectable } from '@angular/core';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class TtCoreService {
+
+  constructor(
+    @Inject('environment') private environment: any
+  ) { }
+
+  test(): void {
+    console.log('test');
+
+    console.log(this.environment.apiV2)
+  }
+}