taxtank-core 0.27.5 → 0.27.6

package/bundles/taxtank-core.umd.js

@@ -1059,6 +1059,10 @@
         SOLE_BUSINESSES_PUT: new Endpoint('PUT', '\\/sole-businesses\\/\\d+'),
         SOLE_DEPRECIATION_METHODS_GET: new Endpoint('GET', '\\/sole-depreciation-methods'),
         SOLE_DEPRECIATION_METHODS_PUT: new Endpoint('PUT', '\\/sole-depreciation-methods\\/\\d+'),
+        SOLE_INVOICES_GET: new Endpoint('GET', '\\/sole-invoices'),
+        SOLE_INVOICES_POST: new Endpoint('POST', '\\/sole-invoices'),
+        SOLE_INVOICES_PUT: new Endpoint('PUT', '\\/sole-invoices\\/\\d+'),
+        SOLE_INVOICES_DELETE: new Endpoint('DELETE', '\\/sole-invoices\\/\\d+'),
         SOLE_INVOICE_TEMPLATES_GET: new Endpoint('GET', '\\/sole-invoice-templates'),
         SOLE_INVOICE_TEMPLATES_POST: new Endpoint('POST', '\\/sole-invoice-templates'),
         SOLE_INVOICE_TEMPLATES_PUT: new Endpoint('PUT', '\\/sole-invoice-templates\\/\\d+'),
@@ -3126,8 +3130,17 @@
     var SoleInvoiceItem = /** @class */ (function (_super) {
         __extends(SoleInvoiceItem, _super);
         function SoleInvoiceItem() {
-            return _super !== null && _super.apply(this, arguments) || this;
+            var _this = _super.apply(this, __spreadArray([], __read(arguments))) || this;
+            _this.isGST = false;
+            return _this;
         }
+        Object.defineProperty(SoleInvoiceItem.prototype, "amount", {
+            get: function () {
+                return this.price * this.quantity;
+            },
+            enumerable: false,
+            configurable: true
+        });
         return SoleInvoiceItem;
     }(SoleInvoiceItem$1));
     __decorate([
@@ -3188,13 +3201,29 @@
         return SoleInvoiceTemplate;
     }(AbstractModel));
 
+    exports.SoleInvoiceTemplateTaxTypeEnum = void 0;
+    (function (SoleInvoiceTemplateTaxTypeEnum) {
+        SoleInvoiceTemplateTaxTypeEnum[SoleInvoiceTemplateTaxTypeEnum["EXCLUSIVE"] = 0] = "EXCLUSIVE";
+        SoleInvoiceTemplateTaxTypeEnum[SoleInvoiceTemplateTaxTypeEnum["INCLUSIVE"] = 1] = "INCLUSIVE";
+        SoleInvoiceTemplateTaxTypeEnum[SoleInvoiceTemplateTaxTypeEnum["NONE"] = 2] = "NONE";
+    })(exports.SoleInvoiceTemplateTaxTypeEnum || (exports.SoleInvoiceTemplateTaxTypeEnum = {}));
+
     var SoleInvoiceTemplate = /** @class */ (function (_super) {
         __extends(SoleInvoiceTemplate, _super);
         function SoleInvoiceTemplate() {
             var _this = _super.apply(this, __spreadArray([], __read(arguments))) || this;
-            _this.isTaxIncluded = false;
+            _this.taxType = exports.SoleInvoiceTemplateTaxTypeEnum.NONE;
             return _this;
         }
+        SoleInvoiceTemplate.prototype.isNoTax = function () {
+            return this.taxType === exports.SoleInvoiceTemplateTaxTypeEnum.NONE;
+        };
+        SoleInvoiceTemplate.prototype.isTaxExclusive = function () {
+            return this.taxType === exports.SoleInvoiceTemplateTaxTypeEnum.EXCLUSIVE;
+        };
+        SoleInvoiceTemplate.prototype.isTaxInclusive = function () {
+            return this.taxType === exports.SoleInvoiceTemplateTaxTypeEnum.INCLUSIVE;
+        };
         return SoleInvoiceTemplate;
     }(SoleInvoiceTemplate$1));
     __decorate([
@@ -3204,11 +3233,105 @@
         classTransformer.Type(function () { return BankAccount; })
     ], SoleInvoiceTemplate.prototype, "bankAccount", void 0);
 
+    exports.SoleInvoiceStatusesEnum = void 0;
+    (function (SoleInvoiceStatusesEnum) {
+        SoleInvoiceStatusesEnum[SoleInvoiceStatusesEnum["CANCELED"] = 0] = "CANCELED";
+        SoleInvoiceStatusesEnum[SoleInvoiceStatusesEnum["DRAFT"] = 1] = "DRAFT";
+        SoleInvoiceStatusesEnum[SoleInvoiceStatusesEnum["PENDING"] = 2] = "PENDING";
+        SoleInvoiceStatusesEnum[SoleInvoiceStatusesEnum["PAID"] = 3] = "PAID";
+    })(exports.SoleInvoiceStatusesEnum || (exports.SoleInvoiceStatusesEnum = {}));
+
+    var SoleDetails$1 = /** @class */ (function (_super) {
+        __extends(SoleDetails, _super);
+        function SoleDetails() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        return SoleDetails;
+    }(AbstractModel));
+
+    var SoleDetails = /** @class */ (function (_super) {
+        __extends(SoleDetails, _super);
+        function SoleDetails() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        return SoleDetails;
+    }(SoleDetails$1));
+    SoleDetails.GSTPercentMultiplier = 0.1;
+    SoleDetails.GSTPercentDivider = 11;
+    __decorate([
+        classTransformer.Type(function () { return User; })
+    ], SoleDetails.prototype, "user", void 0);
+
     var SoleInvoice = /** @class */ (function (_super) {
         __extends(SoleInvoice, _super);
         function SoleInvoice() {
-            return _super !== null && _super.apply(this, arguments) || this;
+            var _this = _super.apply(this, __spreadArray([], __read(arguments))) || this;
+            _this.items = [classTransformer.plainToClass(SoleInvoiceItem, {})];
+            _this.status = exports.SoleInvoiceStatusesEnum.DRAFT;
+            return _this;
         }
+        Object.defineProperty(SoleInvoice.prototype, "amount", {
+            get: function () {
+                return this.items.reduce(function (sum, item) { return sum + item.amount; }, 0);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        SoleInvoice.prototype.getGSTItems = function () {
+            return this.items.filter(function (item) { return item.isGST; });
+        };
+        SoleInvoice.prototype.getGSTItemsAmount = function () {
+            return this.getGSTItems().reduce(function (sum, item) { return sum + item.amount; }, 0);
+        };
+        Object.defineProperty(SoleInvoice.prototype, "subtotal", {
+            get: function () {
+                var _a;
+                if ((_a = this.template) === null || _a === void 0 ? void 0 : _a.isTaxInclusive()) {
+                    return this.amount - this.GSTAmount;
+                }
+                return this.amount;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(SoleInvoice.prototype, "GSTAmount", {
+            get: function () {
+                var _a, _b;
+                switch (true) {
+                    case (_a = this.template) === null || _a === void 0 ? void 0 : _a.isTaxInclusive():
+                        return +(this.getGSTItemsAmount() / SoleDetails.GSTPercentDivider).toFixed(2);
+                    case (_b = this.template) === null || _b === void 0 ? void 0 : _b.isTaxExclusive():
+                        return +(this.getGSTItemsAmount() * SoleDetails.GSTPercentMultiplier).toFixed(2);
+                    default:
+                        return 0;
+                }
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(SoleInvoice.prototype, "total", {
+            get: function () {
+                var _a;
+                if ((_a = this.template) === null || _a === void 0 ? void 0 : _a.isTaxExclusive()) {
+                    return this.amount + this.GSTAmount;
+                }
+                return this.amount;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        SoleInvoice.prototype.isDraft = function () {
+            return this.status === exports.SoleInvoiceStatusesEnum.DRAFT;
+        };
+        SoleInvoice.prototype.isCancelled = function () {
+            return this.status === exports.SoleInvoiceStatusesEnum.CANCELED;
+        };
+        SoleInvoice.prototype.isPending = function () {
+            return this.status === exports.SoleInvoiceStatusesEnum.PENDING;
+        };
+        SoleInvoice.prototype.isPaid = function () {
+            return this.status === exports.SoleInvoiceStatusesEnum.PAID;
+        };
         return SoleInvoice;
     }(SoleInvoice$1));
     __decorate([
@@ -4584,25 +4707,6 @@
         return SoleDepreciationMethod;
     }(SoleDepreciationMethod$1));
 
-    var SoleDetails$1 = /** @class */ (function (_super) {
-        __extends(SoleDetails, _super);
-        function SoleDetails() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        return SoleDetails;
-    }(AbstractModel));
-
-    var SoleDetails = /** @class */ (function (_super) {
-        __extends(SoleDetails, _super);
-        function SoleDetails() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        return SoleDetails;
-    }(SoleDetails$1));
-    __decorate([
-        classTransformer.Type(function () { return User; })
-    ], SoleDetails.prototype, "user", void 0);
-
     var User = /** @class */ (function (_super) {
         __extends(User, _super);
         function User() {
@@ -11171,6 +11275,26 @@
                         }] }];
         } });
 
+    var SoleInvoiceService = /** @class */ (function (_super) {
+        __extends(SoleInvoiceService, _super);
+        function SoleInvoiceService() {
+            var _this = _super.apply(this, __spreadArray([], __read(arguments))) || this;
+            _this.modelClass = SoleInvoice;
+            _this.url = 'sole-invoices';
+            _this.isHydra = true;
+            return _this;
+        }
+        return SoleInvoiceService;
+    }(RestService));
+    SoleInvoiceService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: SoleInvoiceService, deps: null, target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    SoleInvoiceService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: SoleInvoiceService, providedIn: 'root' });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0__namespace, type: SoleInvoiceService, decorators: [{
+                type: i0.Injectable,
+                args: [{
+                        providedIn: 'root'
+                    }]
+            }] });
+
     var SoleInvoiceTemplateService = /** @class */ (function (_super) {
         __extends(SoleInvoiceTemplateService, _super);
         function SoleInvoiceTemplateService() {
@@ -16926,15 +17050,119 @@
         return SoleDetailsForm;
     }(AbstractForm));
 
+    var SoleInvoiceItemForm = /** @class */ (function (_super) {
+        __extends(SoleInvoiceItemForm, _super);
+        function SoleInvoiceItemForm(item) {
+            var _this = this;
+            var _a;
+            _this = _super.call(this, {
+                description: new forms.FormControl(item.description, forms.Validators.required),
+                quantity: new forms.FormControl(item.quantity, forms.Validators.required),
+                price: new forms.FormControl(item.price, forms.Validators.required),
+                isGST: new forms.FormControl({ value: item.isGST, disabled: !((_a = item.chartAccounts) === null || _a === void 0 ? void 0 : _a.isGST) }),
+                chartAccounts: new forms.FormControl(item.chartAccounts, forms.Validators.required)
+            }, item) || this;
+            _this.listenEvents();
+            return _this;
+        }
+        SoleInvoiceItemForm.prototype.listenEvents = function () {
+            this.listenChartAccountsChanges();
+        };
+        SoleInvoiceItemForm.prototype.onTemplateChanged = function (template) {
+            this.template = template;
+            if (this.template.isNoTax()) {
+                this.get('isGST').setValue(false);
+                this.get('isGST').disable();
+            }
+            else {
+                this.get('isGST').enable();
+            }
+        };
+        SoleInvoiceItemForm.prototype.listenChartAccountsChanges = function () {
+            var _this = this;
+            this.get('chartAccounts').valueChanges.subscribe(function (chartAccounts) {
+                if (_this.template.isNoTax()) {
+                    return;
+                }
+                if (chartAccounts.isGST) {
+                    _this.get('isGST').enable();
+                }
+                else {
+                    _this.get('isGST').setValue(false);
+                    _this.get('isGST').disable();
+                }
+            });
+        };
+        return SoleInvoiceItemForm;
+    }(AbstractForm));
+
+    var SoleInvoiceForm = /** @class */ (function (_super) {
+        __extends(SoleInvoiceForm, _super);
+        function SoleInvoiceForm(invoice) {
+            var _this = _super.call(this, {
+                dateFrom: new forms.FormControl(invoice.dateFrom, forms.Validators.required),
+                dateTo: new forms.FormControl(invoice.dateTo, forms.Validators.required),
+                items: new forms.FormArray(invoice.items.map(function (item) { return new SoleInvoiceItemForm(item); })),
+                payer: new forms.FormControl(invoice.payer, forms.Validators.required),
+                template: new forms.FormControl(invoice.template, forms.Validators.required)
+            }, invoice) || this;
+            if (invoice.id) {
+                _this.updateItemsForm(invoice.template);
+            }
+            _this.listenEvents();
+            return _this;
+        }
+        Object.defineProperty(SoleInvoiceForm.prototype, "items", {
+            get: function () {
+                return this.get('items');
+            },
+            enumerable: false,
+            configurable: true
+        });
+        SoleInvoiceForm.prototype.listenEvents = function () {
+            this.listenTemplateChanges();
+        };
+        SoleInvoiceForm.prototype.addItem = function () {
+            this.items.push(new SoleInvoiceItemForm(classTransformer.plainToClass(SoleInvoiceItem, {})));
+        };
+        SoleInvoiceForm.prototype.removeItem = function (index) {
+            // do not remove the last item
+            if (this.items.length === 1) {
+                return;
+            }
+            this.items.removeAt(index);
+        };
+        SoleInvoiceForm.prototype.submit = function (data) {
+            if (data === void 0) { data = {}; }
+            var items = this.items.controls.map(function (control) { return control.submit(); });
+            return _super.prototype.submit.call(this, Object.assign({}, data, { items: items }));
+        };
+        SoleInvoiceForm.prototype.listenTemplateChanges = function () {
+            var _this = this;
+            this.get('template').valueChanges.subscribe(function (template) {
+                _this.updateItemsForm(template);
+            });
+        };
+        SoleInvoiceForm.prototype.updateItemsForm = function (template) {
+            this.items.controls.forEach(function (itemForm) {
+                itemForm.onTemplateChanged(template);
+            });
+        };
+        return SoleInvoiceForm;
+    }(AbstractForm));
+
     var SoleInvoiceTemplateForm = /** @class */ (function (_super) {
         __extends(SoleInvoiceTemplateForm, _super);
-        function SoleInvoiceTemplateForm(invoiceTemplate) {
-            return _super.call(this, {
+        function SoleInvoiceTemplateForm(invoiceTemplate, soleDetails) {
+            var _this = _super.call(this, {
                 name: new forms.FormControl(invoiceTemplate.name, forms.Validators.required),
-                isTaxIncluded: new forms.FormControl(invoiceTemplate.isTaxIncluded),
+                // taxType always 'No Tax' when sole details are not GST registered
+                taxType: new forms.FormControl({ value: invoiceTemplate.taxType, disabled: !soleDetails.isGST }, forms.Validators.required),
                 term: new forms.FormControl(invoiceTemplate.term, [forms.Validators.required, forms.Validators.min(0)]),
                 bankAccount: new forms.FormControl(invoiceTemplate.bankAccount, [forms.Validators.required])
             }, invoiceTemplate) || this;
+            _this.soleDetails = soleDetails;
+            return _this;
         }
         return SoleInvoiceTemplateForm;
     }(AbstractForm));
@@ -17006,17 +17234,13 @@
         function BankAccountAddManualForm(connection) {
             var _this = _super.call(this) || this;
             _this.connection = connection;
-            _this
-                .addControl('type', new forms.FormControl(null, forms.Validators.required))
-                .addControl('accountName', new forms.FormControl(null, forms.Validators.required))
-                .addControl('currentBalance', new forms.FormControl(null, forms.Validators.required))
-                .addControl('accountNumber', new forms.FormControl(null, [forms.Validators.required, forms.Validators.pattern(BankAccountAddManualForm.accountNumberPattern)]));
-            _this.listenEvents();
+            _this.addControl('type', new forms.FormControl(null, forms.Validators.required));
+            _this.addControl('accountName', new forms.FormControl(null, forms.Validators.required));
+            _this.addControl('currentBalance', new forms.FormControl(null, forms.Validators.required));
+            _this.addControl('accountNumber', new forms.FormControl(null, [forms.Validators.required, forms.Validators.pattern(BankAccountAddManualForm.accountNumberPattern)]));
+            _this.listenTypeChanges();
             return _this;
         }
-        BankAccountAddManualForm.prototype.listenEvents = function () {
-            this.listenTypeChanges();
-        };
         /**
          * Add/Remove loan form depends on selected bank account type
          */
@@ -18054,7 +18278,10 @@
     exports.SoleForecast = SoleForecast;
     exports.SoleForecastService = SoleForecastService;
     exports.SoleInvoice = SoleInvoice;
+    exports.SoleInvoiceForm = SoleInvoiceForm;
     exports.SoleInvoiceItem = SoleInvoiceItem;
+    exports.SoleInvoiceItemForm = SoleInvoiceItemForm;
+    exports.SoleInvoiceService = SoleInvoiceService;
     exports.SoleInvoiceTemplate = SoleInvoiceTemplate;
     exports.SoleInvoiceTemplateForm = SoleInvoiceTemplateForm;
     exports.SoleInvoiceTemplateService = SoleInvoiceTemplateService;