taxtank-core 0.8.5 → 0.9.1

package/esm2015/lib/collections/collection.js

@@ -43,10 +43,7 @@ export class Collection {
     getIds() {
         return this.items.map((item) => item['id']);
     }
-    /**
-     * @TODO vik rename
-     */
-    getOneBy(path, value) {
+    findBy(path, value) {
         return this.items.find((item) => get(item, path) === value);
     }
     getBy(path, value) {
@@ -84,4 +81,4 @@ export class Collection {
         return last(this.items);
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sbGVjdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R0LWNvcmUvc3JjL2xpYi9jb2xsZWN0aW9ucy9jb2xsZWN0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQy9ELE9BQU8sS0FBSyxNQUFNLGNBQWMsQ0FBQztBQUNqQyxPQUFPLElBQUksTUFBTSxhQUFhLENBQUM7QUFDL0IsT0FBTyxHQUFHLE1BQU0sWUFBWSxDQUFDO0FBRTdCLE1BQU0sYUFBYSxHQUFHLE9BQU8sQ0FBQztBQUU5Qjs7R0FFRztBQUNILE1BQU0sT0FBTyxVQUFVO0lBSXJCLFlBQVksUUFBaUIsRUFBRTtRQUM3QixJQUFJLENBQUMsS0FBSyxHQUFHLEtBQUssQ0FBQztJQUNyQixDQUFDO0lBRUQsTUFBTSxDQUFDLFFBQWlCLEVBQUU7UUFDeEIsT0FBTyxJQUFLLElBQUksQ0FBQyxXQUFtQixDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQzlDLENBQUM7SUFFRCxPQUFPLENBQUMsT0FBZSxFQUFFO1FBQ3ZCLE9BQU8sSUFBSSxvQkFBb0IsQ0FBQyxJQUFJLEVBQUUsSUFBSSxDQUFDLENBQUM7SUFDOUMsQ0FBQztJQUVELE9BQU8sQ0FBQyxJQUFZO1FBQ2xCLHlDQUF5QztRQUN6QyxNQUFNLE1BQU0sR0FBNkIsRUFBRSxDQUFDO1FBRTVDLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQyxPQUFPLENBQUMsQ0FBQyxLQUFZLEVBQUUsRUFBRTtZQUN0QyxNQUFNLENBQUMsR0FBRyxDQUFDLEtBQUssRUFBRSxJQUFJLEVBQUUsYUFBYSxDQUFDLENBQUMsR0FBRyxLQUFLLENBQUM7UUFDbEQsQ0FBQyxDQUFDLENBQUM7UUFFSCxPQUFPLE1BQU0sQ0FBQztJQUNoQixDQUFDO0lBRUQ7O09BRUc7SUFDSCxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUM7UUFDZixnREFBZ0Q7UUFDaEQsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLE1BQU0sRUFBRSxDQUFDO0lBQzdCLENBQUM7SUFFRDs7T0FFRztJQUNILElBQUksTUFBTTtRQUNSLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUM7SUFDM0IsQ0FBQztJQUVEOztPQUVHO0lBQ0gsTUFBTTtRQUNKLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQyxJQUFXLEVBQVUsRUFBRSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO0lBQzdELENBQUM7SUFFRDs7T0FFRztJQUNILFFBQVEsQ0FBQyxJQUFZLEVBQUUsS0FBVTtRQUMvQixPQUFPLElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUMsSUFBVyxFQUFFLEVBQUUsQ0FBQyxHQUFHLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxLQUFLLEtBQUssQ0FBQyxDQUFDO0lBQ3JFLENBQUM7SUFFRCxLQUFLLENBQUMsSUFBWSxFQUFFLEtBQVU7UUFDNUIsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLENBQUMsSUFBVyxFQUFFLEVBQUUsQ0FBQyxHQUFHLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxLQUFLLEtBQUssQ0FBQyxDQUFDLENBQUM7SUFDcEYsQ0FBQztJQUVEOztPQUVHO0lBQ0gsT0FBTyxDQUFDLEVBQVU7UUFDaEIsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxDQUFDLElBQVcsRUFBVyxFQUFFLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQyxDQUFDO0lBQ3RFLENBQUM7SUFFRCxRQUFRLENBQUMsR0FBYTtRQUNwQixPQUFPLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLENBQUMsSUFBVyxFQUFXLEVBQUUsQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDL0UsQ0FBQztJQUVEOzs7T0FHRztJQUNILEtBQUssQ0FBQyxLQUFhO1FBQ2pCLE9BQU8sQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxDQUFDLEdBQVcsRUFBRSxJQUFXLEVBQVUsRUFBRSxDQUFDLEdBQUcsR0FBRyxNQUFNLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQzNHLENBQUM7SUFFRCxPQUFPO1FBQ0wsT0FBTyxDQUFDLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQ3pCLENBQUM7SUFFRDs7T0FFRztJQUNILE1BQU0sQ0FBQyxRQUFrQztRQUN2QyxPQUFPLElBQUksVUFBVSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUM7SUFDckQsQ0FBQztJQUVELElBQUksS0FBSztRQUNQLE9BQU8sS0FBSyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUMzQixDQUFDO0lBRUQsSUFBSSxJQUFJO1FBQ04sT0FBTyxJQUFJLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQzFCLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbGxlY3Rpb25EaWN0aW9uYXJ5IH0gZnJvbSAnLi9jb2xsZWN0aW9uLWRpY3Rpb25hcnknO1xyXG5pbXBvcnQgZmlyc3QgZnJvbSAnbG9kYXNoL2ZpcnN0JztcclxuaW1wb3J0IGxhc3QgZnJvbSAnbG9kYXNoL2xhc3QnO1xyXG5pbXBvcnQgZ2V0IGZyb20gJ2xvZGFzaC9nZXQnO1xyXG5cclxuY29uc3QgREVGQVVMVF9JTkRFWCA9ICdvdGhlcic7XHJcblxyXG4vKipcclxuICogQmFzZSBjb2xsZWN0aW9uIGNsYXNzLiBDb250YWlucyBjb21tb24gcHJvcGVydGllcyBhbmQgbWV0aG9kcyBmb3IgYWxsIGNvbGxlY3Rpb25zXHJcbiAqL1xyXG5leHBvcnQgY2xhc3MgQ29sbGVjdGlvbjxNb2RlbCBleHRlbmRzIG9iamVjdD4gaW1wbGVtZW50cyBJdGVyYWJsZTxNb2RlbD4ge1xyXG4gIC8vIGxpc3Qgb2YgY29sbGVjdGlvbidzIGl0ZW1zXHJcbiAgaXRlbXM6IE1vZGVsW107XHJcblxyXG4gIGNvbnN0cnVjdG9yKGl0ZW1zOiBNb2RlbFtdID0gW10pIHtcclxuICAgIHRoaXMuaXRlbXMgPSBpdGVtcztcclxuICB9XHJcblxyXG4gIGNyZWF0ZShpdGVtczogTW9kZWxbXSA9IFtdKTogdGhpcyB7XHJcbiAgICByZXR1cm4gbmV3ICh0aGlzLmNvbnN0cnVjdG9yIGFzIGFueSkoaXRlbXMpO1xyXG4gIH1cclxuXHJcbiAgZ3JvdXBCeShwYXRoOiBzdHJpbmcgPSAnJyk6IENvbGxlY3Rpb25EaWN0aW9uYXJ5PENvbGxlY3Rpb248TW9kZWw+PiB7XHJcbiAgICByZXR1cm4gbmV3IENvbGxlY3Rpb25EaWN0aW9uYXJ5KHRoaXMsIHBhdGgpO1xyXG4gIH1cclxuXHJcbiAgaW5kZXhCeShwYXRoOiBzdHJpbmcpOiBvYmplY3Qge1xyXG4gICAgLy8gQ3JlYXRlIGVtcHR5IGluaXRpYWwgb2JqZWN0IGZvciBncm91cHNcclxuICAgIGNvbnN0IHJlc3VsdDogeyBba2V5OiBzdHJpbmddOiBNb2RlbCB9ID0ge307XHJcblxyXG4gICAgdGhpcy50b0FycmF5KCkuZm9yRWFjaCgobW9kZWw6IE1vZGVsKSA9PiB7XHJcbiAgICAgIHJlc3VsdFtnZXQobW9kZWwsIHBhdGgsIERFRkFVTFRfSU5ERVgpXSA9IG1vZGVsO1xyXG4gICAgfSk7XHJcblxyXG4gICAgcmV0dXJuIHJlc3VsdDtcclxuICB9XHJcblxyXG4gIC8qKlxyXG4gICAqIEl0ZXJhdG9yIHRoYXQgYWxsb3cgdG8gaXRlcmF0ZSBjb2xsZWN0aW9uIGl0ZW1zXHJcbiAgICovXHJcbiAgW1N5bWJvbC5pdGVyYXRvcl0oKTogSXRlcmF0b3I8TW9kZWw+IHtcclxuICAgIC8vIC52YWx1ZXMoKSByZXR1cm5zIEl0ZXJhdG9yIGluc3RhbmNlIGZvciBhcnJheVxyXG4gICAgcmV0dXJuIHRoaXMuaXRlbXMudmFsdWVzKCk7XHJcbiAgfVxyXG5cclxuICAvKipcclxuICAgKiBnZXQgY29sbGVjdGlvbiBsZW5ndGhcclxuICAgKi9cclxuICBnZXQgbGVuZ3RoKCk6IG51bWJlciB7XHJcbiAgICByZXR1cm4gdGhpcy5pdGVtcy5sZW5ndGg7XHJcbiAgfVxyXG5cclxuICAvKipcclxuICAgKiBHZXQgbGlzdCBvZiBpdGVtcyBpZHNcclxuICAgKi9cclxuICBnZXRJZHMoKTogbnVtYmVyW10ge1xyXG4gICAgcmV0dXJuIHRoaXMuaXRlbXMubWFwKChpdGVtOiBNb2RlbCk6IG51bWJlciA9PiBpdGVtWydpZCddKTtcclxuICB9XHJcblxyXG4gIC8qKlxyXG4gICAqIEBUT0RPIHZpayByZW5hbWVcclxuICAgKi9cclxuICBnZXRPbmVCeShwYXRoOiBzdHJpbmcsIHZhbHVlOiBhbnkpOiBNb2RlbCB7XHJcbiAgICByZXR1cm4gdGhpcy5pdGVtcy5maW5kKChpdGVtOiBNb2RlbCkgPT4gZ2V0KGl0ZW0sIHBhdGgpID09PSB2YWx1ZSk7XHJcbiAgfVxyXG5cclxuICBnZXRCeShwYXRoOiBzdHJpbmcsIHZhbHVlOiBhbnkpOiB0aGlzIHtcclxuICAgIHJldHVybiB0aGlzLmNyZWF0ZSh0aGlzLml0ZW1zLmZpbHRlcigoaXRlbTogTW9kZWwpID0+IGdldChpdGVtLCBwYXRoKSA9PT0gdmFsdWUpKTtcclxuICB9XHJcblxyXG4gIC8qKlxyXG4gICAqIEdldCBzaW5nbGUgaXRlbSBieSBpZFxyXG4gICAqL1xyXG4gIGdldEJ5SWQoaWQ6IG51bWJlcik6IE1vZGVsIHtcclxuICAgIHJldHVybiB0aGlzLml0ZW1zLmZpbmQoKGl0ZW06IE1vZGVsKTogYm9vbGVhbiA9PiBpdGVtWydpZCddID09PSBpZCk7XHJcbiAgfVxyXG5cclxuICBnZXRCeUlkcyhpZHM6IG51bWJlcltdKTogTW9kZWxbXSB7XHJcbiAgICByZXR1cm4gdGhpcy5pdGVtcy5maWx0ZXIoKGl0ZW06IE1vZGVsKTogYm9vbGVhbiA9PiBpZHMuaW5jbHVkZXMoaXRlbVsnaWQnXSkpO1xyXG4gIH1cclxuXHJcbiAgLyoqXHJcbiAgICogR2V0IHRvdGFsIHN1bSBvZiBpdGVtcyBieSBmaWVsZFxyXG4gICAqIEBwYXJhbSBmaWVsZCBOYW1lIG9mIHRoZSBmaWVsZCBmb3Igc3VtXHJcbiAgICovXHJcbiAgc3VtQnkoZmllbGQ6IHN0cmluZyk6IG51bWJlciB7XHJcbiAgICByZXR1cm4gK3RoaXMuaXRlbXMucmVkdWNlKChzdW06IG51bWJlciwgaXRlbTogTW9kZWwpOiBudW1iZXIgPT4gc3VtICsgTnVtYmVyKGl0ZW1bZmllbGRdKSwgMCkudG9GaXhlZCgyKTtcclxuICB9XHJcblxyXG4gIHRvQXJyYXkoKTogTW9kZWxbXSB7XHJcbiAgICByZXR1cm4gWy4uLnRoaXMuaXRlbXNdO1xyXG4gIH1cclxuXHJcbiAgLyoqXHJcbiAgICogRmlsdGVyIGl0ZW1zIGJ5IHNwZWNpZmljIHByb3ZpZGVkIGNhbGxiYWNrXHJcbiAgICovXHJcbiAgZmlsdGVyKGNhbGxiYWNrOiAoaXRlbTogTW9kZWwpID0+IGJvb2xlYW4pOiBDb2xsZWN0aW9uPE1vZGVsPiB7XHJcbiAgICByZXR1cm4gbmV3IENvbGxlY3Rpb24odGhpcy5pdGVtcy5maWx0ZXIoY2FsbGJhY2spKTtcclxuICB9XHJcblxyXG4gIGdldCBmaXJzdCgpOiBNb2RlbCB7XHJcbiAgICByZXR1cm4gZmlyc3QodGhpcy5pdGVtcyk7XHJcbiAgfVxyXG5cclxuICBnZXQgbGFzdCgpOiBNb2RlbCB7XHJcbiAgICByZXR1cm4gbGFzdCh0aGlzLml0ZW1zKTtcclxuICB9XHJcbn1cclxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/db/Models/transaction-base.js

@@ -11,10 +11,11 @@ export class TransactionBase {
      * Check if current tank is Work
      */
     isWorkTank() {
+        // @TODO remove this hack
         if (this.tankType) {
             return this.tankType === TankTypeEnum.WORK;
         }
         return CHART_ACCOUNTS_CATEGORIES.work.includes(this.chartAccounts.category);
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNhY3Rpb24tYmFzZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R0LWNvcmUvc3JjL2xpYi9kYi9Nb2RlbHMvdHJhbnNhY3Rpb24tYmFzZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSw2REFBNkQsQ0FBQztBQUN4RyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFdkQsTUFBTSxPQUFPLGVBQWU7SUFXMUI7O09BRUc7SUFDSCxjQUFjO1FBQ1osT0FBTyxDQUFDLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQztJQUN6QixDQUFDO0lBRUQ7O09BRUc7SUFDSCxVQUFVO1FBQ1IsSUFBSSxJQUFJLENBQUMsUUFBUSxFQUFFO1lBQ2pCLE9BQU8sSUFBSSxDQUFDLFFBQVEsS0FBSyxZQUFZLENBQUMsSUFBSSxDQUFDO1NBQzVDO1FBQ0QsT0FBTyx5QkFBeUIsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxhQUFhLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDOUUsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUHJvcGVydHkgfSBmcm9tICcuL3Byb3BlcnR5L3Byb3BlcnR5JztcbmltcG9ydCB7IENoYXJ0QWNjb3VudHMgfSBmcm9tICcuL2NoYXJ0LWFjY291bnRzJztcbmltcG9ydCB7IENIQVJUX0FDQ09VTlRTX0NBVEVHT1JJRVMgfSBmcm9tICcuLi8uLi9tb2RlbHMvY2hhcnQtYWNjb3VudHMvY2hhcnQtYWNjb3VudHMtY2F0ZWdvcmllcy5jb25zdCc7XG5pbXBvcnQgeyBUYW5rVHlwZUVudW0gfSBmcm9tICcuLi9FbnVtcy90YW5rLXR5cGUuZW51bSc7XG5cbmV4cG9ydCBjbGFzcyBUcmFuc2FjdGlvbkJhc2Uge1xuICBpZD86IG51bWJlcjtcbiAgYW1vdW50PzogbnVtYmVyO1xuICBwcm9wZXJ0eT86IFByb3BlcnR5O1xuICBkYXRlPzogRGF0ZTtcbiAgY2hhcnRBY2NvdW50cz86IENoYXJ0QWNjb3VudHM7XG4gIGRlc2NyaXB0aW9uPzogc3RyaW5nO1xuICBmaWxlPzogRmlsZTtcbiAgY2xhaW1QZXJjZW50PzogbnVtYmVyO1xuICB0YW5rVHlwZTogVGFua1R5cGVFbnVtO1xuXG4gIC8qKlxuICAgKiBDaGVjayBpZiBjdXJyZW50IHRhbmsgaXMgUHJvcGVydHlcbiAgICovXG4gIGlzUHJvcGVydHlUYW5rKCk6IGJvb2xlYW4ge1xuICAgIHJldHVybiAhIXRoaXMucHJvcGVydHk7XG4gIH1cblxuICAvKipcbiAgICogQ2hlY2sgaWYgY3VycmVudCB0YW5rIGlzIFdvcmtcbiAgICovXG4gIGlzV29ya1RhbmsoKTogYm9vbGVhbiB7XG4gICAgaWYgKHRoaXMudGFua1R5cGUpIHtcbiAgICAgIHJldHVybiB0aGlzLnRhbmtUeXBlID09PSBUYW5rVHlwZUVudW0uV09SSztcbiAgICB9XG4gICAgcmV0dXJuIENIQVJUX0FDQ09VTlRTX0NBVEVHT1JJRVMud29yay5pbmNsdWRlcyh0aGlzLmNoYXJ0QWNjb3VudHMuY2F0ZWdvcnkpO1xuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNhY3Rpb24tYmFzZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R0LWNvcmUvc3JjL2xpYi9kYi9Nb2RlbHMvdHJhbnNhY3Rpb24tYmFzZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSw2REFBNkQsQ0FBQztBQUN4RyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFdkQsTUFBTSxPQUFPLGVBQWU7SUFXMUI7O09BRUc7SUFDSCxjQUFjO1FBQ1osT0FBTyxDQUFDLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQztJQUN6QixDQUFDO0lBRUQ7O09BRUc7SUFDSCxVQUFVO1FBQ1IseUJBQXlCO1FBQ3pCLElBQUksSUFBSSxDQUFDLFFBQVEsRUFBRTtZQUNqQixPQUFPLElBQUksQ0FBQyxRQUFRLEtBQUssWUFBWSxDQUFDLElBQUksQ0FBQztTQUM1QztRQUNELE9BQU8seUJBQXlCLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsYUFBYSxDQUFDLFFBQVEsQ0FBQyxDQUFDO0lBQzlFLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFByb3BlcnR5IH0gZnJvbSAnLi9wcm9wZXJ0eS9wcm9wZXJ0eSc7XG5pbXBvcnQgeyBDaGFydEFjY291bnRzIH0gZnJvbSAnLi9jaGFydC1hY2NvdW50cyc7XG5pbXBvcnQgeyBDSEFSVF9BQ0NPVU5UU19DQVRFR09SSUVTIH0gZnJvbSAnLi4vLi4vbW9kZWxzL2NoYXJ0LWFjY291bnRzL2NoYXJ0LWFjY291bnRzLWNhdGVnb3JpZXMuY29uc3QnO1xuaW1wb3J0IHsgVGFua1R5cGVFbnVtIH0gZnJvbSAnLi4vRW51bXMvdGFuay10eXBlLmVudW0nO1xuXG5leHBvcnQgY2xhc3MgVHJhbnNhY3Rpb25CYXNlIHtcbiAgaWQ/OiBudW1iZXI7XG4gIGFtb3VudD86IG51bWJlcjtcbiAgcHJvcGVydHk/OiBQcm9wZXJ0eTtcbiAgZGF0ZT86IERhdGU7XG4gIGNoYXJ0QWNjb3VudHM/OiBDaGFydEFjY291bnRzO1xuICBkZXNjcmlwdGlvbj86IHN0cmluZztcbiAgZmlsZT86IEZpbGU7XG4gIGNsYWltUGVyY2VudD86IG51bWJlcjtcbiAgdGFua1R5cGU6IFRhbmtUeXBlRW51bTtcblxuICAvKipcbiAgICogQ2hlY2sgaWYgY3VycmVudCB0YW5rIGlzIFByb3BlcnR5XG4gICAqL1xuICBpc1Byb3BlcnR5VGFuaygpOiBib29sZWFuIHtcbiAgICByZXR1cm4gISF0aGlzLnByb3BlcnR5O1xuICB9XG5cbiAgLyoqXG4gICAqIENoZWNrIGlmIGN1cnJlbnQgdGFuayBpcyBXb3JrXG4gICAqL1xuICBpc1dvcmtUYW5rKCk6IGJvb2xlYW4ge1xuICAgIC8vIEBUT0RPIHJlbW92ZSB0aGlzIGhhY2tcbiAgICBpZiAodGhpcy50YW5rVHlwZSkge1xuICAgICAgcmV0dXJuIHRoaXMudGFua1R5cGUgPT09IFRhbmtUeXBlRW51bS5XT1JLO1xuICAgIH1cbiAgICByZXR1cm4gQ0hBUlRfQUNDT1VOVFNfQ0FURUdPUklFUy53b3JrLmluY2x1ZGVzKHRoaXMuY2hhcnRBY2NvdW50cy5jYXRlZ29yeSk7XG4gIH1cbn1cbiJdfQ==

package/esm2015/lib/models/toast/toast-type.enum.js

@@ -0,0 +1,8 @@
+export var ToastTypeEnum;
+(function (ToastTypeEnum) {
+    ToastTypeEnum[ToastTypeEnum["INFO"] = 0] = "INFO";
+    ToastTypeEnum[ToastTypeEnum["SUCCESS"] = 1] = "SUCCESS";
+    ToastTypeEnum[ToastTypeEnum["WARNING"] = 2] = "WARNING";
+    ToastTypeEnum[ToastTypeEnum["ERROR"] = 3] = "ERROR";
+})(ToastTypeEnum || (ToastTypeEnum = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9hc3QtdHlwZS5lbnVtLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL21vZGVscy90b2FzdC90b2FzdC10eXBlLmVudW0udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFOLElBQVksYUFLWDtBQUxELFdBQVksYUFBYTtJQUN2QixpREFBSSxDQUFBO0lBQ0osdURBQU8sQ0FBQTtJQUNQLHVEQUFPLENBQUE7SUFDUCxtREFBSyxDQUFBO0FBQ1AsQ0FBQyxFQUxXLGFBQWEsS0FBYixhQUFhLFFBS3hCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gVG9hc3RUeXBlRW51bSB7XG4gIElORk8sXG4gIFNVQ0NFU1MsXG4gIFdBUk5JTkcsXG4gIEVSUk9SXG59XG4iXX0=

package/esm2015/lib/models/toast/toast.js

@@ -0,0 +1,9 @@
+/**
+ * Common toast message class
+ */
+export class Toast {
+    constructor() {
+        this.duration = 3000;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9hc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvbW9kZWxzL3RvYXN0L3RvYXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBOztHQUVHO0FBQ0gsTUFBTSxPQUFPLEtBQUs7SUFBbEI7UUFJRSxhQUFRLEdBQVcsSUFBSSxDQUFDO0lBQzFCLENBQUM7Q0FBQSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFRvYXN0VHlwZUVudW0gfSBmcm9tICcuL3RvYXN0LXR5cGUuZW51bSc7XG5cbi8qKlxuICogQ29tbW9uIHRvYXN0IG1lc3NhZ2UgY2xhc3NcbiAqL1xuZXhwb3J0IGNsYXNzIFRvYXN0IHtcbiAgdHlwZTogVG9hc3RUeXBlRW51bTtcbiAgdGl0bGU6IHN0cmluZztcbiAgbWVzc2FnZTogc3RyaW5nO1xuICBkdXJhdGlvbjogbnVtYmVyID0gMzAwMDtcbn1cbiJdfQ==

package/esm2015/lib/services/http/address/address.service.js

@@ -0,0 +1,39 @@
+import { Inject, Injectable } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import { Country } from '../../../models/address/country';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class AddressService {
+    constructor(http, environment) {
+        this.http = http;
+        this.environment = environment;
+        this.countriesSubject = new ReplaySubject(1);
+    }
+    getCountries() {
+        if (!this._countries) {
+            this.http.get(`${this.environment.apiV2}/countries`)
+                .pipe(map((response) => {
+                return response['hydra:member'].map((item) => plainToClass(Country, item));
+            }))
+                .subscribe((countries) => {
+                this._countries = countries;
+                this.countriesSubject.next(countries);
+            });
+        }
+        return this.countriesSubject.asObservable();
+    }
+}
+AddressService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: AddressService, deps: [{ token: i1.HttpClient }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+AddressService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: AddressService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: AddressService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/http/bank/bank-account/bank-account.service.js

@@ -0,0 +1,118 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import _ from 'lodash';
+import { replace } from '../../../../functions/array';
+import { plainToClass } from 'class-transformer';
+import { RestService } from '../../rest/rest.service';
+import { BankAccount } from '../../../../models/bank/bank-account';
+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";
+/**
+ * Service that handling user's bank accounts logic
+ */
+export class BankAccountService extends RestService {
+    constructor(http, eventDispatcherService, environment) {
+        super(http, eventDispatcherService, environment);
+        this.http = http;
+        this.eventDispatcherService = eventDispatcherService;
+        this.environment = environment;
+        // api url parameter for bank accounts
+        this.url = 'bank-accounts';
+        this.modelClass = BankAccount;
+        this.listenEvents();
+    }
+    /**
+     * Listen system notifications and update cache when got basiq notification received
+     */
+    listenEvents() {
+        this.listenToEventDispatcherChanges();
+    }
+    /**
+     * Created manual bank account
+     * @param bankAccounts
+     * @param queryParams
+     */
+    addBatch(bankAccounts, queryParams = {}) {
+        return this.http.post(`${this.environment.apiV2}/${this.url}`, bankAccounts)
+            .pipe(map((newBankAccountsBase) => {
+            const newBankAccounts = newBankAccountsBase.map((bankAccountBase) => plainToClass(BankAccount, bankAccountBase));
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.BANK_ACCOUNT_CREATED, newBankAccounts));
+            const tempCache = _.cloneDeep(this.cache);
+            tempCache.push(...newBankAccounts);
+            this.cache = tempCache;
+            this.updateCache();
+            return newBankAccounts;
+        }));
+    }
+    /**
+     * Update bank account and fire event
+     */
+    update(bankAccount) {
+        return super.update(bankAccount).pipe(map((updatedBankAccount) => {
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.BANK_ACCOUNT_UPDATED, updatedBankAccount));
+            return updatedBankAccount;
+        }));
+    }
+    /**
+     * Update bank account opening balance
+     * @param bankAccount Bank account for balance updating
+     */
+    updateOpeningBalance(bankAccount) {
+        return this.http.put(`${this.environment.apiV2}/${this.url}/${bankAccount.id}/opening-balances/${bankAccount.getCurrentYearBalance().id}`, bankAccount.getCurrentYearBalance())
+            .pipe(map((response) => {
+            const tempCache = _.cloneDeep(this.cache);
+            replace(tempCache[tempCache.findIndex((ba) => ba.id === bankAccount.id)].balances, response);
+            this.cache = tempCache;
+            this.updateCache();
+        }));
+    }
+    /**
+     * Update bank account current balance
+     */
+    updateCurrentBalance(bankAccount) {
+        return this.http.put(`${this.environment.apiV2}/${this.url}/${bankAccount.id}/balance`, bankAccount)
+            .pipe(map((response) => {
+            const updatedBankAccount = plainToClass(BankAccount, response);
+            replace(this.cache, updatedBankAccount);
+            this.updateCache();
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.BANK_ACCOUNT_UPDATED, updatedBankAccount));
+            return updatedBankAccount;
+        }));
+    }
+    getOwn() {
+        return this.get()
+            .pipe(map((bankAccounts) => {
+            return bankAccounts.filter((bankAccount) => bankAccount.isOwner(+localStorage.getItem('userId')));
+        }));
+    }
+    /**
+     * Listen to EventDispatcherService events
+     */
+    listenToEventDispatcherChanges() {
+        this.eventDispatcherService.on([
+            AppEventTypeEnum.PROPERTY_SHARE_UPDATED,
+            AppEventTypeEnum.LOAN_PAYOUT_UPDATED,
+            AppEventTypeEnum.BANK_CONNECTION_ADDED
+        ]).subscribe(() => {
+            this.fetch().subscribe((bankAccounts) => {
+                this.cache = bankAccounts;
+                this.updateCache();
+            });
+        });
+    }
+}
+BankAccountService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankAccountService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+BankAccountService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankAccountService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankAccountService, 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":"bank-account.service.js","sourceRoot":"","sources":["../../../../../../../../projects/tt-core/src/lib/services/http/bank/bank-account/bank-account.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Injectable} from '@angular/core';\nimport {HttpClient} from '@angular/common/http';\nimport {Observable} from 'rxjs';\nimport {BankAccount as BankAccountBase} from '../../../../db/Models/bank-account';\nimport {map} from 'rxjs/operators';\nimport _ from 'lodash';\nimport {replace} from '../../../../functions/array';\nimport {plainToClass} from 'class-transformer';\nimport {RestService} from '../../rest/rest.service';\nimport {BankAccount} from '../../../../models/bank/bank-account';\nimport {EventDispatcherService} from '../../../event/event-dispatcher.service';\nimport {AppEvent} from '../../../../models/event/app-event';\nimport {AppEventTypeEnum} from '../../../../models/event/app-event-type.enum';\n\n/**\n * Service that handling user's bank accounts logic\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class BankAccountService extends RestService<BankAccountBase, BankAccount> {\n  // api url parameter for bank accounts\n  url: string = 'bank-accounts';\n  modelClass = BankAccount;\n\n  constructor(\n    protected http: HttpClient,\n    protected eventDispatcherService: EventDispatcherService,\n    @Inject('environment') protected environment: any\n  ) {\n    super(http, eventDispatcherService, environment);\n    this.listenEvents();\n  }\n\n  /**\n   * Listen system notifications and update cache when got basiq notification received\n   */\n  listenEvents(): void {\n    this.listenToEventDispatcherChanges();\n  }\n\n  /**\n   * Created manual bank account\n   * @param bankAccounts\n   * @param queryParams\n   */\n  addBatch(bankAccounts: BankAccount[], queryParams: object = {}): Observable<BankAccount[]> {\n    return this.http.post(`${this.environment.apiV2}/${this.url}`, bankAccounts)\n      .pipe(\n        map((newBankAccountsBase: BankAccountBase[]) => {\n          const newBankAccounts: BankAccount[] = newBankAccountsBase.map((bankAccountBase: BankAccountBase): BankAccount => plainToClass(BankAccount, bankAccountBase));\n          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.BANK_ACCOUNT_CREATED, newBankAccounts));\n          const tempCache: BankAccount[] = _.cloneDeep(this.cache);\n          tempCache.push(...newBankAccounts);\n          this.cache = tempCache;\n          this.updateCache();\n          return newBankAccounts;\n        })\n      );\n  }\n\n  /**\n   * Update bank account and fire event\n   */\n  update(bankAccount: BankAccount): Observable<BankAccount> {\n    return super.update(bankAccount).pipe(\n      map((updatedBankAccount: BankAccount) => {\n        this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.BANK_ACCOUNT_UPDATED, updatedBankAccount));\n        return updatedBankAccount;\n      })\n    );\n  }\n\n  /**\n   * Update bank account opening balance\n   * @param bankAccount Bank account for balance updating\n   */\n  updateOpeningBalance(bankAccount: BankAccount): Observable<any> {\n    return this.http.put(`${this.environment.apiV2}/${this.url}/${bankAccount.id}/opening-balances/${bankAccount.getCurrentYearBalance().id}`, bankAccount.getCurrentYearBalance())\n      .pipe(\n        map((response: object) => {\n          const tempCache: BankAccount[] = _.cloneDeep(this.cache);\n\n          replace(tempCache[tempCache.findIndex((ba: BankAccount) => ba.id === bankAccount.id)].balances, response);\n          this.cache = tempCache;\n          this.updateCache();\n        })\n      );\n  }\n\n  /**\n   * Update bank account current balance\n   */\n  updateCurrentBalance(bankAccount: BankAccount): Observable<BankAccount> {\n    return this.http.put(`${this.environment.apiV2}/${this.url}/${bankAccount.id}/balance`, bankAccount)\n      .pipe(\n        map((response: object) => {\n          const updatedBankAccount: BankAccount = plainToClass(BankAccount, response);\n\n          replace(this.cache, updatedBankAccount);\n          this.updateCache();\n\n          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.BANK_ACCOUNT_UPDATED, updatedBankAccount));\n          return updatedBankAccount;\n        })\n      );\n  }\n\n  getOwn(): Observable<BankAccount[]> {\n    return this.get()\n      .pipe(\n        map((bankAccounts: BankAccount[]) => {\n          return bankAccounts.filter((bankAccount: BankAccount) => bankAccount.isOwner(+localStorage.getItem('userId')));\n        })\n      );\n  }\n\n  /**\n   * Listen to EventDispatcherService events\n   */\n  private listenToEventDispatcherChanges(): void {\n    this.eventDispatcherService.on([\n      AppEventTypeEnum.PROPERTY_SHARE_UPDATED,\n      AppEventTypeEnum.LOAN_PAYOUT_UPDATED,\n      AppEventTypeEnum.BANK_CONNECTION_ADDED\n    ]).subscribe(() => {\n      this.fetch().subscribe((bankAccounts: BankAccount[]) => {\n        this.cache = bankAccounts;\n        this.updateCache();\n      });\n    });\n  }\n}\n"]}

package/esm2015/lib/services/http/bank/bank-connection/bank-connection.service.js

@@ -0,0 +1,52 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { plainToClass } from 'class-transformer';
+import { BankConnection } from '../../../../models/bank/bank-connection';
+import { RestService } from '../../rest/rest.service';
+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";
+/**
+ * BankConnection means user account at specific bank (usually each user has only one at the same bank)
+ * service handles BankConnection management
+ */
+export class BankConnectionService extends RestService {
+    constructor(http, eventDispatcherService, environment) {
+        super(http, eventDispatcherService, environment);
+        this.http = http;
+        this.eventDispatcherService = eventDispatcherService;
+        this.environment = environment;
+        this.modelClass = BankConnection;
+        this.url = 'bank-connections';
+        this.listenEvents();
+    }
+    listenEvents() {
+        this.listenToAddedBankAccounts();
+    }
+    post(bankConnection) {
+        return this.http.post(`${this.environment.apiV2}/${this.url}`, bankConnection)
+            .pipe(map((bankConnectionBase) => {
+            this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.BANK_CONNECTION_ADDED, null));
+            return plainToClass(BankConnection, bankConnectionBase);
+        }));
+    }
+    listenToAddedBankAccounts() {
+        this.eventDispatcherService.on(AppEventTypeEnum.BANK_ACCOUNT_CREATED).subscribe(() => {
+            this.resetCache();
+        });
+    }
+}
+BankConnectionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankConnectionService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+BankConnectionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankConnectionService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankConnectionService, 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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

package/esm2015/lib/services/http/bank/bank-transaction/bank-transaction.service.js

@@ -0,0 +1,89 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { RestService } from '../../rest/rest.service';
+import { plainToClass } from 'class-transformer';
+import { UserEventTypeClientTypeEnum } from '../../../../db/Enums/user-event-type-client-type.enum';
+import { BankTransaction } from '../../../../models/bank/bank-transaction';
+import { FinancialYear } from '../../../../models/financial-year/financial-year';
+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";
+/**
+ * Service for bank transactions business logic
+ */
+export class BankTransactionService extends RestService {
+    constructor(http, eventDispatcherService, environment) {
+        super(http, eventDispatcherService, environment);
+        this.http = http;
+        this.eventDispatcherService = eventDispatcherService;
+        this.environment = environment;
+        // url part for BankTransaction API
+        this.url = 'bank-transactions';
+        this.modelClass = BankTransaction;
+        this.listenEvents();
+    }
+    listenEvents() {
+        this.listenBankTransactionsImport();
+    }
+    ;
+    /**
+     * get list of bank transactions for passed bank account id
+     * @param bankAccountId Id of bank account we search bank transactions for
+     */
+    getByBankAccountId(bankAccountId) {
+        return this.get()
+            .pipe(map((bankTransactions) => {
+            return bankTransactions.filter((bankTransaction) => bankTransaction.bankAccount.id === bankAccountId);
+        }));
+    }
+    /**
+     * Get list of bank transactions for provided financial year
+     * @TODO VIK/Alex: consider to use one endpoint to get bank transactions for 2 fin years
+     */
+    getTransactionsByYear(finYear) {
+        return this.http.get(`${this.environment.apiV2}/bank-transactions?financialYear=${finYear}`)
+            .pipe(map((bankTransactionsBase) => {
+            return bankTransactionsBase.map((bankTransaction) => plainToClass(BankTransaction, bankTransaction));
+        }));
+    }
+    /**
+     * import bank transactions from csv file
+     * @param bankAccountId Bank account id we import bank transactions for
+     * @param file File with bank transactions for import
+     */
+    import(bankAccountId, file) {
+        const formData = new FormData();
+        formData.append('file', file);
+        return this.http.post(`${this.environment.apiV2}/bank-accounts/${bankAccountId}/bank-transaction-imports`, formData)
+            .pipe(map((response) => {
+            const newBankTransactions = response.map((bankTransaction) => plainToClass(BankTransaction, bankTransaction));
+            // push new items to cache only if we already have cache. Otherwise cache will contain only new items.
+            if (this.cache) {
+                // just current year's transactions should be added
+                this.cache.push(...newBankTransactions.filter((bt) => new FinancialYear().includes(bt.date)));
+                this.updateCache();
+            }
+            return newBankTransactions;
+        }));
+    }
+    listenBankTransactionsImport() {
+        this.eventDispatcherService.on(AppEventTypeEnum.NOTIFICATION_ADDED).subscribe((notification) => {
+            if (!notification.isRead && notification.eventType === UserEventTypeClientTypeEnum.BASIQ_FIRST_IMPORT_COMPLETE) {
+                this.resetCache();
+            }
+        });
+    }
+}
+BankTransactionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankTransactionService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+BankTransactionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankTransactionService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankTransactionService, 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":"bank-transaction.service.js","sourceRoot":"","sources":["../../../../../../../../projects/tt-core/src/lib/services/http/bank/bank-transaction/bank-transaction.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { BankTransaction as BankTransactionBase } from '../../../../db/Models/bank-transaction';\nimport { Observable } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { RestService } from '../../rest/rest.service';\nimport { plainToClass } from 'class-transformer';\nimport { HttpClient } from '@angular/common/http';\nimport { UserEventTypeClientTypeEnum } from '../../../../db/Enums/user-event-type-client-type.enum';\nimport { BankTransaction } from '../../../../models/bank/bank-transaction';\nimport { EventDispatcherService } from '../../../event/event-dispatcher.service';\nimport { FinancialYear } from '../../../../models/financial-year/financial-year';\nimport { AppEventTypeEnum } from '../../../../models/event/app-event-type.enum';\nimport { Notification } from '../../../../models/notification/notification';\n\n/**\n * Service for bank transactions business logic\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class BankTransactionService extends RestService<BankTransactionBase, BankTransaction> {\n  // url part for BankTransaction API\n  url: string = 'bank-transactions';\n  modelClass = BankTransaction;\n\n  constructor(\n    protected http: HttpClient,\n    protected eventDispatcherService: EventDispatcherService,\n    @Inject('environment') protected environment: any\n  ) {\n    super(http, eventDispatcherService, environment);\n    this.listenEvents();\n  }\n\n  private listenEvents(): void {\n    this.listenBankTransactionsImport();\n  };\n\n  /**\n   * get list of bank transactions for passed bank account id\n   * @param bankAccountId Id of bank account we search bank transactions for\n   */\n  getByBankAccountId(bankAccountId: number): Observable<BankTransaction[]> {\n    return this.get()\n      .pipe(\n        map((bankTransactions: BankTransaction[]) => {\n          return bankTransactions.filter((bankTransaction: BankTransaction) => bankTransaction.bankAccount.id === bankAccountId);\n        })\n      );\n  }\n\n  /**\n   * Get list of bank transactions for provided financial year\n   * @TODO VIK/Alex: consider to use one endpoint to get bank transactions for 2 fin years\n   */\n  getTransactionsByYear(finYear: number): Observable<BankTransaction[]> {\n    return this.http.get(`${this.environment.apiV2}/bank-transactions?financialYear=${finYear}`)\n      .pipe(\n        map((bankTransactionsBase: BankTransactionBase[]) => {\n          return bankTransactionsBase.map((bankTransaction: BankTransaction) => plainToClass(BankTransaction, bankTransaction));\n        })\n      );\n  }\n\n  /**\n   * import bank transactions from csv file\n   * @param bankAccountId Bank account id we import bank transactions for\n   * @param file File with bank transactions for import\n   */\n  import(bankAccountId: number, file: File): Observable<BankTransaction[]> {\n    const formData: FormData = new FormData();\n    formData.append('file', file);\n\n    return this.http.post(`${this.environment.apiV2}/bank-accounts/${bankAccountId}/bank-transaction-imports`, formData)\n      .pipe(\n        map((response: BankTransactionBase[]) => {\n          const newBankTransactions: BankTransaction[] = response.map((bankTransaction: BankTransactionBase) => plainToClass(BankTransaction, bankTransaction));\n          // push new items to cache only if we already have cache. Otherwise cache will contain only new items.\n          if (this.cache) {\n            // just current year's transactions should be added\n            this.cache.push(...newBankTransactions.filter((bt: BankTransaction) => new FinancialYear().includes(bt.date)));\n            this.updateCache();\n          }\n\n          return newBankTransactions;\n        })\n      );\n  }\n\n  private listenBankTransactionsImport(): void {\n    this.eventDispatcherService.on(AppEventTypeEnum.NOTIFICATION_ADDED).subscribe((notification: Notification) => {\n      if (!notification.isRead && notification.eventType === UserEventTypeClientTypeEnum.BASIQ_FIRST_IMPORT_COMPLETE) {\n        this.resetCache();\n      }\n    });\n  }\n}\n"]}

package/esm2015/lib/services/http/bank/bank.service.js

@@ -0,0 +1,24 @@
+import { Injectable } from '@angular/core';
+import { Bank } from '../../../models/bank/bank';
+import { RestService } from '../rest/rest.service';
+import * as i0 from "@angular/core";
+/**
+ * Service that handling banks logic
+ */
+export class BankService extends RestService {
+    constructor() {
+        super(...arguments);
+        this.modelClass = Bank;
+        this.url = 'banks';
+        this.isHydra = true;
+    }
+}
+BankService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+BankService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BankService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFuay5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL3NlcnZpY2VzL2h0dHAvYmFuay9iYW5rLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUUzQyxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDakQsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLHNCQUFzQixDQUFDOztBQUVuRDs7R0FFRztBQUlILE1BQU0sT0FBTyxXQUFZLFNBQVEsV0FBMkI7SUFINUQ7O1FBSUUsZUFBVSxHQUFnQixJQUFJLENBQUM7UUFDL0IsUUFBRyxHQUFXLE9BQU8sQ0FBQztRQUN0QixZQUFPLEdBQVksSUFBSSxDQUFDO0tBQ3pCOzt5R0FKWSxXQUFXOzZHQUFYLFdBQVcsY0FGVixNQUFNOzRGQUVQLFdBQVc7a0JBSHZCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQmFuayBhcyBCYW5rQmFzZSB9IGZyb20gJy4uLy4uLy4uL2RiL01vZGVscy9iYW5rJztcbmltcG9ydCB7IEJhbmsgfSBmcm9tICcuLi8uLi8uLi9tb2RlbHMvYmFuay9iYW5rJztcbmltcG9ydCB7IFJlc3RTZXJ2aWNlIH0gZnJvbSAnLi4vcmVzdC9yZXN0LnNlcnZpY2UnO1xuXG4vKipcbiAqIFNlcnZpY2UgdGhhdCBoYW5kbGluZyBiYW5rcyBsb2dpY1xuICovXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290J1xufSlcbmV4cG9ydCBjbGFzcyBCYW5rU2VydmljZSBleHRlbmRzIFJlc3RTZXJ2aWNlPEJhbmtCYXNlLCBCYW5rPiB7XG4gIG1vZGVsQ2xhc3M6IHR5cGVvZiBCYW5rID0gQmFuaztcbiAgdXJsOiBzdHJpbmcgPSAnYmFua3MnO1xuICBpc0h5ZHJhOiBib29sZWFuID0gdHJ1ZTtcbn1cbiJdfQ==

package/esm2015/lib/services/http/bank/basiq/basiq.service.js

@@ -0,0 +1,94 @@
+import { Inject, Injectable } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { UserEventTypeClientTypeEnum } from '../../../../db/Enums/user-event-type-client-type.enum';
+import { RestService } from '../../rest/rest.service';
+import { BankAccount } from '../../../../models/bank/bank-account';
+import { BasiqToken } from '../../../../models/bank/basiq-token';
+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";
+/**
+ * basiq is a middleman between bank and user
+ * service is responsible for fetching bank related information
+ */
+export class BasiqService extends RestService {
+    constructor(http, eventDispatcherService, environment) {
+        super(http, eventDispatcherService, environment);
+        this.http = http;
+        this.eventDispatcherService = eventDispatcherService;
+        this.environment = environment;
+        this.tokenSubject = new ReplaySubject();
+        this.url = 'basiq/accounts';
+        this.modelClass = BankAccount;
+        this.listenEvents();
+    }
+    /**
+     * Listen events from Event Dispatcher service
+     */
+    listenEvents() {
+        this.listenToBankConnectionAdded();
+        this.listenNotifications();
+    }
+    /**
+     * access token to use basiq connect ui iframe
+     */
+    getToken() {
+        if (!this.token || this.token.isExpired()) {
+            this.http.get(`${this.environment.apiV2}/basiq/tokens`)
+                .pipe(map((response) => {
+                const now = new Date().getTime();
+                return new BasiqToken(response['access_token'], new Date(now + response['expires_in'] * 1000));
+            }))
+                .subscribe((token) => {
+                this.tokenSubject.next(token);
+            });
+        }
+        return this.tokenSubject.asObservable();
+    }
+    getConnections() {
+        return this.get().pipe(map((bankAccounts) => {
+            // get all connections
+            const connections = bankAccounts.map((bankAccount) => {
+                return bankAccount.bankConnection;
+            });
+            // return without duplicates
+            return [...new Map(connections.map((connection) => [connection.id, connection])).values()];
+        }));
+    }
+    /**
+     * Listen to EventDispatcherService event related to added Bank connection
+     */
+    listenToBankConnectionAdded() {
+        this.eventDispatcherService.on(AppEventTypeEnum.BANK_CONNECTION_ADDED).subscribe(() => {
+            this.fetch().subscribe((bankAccounts) => {
+                this.cache = bankAccounts;
+                this.updateCache();
+            });
+        });
+    }
+    /**
+     * listen to notifications to update basiq accounts list
+     */
+    listenNotifications() {
+        this.eventDispatcherService.on(AppEventTypeEnum.NOTIFICATION_ADDED).subscribe((notification) => {
+            if (!notification.isRead && notification.eventType === UserEventTypeClientTypeEnum.BASIQ_NEW_ACCOUNTS) {
+                this.resetCache();
+                this.get().subscribe();
+            }
+        });
+    }
+}
+BasiqService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BasiqService, deps: [{ token: i1.HttpClient }, { token: i2.EventDispatcherService }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+BasiqService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BasiqService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: BasiqService, 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":"basiq.service.js","sourceRoot":"","sources":["../../../../../../../../projects/tt-core/src/lib/services/http/bank/basiq/basiq.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 { BankAccount as BankAccountBase } from '../../../../db/Models/bank-account';\nimport { UserEventTypeClientTypeEnum } from '../../../../db/Enums/user-event-type-client-type.enum';\nimport { RestService } from '../../rest/rest.service';\nimport { BankAccount } from '../../../../models/bank/bank-account';\nimport { BasiqToken } from '../../../../models/bank/basiq-token';\nimport { EventDispatcherService } from '../../../event/event-dispatcher.service';\nimport { AppEventTypeEnum } from '../../../../models/event/app-event-type.enum';\nimport { BankConnection } from '../../../../models/bank/bank-connection';\nimport { Notification } from '../../../../models/notification/notification';\n\n/**\n * basiq is a middleman between bank and user\n * service is responsible for fetching bank related information\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class BasiqService extends RestService<BankAccountBase, BankAccount> {\n  token: BasiqToken;\n  tokenSubject: ReplaySubject<BasiqToken> = new ReplaySubject<BasiqToken>();\n  url: string = 'basiq/accounts';\n  modelClass = BankAccount;\n\n  constructor(\n    protected http: HttpClient,\n    protected eventDispatcherService: EventDispatcherService,\n    @Inject('environment') protected environment: any\n  ) {\n    super(http, eventDispatcherService, environment);\n    this.listenEvents();\n  }\n\n  /**\n   * Listen events from Event Dispatcher service\n   */\n  listenEvents(): void {\n    this.listenToBankConnectionAdded();\n    this.listenNotifications();\n  }\n\n  /**\n   * access token to use basiq connect ui iframe\n   */\n  getToken(): Observable<BasiqToken> {\n    if (!this.token || this.token.isExpired()) {\n      this.http.get(`${this.environment.apiV2}/basiq/tokens`)\n        .pipe(\n          map((response: object) => {\n            const now: number = new Date().getTime();\n\n            return new BasiqToken(response['access_token'], new Date(now + response['expires_in'] * 1000));\n          })\n        )\n        .subscribe((token: BasiqToken) => {\n          this.tokenSubject.next(token);\n        });\n    }\n\n    return this.tokenSubject.asObservable();\n  }\n\n  getConnections(): Observable<BankConnection[]> {\n    return this.get().pipe(\n      map((bankAccounts: BankAccount[]) => {\n        // get all connections\n        const connections: BankConnection[] = bankAccounts.map((bankAccount: BankAccount) => {\n          return bankAccount.bankConnection;\n        });\n\n        // return without duplicates\n        return [...new Map(connections.map((connection: BankConnection) => [connection.id, connection])).values()];\n      })\n    );\n  }\n\n  /**\n   * Listen to EventDispatcherService event related to added Bank connection\n   */\n  private listenToBankConnectionAdded(): void {\n    this.eventDispatcherService.on(AppEventTypeEnum.BANK_CONNECTION_ADDED).subscribe(() => {\n      this.fetch().subscribe((bankAccounts: BankAccount[]) => {\n        this.cache = bankAccounts;\n        this.updateCache();\n      });\n    });\n  }\n\n  /**\n   * listen to notifications to update basiq accounts list\n   */\n  private listenNotifications(): void {\n    this.eventDispatcherService.on(AppEventTypeEnum.NOTIFICATION_ADDED).subscribe((notification: Notification): void => {\n      if (!notification.isRead && notification.eventType === UserEventTypeClientTypeEnum.BASIQ_NEW_ACCOUNTS) {\n        this.resetCache();\n        this.get().subscribe();\n      }\n    });\n  }\n}\n"]}