taxtank-core 0.28.70 → 0.28.73

package/bundles/taxtank-core.umd.js

@@ -3179,6 +3179,10 @@
         classTransformer.Type(function () { return SoleBusinessLossOffsetRule; })
     ], SoleBusinessLossOffsetRule.prototype, "parent", void 0);
 
+    /**
+     * If a sole trader business makes a tax loss in a current year, you can generally carry forward that loss and offset profit in future years.
+     * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/4641357930/Rules+when+a+business+makes+a+loss+Tax+Summary#Offsetting-current-year-business-losses
+     */
     var SoleBusinessLoss = /** @class */ (function (_super) {
         __extends(SoleBusinessLoss, _super);
         function SoleBusinessLoss() {
@@ -5456,6 +5460,48 @@
             enumerable: false,
             configurable: true
         });
+        Object.defineProperty(BasReport.prototype, "paygTaxInstalmentOwedToATO", {
+            get: function () {
+                return this.paygTaxInstalment > 0 ? this.paygTaxInstalment : 0;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(BasReport.prototype, "paygTaxInstalmentOwedByATO", {
+            get: function () {
+                return this.paygTaxInstalment < 0 ? Math.abs(this.paygTaxInstalment) : 0;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(BasReport.prototype, "fuelTaxCreditOwedToATO", {
+            get: function () {
+                return this.fuelTaxCredit < 0 ? this.fuelTaxCredit : 0;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(BasReport.prototype, "fuelTaxCreditOwedByATO", {
+            get: function () {
+                return this.fuelTaxCredit > 0 ? Math.abs(this.fuelTaxCredit) : 0;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(BasReport.prototype, "owesToATO", {
+            get: function () {
+                return this.incomeGST + this.taxWithheldTotal + this.paygTaxInstalmentOwedToATO + this.fuelTaxCreditOwedToATO;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(BasReport.prototype, "owedByATO", {
+            get: function () {
+                return this.expenseGST + this.paygTaxInstalmentOwedByATO + this.fuelTaxCreditOwedByATO;
+            },
+            enumerable: false,
+            configurable: true
+        });
         Object.defineProperty(BasReport.prototype, "gst", {
             /**
              * GST payable to the ATO, or refundable from the ATO in case it's negative
@@ -7591,27 +7637,42 @@
             return _super !== null && _super.apply(this, arguments) || this;
         }
         /**
-         * Calculate business losses applied to the current year
+         * Business loss applied in current year, includes previous year losses and current year losses for businesses matching offset rule
          */
         SoleBusinessLossesCollection.prototype.calculateBusinessLossApplied = function (transactions) {
             var _this = this;
-            var transactionsByBusinessIds = new CollectionDictionary(transactions, 'business.id');
-            // Dictionary with pairs key = business id, value = business claim amount
+            // claim amounts for businesses that can be applied to be reduced by prior year business losses
+            var claimAmountsByBusinessId = this.getClaimAmountsByBusinessId(transactions);
+            return Object.keys(claimAmountsByBusinessId.items).reduce(function (sum, businessId) {
+                var loss = _this.findBy('business.id', +businessId);
+                var lossOpenBalance = (loss === null || loss === void 0 ? void 0 : loss.openBalance) || 0;
+                // business loss can be applied to business profit or other income types profit in case in offset rule met
+                return sum + (loss.offsetRule ? lossOpenBalance : Math.min(lossOpenBalance, claimAmountsByBusinessId.get(businessId)));
+            }, 0);
+        };
+        /**
+         * Get business claim amounts that can be applied to be reduced by prior year business losses:
+         * businesses with income or businesses with a loss, but which met the non-commercial loss rules
+         * https://www.ato.gov.au/Business/Non-commercial-losses/
+         */
+        SoleBusinessLossesCollection.prototype.getClaimAmountsByBusinessId = function (transactions) {
+            var _this = this;
             var claimAmountsByBusinessId = new Dictionary([]);
-            transactionsByBusinessIds.keys.forEach(function (businessId) {
-                var businessClaimAmount = transactionsByBusinessIds
+            var transactionsByBusinessId = new CollectionDictionary(transactions, 'business.id');
+            transactionsByBusinessId.keys.forEach(function (businessId) {
+                var _a;
+                // business loss may not exist if, when creating a business, user didn't add losses for previous years
+                var lossOffsetRule = (_a = _this.findBy('business.id', +businessId)) === null || _a === void 0 ? void 0 : _a.offsetRule;
+                var businessClaimAmount = transactionsByBusinessId
                     .get(businessId)
                     .getClaimAmountByBusinessId(+businessId);
-                // only businesses with positive income are included in the calculation
-                if (businessClaimAmount > 0) {
-                    claimAmountsByBusinessId.add(businessId, businessClaimAmount);
+                // no way to apply loss for business without profit if offset rules not met
+                if (businessClaimAmount < 0 && !lossOffsetRule) {
+                    return;
                 }
+                claimAmountsByBusinessId.add(businessId, businessClaimAmount);
             });
-            return Object.keys(claimAmountsByBusinessId.items).reduce(function (sum, businessId) {
-                var _a;
-                var lossOpenBalance = ((_a = _this.findBy('business.id', +businessId)) === null || _a === void 0 ? void 0 : _a.openBalance) || 0;
-                return sum + Math.min(lossOpenBalance, claimAmountsByBusinessId.get(businessId));
-            }, 0);
+            return claimAmountsByBusinessId;
         };
         return SoleBusinessLossesCollection;
     }(Collection));
@@ -12916,6 +12977,16 @@
         SoleInvoiceService.prototype.sendEmail = function (invoice) {
             return this.http.post(this.environment.apiV2 + "/" + this.url + "/" + invoice.id + "/send", {});
         };
+        /**
+         * Return the next number from the last invoice.
+         * Basically needed to create a new invoice to show its number when the invoice has not yet been sent to the backend
+         */
+        SoleInvoiceService.prototype.getNewInvoiceNumber = function () {
+            if (!this.cache) {
+                return 0;
+            }
+            return last__default["default"](this.cache).number + 1;
+        };
         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 });
@@ -18978,32 +19049,38 @@
         return SoleInvoiceItemForm;
     }(AbstractForm));
 
+    /**
+     * Form is divided into two groups, since the creation of Sole invoice takes place in two steps:
+     * a common invoice data and sole invoice items.
+     */
     var SoleInvoiceForm = /** @class */ (function (_super) {
         __extends(SoleInvoiceForm, _super);
         function SoleInvoiceForm(invoice, soleDetailsGST, 
         // default template to be preselected
         defaultTemplate) {
             var _this = _super.call(this, {
-                dateFrom: new forms.FormControl(invoice.dateFrom || new Date(), forms.Validators.required),
-                dateTo: new forms.FormControl(invoice.dateTo, forms.Validators.required),
+                commonData: new forms.FormGroup({
+                    dateFrom: new forms.FormControl(invoice.dateFrom || new Date(), forms.Validators.required),
+                    dateTo: new forms.FormControl(invoice.dateTo, forms.Validators.required),
+                    payer: new forms.FormControl(invoice.payer, forms.Validators.required),
+                    taxType: new forms.FormControl(invoice.taxType, forms.Validators.required),
+                    bankAccount: new forms.FormControl(invoice.bankAccount, forms.Validators.required),
+                    reference: new forms.FormControl(invoice.reference)
+                }),
                 items: new forms.FormArray((invoice.items || [classTransformer.plainToClass(SoleInvoiceItem, {})]).map(function (item) { return new SoleInvoiceItemForm(item); })),
-                payer: new forms.FormControl(invoice.payer, forms.Validators.required),
-                taxType: new forms.FormControl(invoice.taxType, forms.Validators.required),
-                bankAccount: new forms.FormControl(invoice.bankAccount, forms.Validators.required),
-                reference: new forms.FormControl(invoice.reference)
             }, invoice) || this;
             _this.invoice = invoice;
             _this.soleDetailsGST = soleDetailsGST;
             _this.defaultTemplate = defaultTemplate;
             // we need invoice template only for new invoices
             if (!invoice.id) {
-                _this.addControl('template', new forms.FormControl(_this.defaultTemplate));
+                (_this.commonData).addControl('template', new forms.FormControl(_this.defaultTemplate));
                 _this.updateTemplateRelatedFields(_this.defaultTemplate);
             }
             // invoice.taxType is always NONE ('No Tax') when soleDetails.isGST === false
             if (!_this.soleDetailsGST) {
-                _this.get('taxType').setValue(exports.SoleInvoiceTaxTypeEnum.NO_TAX);
-                _this.get('taxType').disable();
+                _this.commonData.get('taxType').setValue(exports.SoleInvoiceTaxTypeEnum.NO_TAX);
+                _this.commonData.get('taxType').disable();
                 // Items isGST is not available when invoice.taxType === NONE ('No Tax')
                 _this.items.controls.forEach(function (itemForm) {
                     _this.disableItemGST(itemForm);
@@ -19029,8 +19106,8 @@
                     _this.listenItemChartAccountsChanges(itemForm);
                 });
             }
-            // nothing to listen if template field is not учшые (edit invoice case)
-            if (this.contains('template')) {
+            // nothing to listen if template field is not exist (edit invoice case)
+            if ((this.commonData).contains('template')) {
                 this.listenTemplateChanges();
             }
         };
@@ -19048,16 +19125,21 @@
         };
         SoleInvoiceForm.prototype.submit = function (data) {
             if (data === void 0) { data = {}; }
-            // @TODO Alex TT-2190: move child custom forms submit to Abstract Form
-            var items = this.items.controls.map(function (control) { return control.submit(); });
-            return _super.prototype.submit.call(this, merge__default["default"](data, { items: items }));
+            this.submitted = true;
+            this.markAllAsTouched();
+            if (!this.disabled && !this.valid) {
+                return null;
+            }
+            var invoiceInstance = this.currentValue;
+            this.onSubmit.emit(invoiceInstance);
+            return invoiceInstance;
         };
         /**
          * Update default values from selected invoice template
          */
         SoleInvoiceForm.prototype.listenTemplateChanges = function () {
             var _this = this;
-            this.get('template').valueChanges.subscribe(function (template) {
+            this.commonData.get('template').valueChanges.subscribe(function (template) {
                 _this.updateTemplateRelatedFields(template);
             });
         };
@@ -19066,7 +19148,7 @@
          */
         SoleInvoiceForm.prototype.listenTaxTypeChanges = function () {
             var _this = this;
-            this.get('taxType').valueChanges.subscribe(function (type) {
+            this.commonData.get('taxType').valueChanges.subscribe(function (type) {
                 _this.items.controls.forEach(function (itemForm) {
                     var chartAccounts = itemForm.get('chartAccounts').value;
                     // Item GST is available when invoice.taxType !== NONE ('No Tax')
@@ -19079,18 +19161,18 @@
             });
         };
         SoleInvoiceForm.prototype.updateTemplateRelatedFields = function (template) {
-            this.get('bankAccount').setValue(template.bankAccount);
-            var dateFrom = this.get('dateFrom').value;
+            this.commonData.get('bankAccount').setValue(template.bankAccount);
+            var dateFrom = this.commonData.get('dateFrom').value;
             if (dateFrom) {
-                this.get('dateTo').setValue(new Date(dateFrom.getTime() + template.termTime));
+                this.commonData.get('dateTo').setValue(new Date(dateFrom.getTime() + template.termTime));
             }
             // invoice.taxType is always 'No Tax' when soleDetails.isGST = false and not available for changing
             if (this.soleDetailsGST) {
-                this.get('taxType').setValue(template.taxType);
+                this.commonData.get('taxType').setValue(template.taxType);
             }
         };
         /**
-         * GST availability depends of chart accounts isGST flag
+         * GST availability depends on chart accounts isGST flag
          */
         SoleInvoiceForm.prototype.listenItemChartAccountsChanges = function (itemForm) {
             var _this = this;
@@ -19115,6 +19197,24 @@
             itemForm.get('isGST').setValue(true);
             itemForm.get('isGST').enable();
         };
+        Object.defineProperty(SoleInvoiceForm.prototype, "commonData", {
+            get: function () {
+                return this.get('commonData');
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(SoleInvoiceForm.prototype, "currentValue", {
+            /**
+             * Rewrite abstract form getter to flat "commonData" field, which is not in the class
+             */
+            get: function () {
+                var formRawValue = this.getRawValue();
+                return classTransformer.plainToClass(SoleInvoice, Object.assign({}, this.model, Object.assign(Object.assign({}, formRawValue.commonData), { items: formRawValue.items })));
+            },
+            enumerable: false,
+            configurable: true
+        });
         return SoleInvoiceForm;
     }(AbstractForm));