taxtank-core 0.32.2 → 0.32.5

package/fesm2022/taxtank-core.mjs

@@ -1554,7 +1554,9 @@ class FinancialYear {
     static { this.weeksInYear = 52; }
     static { this.monthsInYear = 12; }
     static { this.startMonthIndex = 6; }
-    static { this.year = +localStorage.getItem('financialYear'); }
+    static get year() {
+        return +localStorage.getItem('financialYear');
+    }
     constructor(date) {
         this.yearStartDate = '-07-01';
         this.yearEndDate = '-06-30';
@@ -4930,13 +4932,14 @@ class VehicleLogbook extends VehicleLogbook$1 {
         return this.odometerEnd - this.odometerStart;
     }
     get tankType() {
-        return this.isSoleTank() ? TankTypeEnum.SOLE : TankTypeEnum.WORK;
-    }
-    isWorkTank() {
-        return !this.business;
-    }
-    isSoleTank() {
-        return !!this.business;
+        switch (true) {
+            case !!this.business:
+                return TankTypeEnum.SOLE;
+            case this.isPersonal:
+                return TankTypeEnum.PERSONAL;
+            default:
+                return TankTypeEnum.WORK;
+        }
     }
 }
 __decorate([
@@ -8492,41 +8495,19 @@ class ReportItemCollection extends Collection {
 }
 
 class VehicleLogbookCollection extends Collection {
-    /**
-     * Get collection of non-personal logbooks (work-related, sole-related).
-     * @TODO Vik: Best period: move this and related logic to backend
-     */
-    getClaimableLogbooks(isSole = false) {
-        return this.filter((logbook) => !logbook.isPersonal && (isSole ? logbook.isSoleTank() : logbook.isWorkTank()));
-    }
     /**
      * Calculate total kilometers traveled
      */
     get kilometers() {
         return this.sumBy('kilometers');
     }
-    /**
-     * Calculate work usage (percent of business-related kilometers from total kilometers)
-     * @TODO Alex: TT-2089 replace with getter
-     */
-    get workUsage() {
-        if (!this.length) {
-            return 0;
-        }
-        const workKilometers = this.items
-            .filter((logbook) => !logbook.isPersonal)
-            .reduce((sum, logbook) => sum + logbook.kilometers, 0);
-        return round(workKilometers / this.kilometers * 100, 2);
+    getWorkUsage(vehicleClaim) {
+        return +(this.getClaimable(vehicleClaim).kilometers / this.kilometers * 100).toFixed(10);
     }
-    getWorkUsageByTank(isSole) {
-        const workKilometers = this.getClaimableLogbooks(isSole).items
-            .reduce((sum, logbook) => sum + logbook.kilometers, 0);
-        return round(workKilometers / this.kilometers * 100, 2);
-    }
-    /**
-     * Get list of logbooks related to passed vehicle claim
-     */
-    getByVehicleClaim(vehicleClaim) {
+    getClaimable(vehicleClaim) {
+        if (!vehicleClaim) {
+            return this.filter((logbook) => !logbook.isPersonal);
+        }
         return vehicleClaim.isSoleTank()
             // sole tank may have multiple vehicle claims, so we need to filter by business.id
             ? this.filterBy('business.id', vehicleClaim.business.id)
@@ -8536,8 +8517,8 @@ class VehicleLogbookCollection extends Collection {
     /**
      * get collection of logbooks with the biggest work usage for {@link BestVehicleLogbookCollection.periodDuration}
      */
-    getBest(isSole = false) {
-        return BestVehicleLogbookCollection.fromLogbooks(this, isSole);
+    getBest() {
+        return BestVehicleLogbookCollection.fromLogbooks(this);
     }
 }
 
@@ -8555,29 +8536,47 @@ class BestVehicleLogbookCollection extends VehicleLogbookCollection {
      * constructor is private because we want to prevent collection initialization via 'new' operator.
      * We should create instances only with fromLogbooks method
      */
-    constructor(logbooks, isSole = false) {
-        super([]);
-        this.isSole = isSole;
-        if (!this.isBestPeriodExist(logbooks)) {
-            return;
-        }
-        this.calculateBestPeriod(logbooks);
+    constructor(logbooks) {
+        super(logbooks);
     }
     /**
      * Best period may be calculated only when user has logbooks minimum for VehicleLogbook.bestPeriodWeeks
      */
-    isBestPeriodExist(logbooks = this) {
+    static isBestPeriodExist(logbooks) {
         if (logbooks.length < 2) {
             return false;
         }
         if (!(logbooks instanceof VehicleLogbookCollection)) {
             logbooks = new VehicleLogbookCollection(logbooks);
         }
-        return BestVehicleLogbookCollection.periodDuration < (logbooks.last.date.getTime() - logbooks.first.date.getTime());
+        return this.periodDuration < (logbooks.last.date.getTime() - logbooks.first.date.getTime());
     }
-    getWorkUsageByClaim(claim) {
-        const claimKilometers = this.getByVehicleClaim(claim).getClaimableLogbooks(this.isSole).kilometers;
-        return round(this.getWorkUsageByTank(this.isSole) * (claimKilometers / this.kilometers), 2);
+    // get list of date ranges for each of passed logbook
+    static getPeriods(logbooks) {
+        const claimable = logbooks.getClaimable();
+        // get a list of date ranges that could potentially be the best
+        const periods = claimable
+            // skip logbooks whose range ends after the last logbook
+            .filter((logbook) => this.getPeriodByLogbook(logbook).end.toDate() < logbooks.last.date)
+            .map((logbook) => this.getPeriodByLogbook(logbook));
+        // skip if the last logbook already included to the last existing date range
+        // if (last(periods).end.toDate() < logbooks.last.date) {
+        // add extra date range for the last claimable logbook
+        // @TODO vik
+        periods.push(this.getPeriodByLogbook(claimable.last, true));
+        // }
+        return periods;
+    }
+    /**
+     * Get claimable date range for passed logbook
+     * @param logbook logbook instance for range calculation
+     * @param isBackward Flag false - range for logbook + duration; flag true - range for logbook - duration. Used for extra case, when we should add an extra date range for the last logbook
+     */
+    static getPeriodByLogbook(logbook, isBackward = false) {
+        if (isBackward) {
+            return new DateRange([new Date(logbook.date.getTime() - this.periodDuration), logbook.date]);
+        }
+        return new DateRange([logbook.date, new Date(logbook.date.getTime() + this.periodDuration)]);
     }
     /**
      * Set Date Range with the biggest work usage percent
@@ -8593,44 +8592,22 @@ class BestVehicleLogbookCollection extends VehicleLogbookCollection {
      */
     calculateBestPeriod(logbooks) {
         // get a list of date ranges that could potentially be the best
-        const periods = this.getPeriods(logbooks);
+        const periods = BestVehicleLogbookCollection.getPeriods(logbooks);
         periods.forEach((period) => {
             const logbooksInPeriod = logbooks.filterByRange('date', period.start.toDate(), period.end.toDate());
-            if (!this.period || (this.getWorkUsageByTank(this.isSole) < logbooksInPeriod.getWorkUsageByTank(this.isSole))) {
+            if (!this.period || (this.getWorkUsage() < logbooksInPeriod.getWorkUsage())) {
                 this.period = period;
                 this.items = logbooksInPeriod.toArray();
             }
         });
     }
-    // get list of date ranges for each of passed logbook
-    getPeriods(logbooks) {
-        const claimable = logbooks.getClaimableLogbooks(this.isSole);
-        // get a list of date ranges that could potentially be the best
-        const periods = claimable
-            // skip logbooks whose range ends after the last logbook
-            .filter((logbook) => this.getPeriodByLogbook(logbook).end.toDate() < logbooks.last.date)
-            .map((logbook) => this.getPeriodByLogbook(logbook));
-        // skip if the last logbook already included to the last existing date range
-        // if (last(periods).end.toDate() < logbooks.last.date) {
-        // add extra date range for the last claimable logbook
-        periods.push(this.getPeriodByLogbook(claimable.last, true));
-        // }
-        return periods;
-    }
-    /**
-     * Get claimable date range for passed logbook
-     * @param logbook logbook instance for range calculation
-     * @param isBackward Flag false - range for logbook + duration; flag true - range for logbook - duration. Used for extra case, when we should add an extra date range for the last logbook
-     */
-    getPeriodByLogbook(logbook, isBackward = false) {
-        if (isBackward) {
-            return new DateRange([new Date(logbook.date.getTime() - BestVehicleLogbookCollection.periodDuration), logbook.date]);
+    static fromLogbooks(logbooks) {
+        if (!this.isBestPeriodExist(logbooks)) {
+            return null;
         }
-        return new DateRange([logbook.date, new Date(logbook.date.getTime() + BestVehicleLogbookCollection.periodDuration)]);
-    }
-    static fromLogbooks(logbooks, isSole = false) {
-        const collection = new BestVehicleLogbookCollection(logbooks, isSole);
-        return collection.isBestPeriodExist(logbooks) ? collection : null;
+        const collection = new BestVehicleLogbookCollection(logbooks.toArray());
+        collection.calculateBestPeriod(logbooks);
+        return collection;
     }
 }
 
@@ -15259,9 +15236,6 @@ class VehicleClaimService extends RestService {
         this.url = 'vehicle-claims';
         this.roles = [UserRolesEnum.WORK_TANK, UserRolesEnum.SOLE_TANK];
     }
-    listenEvents() {
-        this.listenVehicleClaimDetailsChanges();
-    }
     add(model) {
         return super.add(model).pipe(map((vehicleClaim) => {
             this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.VEHICLE_CLAIM_CREATED, vehicleClaim));
@@ -15274,32 +15248,16 @@ class VehicleClaimService extends RestService {
             return vehicleClaim;
         }));
     }
-    /**
-     * Details changes may affect vehicle claims:
-     * when details method changed, all claims current values become 0
-     */
-    listenVehicleClaimDetailsChanges() {
-        this.eventDispatcherService.on(AppEventTypeEnum.VEHICLE_CLAIM_DETAILS_UPDATED)
-            .subscribe(() => {
-            this.refreshCache();
-        });
-    }
     /**
      * Update workUsage for all vehicle claims if logbook best period changed
      * @TODO Vik: Best period move this and related logic to backend
      */
     updateWorkUsage(bestLogbooks) {
-        // no need to update if cache not exist
-        if (!this.cache) {
-            return;
-        }
-        // @TODO Vik (TT-2210): need batch endpoint for this update
-        // @TODO Alex (TT-2210): fix frontend when endpoint ready
-        const batch$ = this.cache.map((claim) => {
-            const claimToUpdate = plainToClass(VehicleClaim, Object.assign({}, claim, { workUsage: bestLogbooks.getWorkUsageByClaim(claim) }));
+        const batch$ = (this.cache ?? []).map((claim) => {
+            const claimToUpdate = plainToClass(VehicleClaim, Object.assign({}, claim, { workUsage: bestLogbooks.getWorkUsage(claim) }));
             return this.update(claimToUpdate);
         });
-        combineLatest(batch$).subscribe();
+        return combineLatest(batch$);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: VehicleClaimService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: VehicleClaimService, providedIn: 'root' }); }