shareneus 1.7.4 → 1.7.6

package/src/tasks/tasks/task-pdf.service.ts

@@ -0,0 +1,238 @@
+import { SharedPDFService } from '../../shared/shared-pdf.service';
+import { PrintSharedService } from '../../shared/shared-print.service';
+import { MyDate } from '../../utils/my-date';
+import { TrUtils } from '../../utils/tr-utils';
+
+declare var pdfMake: any;
+
+export class TaskPDfService {
+
+    static BodySize: number = 8;
+
+    static GetPdfForUnAssignedTasks(TaskData: any, Image: any, EntityData: any) {
+        let Images: any;
+        // let IsThere: boolean = false;
+        // Images = this.imageExists(meetingData.image);
+        // console.log(Images);
+        // TaskData.image = 'assets/images/1013/logo.jpg';
+        SharedPDFService.convertImgToBase64URL(Image, function (base64Img: any) {
+            Images = base64Img.toString();
+        }, function (ntg: any) {
+            Images = null;
+        });
+
+        SharedPDFService.convertImgToBase64URL(Image, function (base64Img: any) {
+        }, function (ntg: any) {
+        });
+        setTimeout(() => {
+            var dd: any = {
+                info: {
+                    title: 'Tasks',
+                },
+                header: function (currentPage: any, pageCount: any) {
+                    return { text: currentPage.toString() + ' of ' + pageCount, alignment: 'right', marginRight: 7, fontSize: 8, marginTop: 2 };
+                },
+                pageMargins: [20, 20, 20, 15],
+                content: [
+                    this.HeaderContent(Images, TaskData),
+                    this.HeaderAfterLine(),
+                    this.GetTaskSubHeadre(TaskData),
+                    // this.HeaderAfterLine(),
+                    this.GetTaskDetails(TaskData, EntityData.User.TZ),
+                ],
+                styles: SharedPDFService.GetStyles(),
+            };
+            pdfMake.createPdf(dd).open();
+        }, 400)
+    }
+
+    static GetHeader(task: any) {
+        return {
+            stack: [{ text: '[' + task.Code + ']' + '  ' + task.Name, alignment: 'center', bold: true, fontSize: 13, marginBottom: 5 },
+                // { text: task.Name, alignment: 'left', fontSize: 13, bold: true },
+                // { text: this.GetDescription(task), alignment: 'left', fontSize: 10, marginTop: 10 },
+                // { text: 'Details', alignment: 'left', fontSize: 10, bold: true, marginTop: 7 },
+            ]
+        };
+    }
+
+    static GetTaskSubHeadre(task: any) {
+        return {
+            stack: [
+                { text: this.GetDescription(task), alignment: 'left', fontSize: 10, marginTop: 10 },
+                { text: 'Details', alignment: 'left', fontSize: 10, bold: true, marginTop: 7 },
+            ]
+        };
+    }
+
+    static HeaderContent(Images: any, TaskData: any) {
+        if (TrUtils.IsNull(Images)) {
+            return { columns: [this.GetHeader(TaskData)], width: '*', marginBottom: 5 };
+        } else {
+            return {
+                columns: [{ image: Images, width: 40 * 1 },
+                // { text: 'Task Details', alignment: 'center', bold: true, fontSize: 16, marginRight: 15 }
+                this.GetHeader(TaskData),
+
+                ], marginBottom: 3
+            }
+        }
+    }
+
+    static GetDescription(task: any) {
+        if (!TrUtils.IsNull(task.Desc)) {
+            // var plainText = HtmlUtilities.ConvertToPlainText(task.Desc);
+            let plainText = this.stripHtml(task.Desc);
+            return plainText;
+        } else {
+            return 'No Description'
+        }
+    }
+
+    static stripHtml(html: any) {
+        // Create a new div element
+        var temporalDivElement = document.createElement("div");
+        // Set the HTML content with the providen
+        temporalDivElement.innerHTML = html;
+        // Retrieve the text property of the element (cross-browser support)
+        return temporalDivElement.textContent || temporalDivElement.innerText || "";
+    }
+
+    static GetTaskDetails(TaskData: any, UserTimeZone: any) {
+        return {
+            stack: [
+                this.GetTableHeadersForApproval(TaskData, UserTimeZone),
+            ]
+        };
+    }
+
+    static GetTableHeadersForApproval(TaskData: any, UserTimeZone: any) {
+        let headersNames: any =
+            [
+                { name: 'Status', value: this.GetValue(TaskData.Sts) },
+                { name: 'Start date', value: this.GetValue(MyDate.ConvertUTCDateToReadable(TaskData.EstStDt)) },
+                { name: 'Due date', value: this.GetValue(MyDate.ConvertUTCDateToReadable(TaskData.EstEnDt)) },
+                { name: 'Estimated Time', value: this.GetTime(TaskData.EstEnDt,UserTimeZone) },
+                { name: 'Priority', value: this.GetPriority(TaskData.Prty) },
+                { name: 'Progress', value: this.GetProgress(TaskData.CoPerc) },
+                { name: 'Assingned To', value: this.GetValue(this.GetAssinessList(TaskData.Members)) },
+                { name: 'Assingned by', value: this.GetValue(this.GetOwner(TaskData.Members)) },
+            ];
+
+        return this.GetDetails(headersNames);
+    }
+
+    static GetValue(value: any) {
+        if (!TrUtils.IsEmpty(value)) {
+            return value;
+        } else {
+            return 'Not specified';
+        }
+    }
+
+    static GetProgress(value: any) {
+        if (!TrUtils.IsEmpty(value)) {
+            return value + '%';
+        } else {
+            return '0' + '%';
+        }
+    }
+
+    static GetPriority(value: any) {
+        if (!TrUtils.IsEmpty(value)) {
+            return value;
+        } else {
+            return 'None';
+        }
+    }
+
+    static GetTime(date: any, UserTimeZone: any) {
+        if (!TrUtils.IsNull(date)) {
+            let time = MyDate.ConvertUTCDateTimeToReadable(date, UserTimeZone);
+            return time;
+        } else {
+            return 'Not specified';
+        }
+
+    }
+
+    static GetAssinessList(Members: any) {
+        let Assignees: any = '';
+        let membersData: any = Members.filter((member: any) => {
+            return !TrUtils.IsNull(member.Ass) && TrUtils.IsNull(member.EnDt);
+        });
+        membersData.forEach((member: any, index: any) => {
+            if (member.Role === 'Assignee') {
+                let comma: string = ' , ';
+                if (membersData.length === index + 1) {
+                    comma = ' ';
+                }
+                let date = MyDate.ConvertUTCDateToReadable(member.Ass);
+                Assignees = Assignees + member.Name + ' (' + date + ')' + comma;
+            }
+        });
+        return Assignees;
+    }
+
+    static GetOwner(Members: any) {
+        let Owner: any = '';
+        Members.forEach((member: any) => {
+            if (member.Role === 'Owner') {
+                Owner = member.Name
+            }
+        });
+        return Owner;
+    }
+
+    static GetDetails(data: any) {
+        return {
+            style: 'tableExample',
+            fontSize: this.BodySize,
+            lineHeight: 1,
+            marginTop: 5,
+            table: {
+                widths: [150, '*'],
+                body: this.GetDetailsTable(data)
+            },
+            layout: PrintSharedService.LayOutStyle()
+        };
+    }
+
+    static GetDetailsTable(data: any) {
+        var body: any = [];
+        data.forEach((row: any) => {
+            if (!TrUtils.IsEmpty(row.value)) {
+                var dataRow: any = [];
+                dataRow.push({ text: (row.name).toString(), noWrap: true, bold: true, fontSize: 10, margin: 5, fillColor: '#FAF9F8' });
+                dataRow.push({ text: (row.value).toString(), lineHeight: 1, fontSize: 10, margin: 5 });
+                body.push(dataRow);
+            }
+        });
+        return body;
+    }
+
+    static HeaderAfterLine() {
+        return {
+            canvas: [
+                {
+                    type: 'line',
+                    lineColor: 'black',
+                    x1: 0,
+                    y1: 0,
+                    x2: 555,
+                    y2: 0,
+                    lineWidth: 1.5
+                }
+            ]
+        };
+    }
+
+    static uniqueBy(a: any, key: any) {
+        var seen: any = {};
+        return a.filter(function (item: any) {
+            var k = key(item);
+            return seen.hasOwnProperty(k) ? false : (seen[k] = true);
+        });
+    }
+    
+}

package/src/tasks/tasks/task-reports-pdf.service.ts

@@ -0,0 +1,313 @@
+import { SharedPDFService } from '../../shared/shared-pdf.service';
+import { PrintSharedService } from '../../shared/shared-print.service';
+import { MyDate } from '../../utils/my-date';
+import { TrUtils } from '../../utils/tr-utils';
+
+class Group {
+    level: number = 0;
+    parent: any;
+    expanded: boolean = true;
+    Assignee: string = '';
+    get visible(): boolean {
+        return !this.parent || (this.parent.visible && this.parent.expanded);
+    }
+}
+
+declare var pdfMake: any;
+
+export class TaskReportsPDfService {
+
+    static overdueTasks: any[] = [];
+
+    static groupByColumns: string[] = ['UserId'];
+
+    static GetPdfForUnAssignedTasks(TaskData: any, IsLandScape: any, ReportType: any, Image: any, EntityData: any) {
+        let Images: any;
+        SharedPDFService.convertImgToBase64URL(Image, function (base64Img: any) {
+            Images = base64Img.toString();
+        }, function (ntg: any) {
+            Images = null;
+        });
+        setTimeout(() => {
+            var dd: any = {
+                // header: function () {
+                //     return { text: ReportType.toString(), alignment: 'center', margin: 10, fontSize: 14 };
+                // },
+                info: {
+                    title: 'TaskReport',
+                },
+                pageMargins: [10, 15, 10, 15],
+                pageOrientation: IsLandScape ? 'landscape' : 'portrait',
+                content: [
+                    this.GetHeader(Images, ReportType),
+                    // { text: ReportType.toString(), alignment: 'center', margin: 10, fontSize: 14 },
+                    this.GetTableForApproval(TaskData, ReportType, EntityData.User.TZ),
+                ],
+                styles: SharedPDFService.GetStyles(),
+            };
+            pdfMake.createPdf(dd).open();
+        }, 400)
+
+        // return dd;
+    }
+
+    static GetHeader(Images: any, ReportType: any) {
+        if (TrUtils.IsNull(Images)) {
+            return {
+                stack: [{ text: 'REPORT', alignment: 'center', bold: true, fontSize: 16, marginBottom: 5 },
+                { text: ReportType.toString(), alignment: 'center', fontSize: 14 }]
+            }
+        } else {
+            return {
+                columns: [{ image: Images, width: 40 * 1 }, {
+                    stack: [{ text: 'REPORT', alignment: 'center', bold: true, fontSize: 16, marginBottom: 5 },
+                    { text: ReportType.toString(), alignment: 'center', fontSize: 14 }]
+                }]
+            }
+        }
+    }
+
+    static GetTableForApproval(TaskData: any, ReportType: any, TZ: any) {
+        return {
+            style: 'tableExample',
+            marginTop: 7,
+            lineHeight: 1,
+            dontBreakRows: true,
+            table: {
+                // widths: [30, 50, 200, 60, 100, 60],
+                widths: [30, 50, '*', 200, 50, 50],
+                body: this.GetApprovalTableHeaderBody(TaskData, ReportType, TZ)
+            },
+            layout: PrintSharedService.LayOutStyle()
+        };
+    }
+
+    static GetApprovalTableHeaderBody(TaskData: any, ReportType: any, TZ: any) {
+
+        var body: any = [];
+        let SNo: number = 1;
+        let columns: any = this.GetTableHeadersForApproval();
+        body.push(columns);
+        TaskData.forEach((task: any) => {
+            var dataRow: any = [];
+            columns.forEach((column: any) => {
+                if (!TrUtils.IsFixedZero(task[column.Field]) && !TrUtils.IsNull(task[column.Field])) {
+                    if (column.Field === 'SNo') {
+                        dataRow.push(task[column.Field].toString());
+                    } else {
+                        if (!TrUtils.IsNull(task['EstEnDt']) && column.Field === 'EstEnDt') {
+                            dataRow.push({ text: this.GetDueDate(task, TZ), alignment: 'left', nowrap: true });
+                        } else {
+                            dataRow.push({ text: task[column.Field].toString(), alignment: 'left', nowrap: true });
+                        }
+                    }
+                } else {
+                    if (column.Field === 'SNo') {
+                        task[column.Field] = SNo;
+                        SNo = SNo + 1;
+                    } else {
+                        task[column.Field] = '';
+                    }
+                    dataRow.push({ text: task[column.Field].toString(), alignment: 'left' });
+                }
+            });
+            body.push(dataRow);
+        });
+        return body;
+    }
+
+    static GetTableHeadersForApproval() {
+        let headersNames: any =
+            [
+                { text: 'S.No.', style: 'tableheader', Field: 'SNo' },
+                { text: 'Task #', style: 'tableheader', Field: 'Code' },
+                { text: 'Task Name', style: 'tableheader', Field: 'Name' },
+                { text: 'Due Date', style: 'tableheader', Field: 'EstEnDt' },
+                { text: 'Priority', style: 'tableheader', Field: 'Prty' },
+                { text: 'Status', style: 'tableheader', Field: 'Sts' },
+            ];
+
+        return headersNames;
+    }
+
+    static GetOverDuePrint(TaskData: any, IsLandScape: any, ReportType: any, Image: any, EntityData: any) {
+        TaskData = this.PrepareDataForTable(TaskData, EntityData);
+        let Images: any;
+        SharedPDFService.convertImgToBase64URL(Image, function (base64Img: any) {
+            Images = base64Img.toString();
+        }, function (ntg: any) {
+            Images = null;
+        });
+        setTimeout(() => {
+            var dd: any = {
+                // header: function () {
+                //     return { text: ReportType.toString(), alignment: 'center', margin: 10, fontSize: 14 };
+                // },
+                pageMargins: [10, 15, 10, 15],
+                pageOrientation: IsLandScape ? 'landscape' : 'portrait',
+                content: [
+                    this.GetHeader(Images, ReportType),
+                    // { text: ReportType.toString(), alignment: 'center', margin: 10, fontSize: 14 },
+                    this.GetTableForApprovalUnAssignedTasks(TaskData, ReportType),
+                ],
+                styles: SharedPDFService.GetStyles()
+            };
+            pdfMake.createPdf(dd).open();
+        }, 400)
+
+        // return dd;
+    }
+
+    static GetTableForApprovalUnAssignedTasks(TaskData: any, ReportType: any) {
+        return {
+            style: 'tableExample',
+            marginTop: 7,
+            lineHeight: 1,
+            dontBreakRows: true,
+            table: {
+                widths: [30, 50, '*', 100, 180],
+                body: this.GetApprovalTableHeaderUnAssignedTasksBody(TaskData, ReportType)
+            },
+            layout: PrintSharedService.LayOutStyle()
+        };
+    }
+
+    static GetApprovalTableHeaderUnAssignedTasksBody(TaskData: any, ReportType: any) {
+        var body: any = [];
+        let SNo: number = 1;
+        let columns: any = this.GetOverDueTableHeadersForApproval();
+        body.push(columns);
+        TaskData.forEach((task: any) => {
+            var dataRow: any = [];
+            columns.forEach((column: any) => {
+                if (!TrUtils.IsNull(task.level) && column.Field === 'SNo') {
+                    dataRow.push({ text: task.Assignee.toString(), alignment: 'left', bold: true, colSpan: 5, nowrap: true, fillColor: 'lightgrey' });
+                } else if (TrUtils.IsNull(task.level)) {
+                    if (!TrUtils.IsFixedZero(task[column.Field]) && !TrUtils.IsNull(task[column.Field])) {
+                        if (column.Field === 'SNo') {
+                            dataRow.push(task[column.Field].toString());
+                        } else {
+                            dataRow.push({ text: task[column.Field].toString(), alignment: 'left', nowrap: true });
+                        }
+
+                    } else {
+                        if (column.Field === 'SNo') {
+                            task[column.Field] = SNo;
+                            SNo = SNo + 1;
+                        } else {
+                            task[column.Field] = '';
+                        }
+                        dataRow.push({ text: task[column.Field].toString(), alignment: 'left' });
+                    }
+                } else {
+                    dataRow.push({});
+                }
+            });
+            body.push(dataRow);
+        });
+        return body;
+    }
+
+    static GetOverDueTableHeadersForApproval() {
+        let headersNames: any =
+            [
+                { text: 'S.No.', style: 'tableheader', Field: 'SNo' },
+                { text: 'Task #', style: 'tableheader', Field: 'TId' },
+                { text: 'Task Name', style: 'tableheader', Field: 'Name' },
+                { text: 'Assign Date', style: 'tableheader', Field: 'AssDate' },
+                { text: 'Due Date', style: 'tableheader', Field: 'DueDt' }
+            ];
+
+        return headersNames;
+    }
+
+    static GetDueDate(params: any, TZ:any) {
+        if (!TrUtils.IsEmpty(params.EstEnDt)) {
+            let DueDays: string;
+            let TodayDate: any = MyDate.GetDateTimeNowInUTC(TZ);
+            let Days = MyDate.GetDaysDiffBetween(TodayDate, params.EstEnDt);
+            if (Days > 1) {
+                DueDays = 'Due in' + ' ' + Days + ' ' + 'days';
+            } else if (Days === 1) {
+                DueDays = 'Due tomorrow';
+            } else if (Days === 0) {
+                DueDays = 'Due today';
+            } else {
+                let days: any = Math.abs(Days);
+                if (days === 1) {
+                    DueDays = '1 day overdue';
+                } else {
+                    DueDays = Math.abs(Days) + ' ' + 'days overdue';
+                }
+            }
+            return MyDate.GetWeekAndDate(params.EstEnDt, TZ) + ' , ' + DueDays;
+        }
+        return '';
+    }
+
+    static PrepareDataForTable(overdueEmpTasks: any[], EntityData: any) {
+        this.overdueTasks = [];
+        overdueEmpTasks.forEach((overdueEmpTask: any) => {
+            overdueEmpTask.Tasks.forEach((Task: any) => {
+                let TaskInfo: any = {
+                    UserId: overdueEmpTask._id,
+                    TId: Task.Code,
+                    DueDt: this.GetDueDate(Task, EntityData.User.TZ),
+                    Name: Task.Name,
+                    Assignee: Task.Assignee.Name,
+                    AssDate: (Task.Assignee.Ass === true || Task.Assignee.Ass === false) ? '' : MyDate.GetWeekAndDate(Task.Assignee.Ass, EntityData.User.TZ)
+                };
+                this.overdueTasks.push(TaskInfo);
+            });
+        });
+        let TableData = this.addGroups(this.overdueTasks, this.groupByColumns);
+        return TableData;
+    }
+
+    static addGroups(data: any[], groupByColumns: string[]): any[] {
+        var rootGroup = new Group();
+        return this.getSublevel(data, 0, groupByColumns, rootGroup);
+    }
+
+    static getSublevel(data: any[], level: number, groupByColumns: string[], parent: Group): any[] {
+        // Recursive function, stop when there are no more levels.
+        if (level >= groupByColumns.length)
+            return data;
+
+        var groups = this.uniqueBy(
+            data.map(
+                row => {
+                    var result: any = new Group();
+                    result.level = level + 1;
+                    result.parent = parent;
+                    for (var i = 0; i <= level; i++)
+                        result[groupByColumns[i]] = row[groupByColumns[i]];
+                    return result;
+                }
+            ),
+            JSON.stringify);
+
+        const currentColumn = groupByColumns[level];
+
+        var subGroups: any[] = [];
+        groups.forEach((group: any) => {
+            let rowsInGroup = data.filter(row => group[currentColumn] === row[currentColumn]);
+            if (rowsInGroup.length !== 0) {
+                group.Assignee = rowsInGroup[0].Assignee;
+            }
+            let subGroup = this.getSublevel(rowsInGroup, level + 1, groupByColumns, group);
+            subGroup.unshift(group);
+            subGroups = subGroups.concat(subGroup);
+        });
+        return subGroups;
+    }
+
+    static uniqueBy(a: any, key: any) {
+        var seen: any = {};
+        return a.filter(function (item: any) {
+            var k = key(item);
+            return seen.hasOwnProperty(k) ? false : (seen[k] = true);
+        });
+    }
+    
+}

package/src/tax/index.ts

@@ -0,0 +1,86 @@
+/**
+ * Tax System — Public API
+ *
+ * This is the entry point for all tax-related functionality.
+ * Import from "shareneus/tax" in both UI and API code.
+ */
+
+// Types
+export type {
+    // Enums / Union types
+    TaxComponentType,
+    CalcMethod,
+    AppliedOn,
+    RoundingMethod,
+    TaxCategory,
+    SupplyType,
+    ResolvedSupplyType,
+    WithholdingType,
+    ResolverType,
+
+    // Regime types
+    IRegimeComponent,
+    IRegimeFeatures,
+    IRounding,
+    ITreatment,
+    ITaxRegime,
+
+    // TaxCode types
+    ITaxCodeComponent,
+    ITaxCode,
+
+    // Line-item types
+    ITaxComponent,
+
+    // Summary types (optional, v2)
+    ITaxSummaryLine,
+    ITaxSummary,
+
+    // Withholding types (TDS/TCS generic)
+    IWithholding,
+    IWithholdingCalcInput,
+
+    // Input/Output types
+    ILineAmountFields,
+    IComponentOverride,
+    ITaxCalcLineInput,
+    ITaxSummaryInput,
+    IRoundingConfig,
+    IDocumentTotalsInput,
+    IDocumentTotals,
+
+    // TaxId types
+    ITaxIdLabel,
+    ITaxIdEntry,
+
+    // Exemption types (v2 master)
+    ITaxExemption,
+
+    // Authority types (v2, US)
+    ITaxAuthority,
+
+    // External provider types (v2)
+    IExternalProvider,
+} from "./tax.types";
+
+// Calculator functions and result types
+export type { IInclusiveResult } from "./tax-calculator";
+
+export {
+    CalculateGrossAmt,
+    CalculateNetAmt,
+    CalculateLineTax,
+    ExtractNetFromInclusive,
+    SumTaxComponents,
+    ComputeTaxSummary,
+    ComputeDocumentTotals,
+    DetermineSupplyType,
+    FindTaxCodeByRateAndSupplyType,
+    CalculateWithholding,
+    RoundAmount,
+    ValidateTaxId,
+    ValidateHSNSACLength,
+    ConvertFlatToTaxes,
+    GetDefaultTaxIdLabels,
+    GetPrintableTaxIds,
+} from "./tax-calculator";