shareneus 1.0.5

package/dist/services/task-pdf.service.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskPDfService = void 0;
+const my_date_1 = require("../utils/my-date");
+const tr_utils_1 = require("../utils/tr-utils");
+const shared_pdf_service_1 = require("./shared-pdf.service");
+const shared_print_service_1 = require("./shared-print.service");
+class TaskPDfService {
+    static GetPdfForUnAssignedTasks(TaskData, Image) {
+        let Images;
+        // let IsThere: boolean = false;
+        // Images = this.imageExists(meetingData.image);
+        // console.log(Images);
+        // TaskData.image = 'assets/images/1013/logo.jpg';
+        shared_pdf_service_1.SharedPDFService.convertImgToBase64URL(Image, function (base64Img) {
+            Images = base64Img.toString();
+        }, function (ntg) {
+            Images = null;
+        });
+        shared_pdf_service_1.SharedPDFService.convertImgToBase64URL(Image, function (base64Img) {
+        }, function (ntg) {
+        });
+        setTimeout(() => {
+            var dd = {
+                info: {
+                    title: 'Tasks',
+                },
+                header: function (currentPage, pageCount) {
+                    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),
+                ],
+                styles: shared_pdf_service_1.SharedPDFService.GetStyles(),
+            };
+            pdfMake.createPdf(dd).open();
+        }, 400);
+    }
+    static GetHeader(task) {
+        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) {
+        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, TaskData) {
+        if (tr_utils_1.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) {
+        if (!tr_utils_1.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) {
+        // 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) {
+        return {
+            stack: [
+                this.GetTableHeadersForApproval(TaskData),
+            ]
+        };
+    }
+    static GetTableHeadersForApproval(TaskData) {
+        let headersNames = [
+            { name: 'Status', value: this.GetValue(TaskData.Sts) },
+            { name: 'Start date', value: this.GetValue(my_date_1.MyDate.ConvertUTCDateToReadable(TaskData.EstStDt)) },
+            { name: 'Due date', value: this.GetValue(my_date_1.MyDate.ConvertUTCDateToReadable(TaskData.EstEnDt)) },
+            { name: 'Estimated Time', value: this.GetTime(TaskData.EstEnDt) },
+            { 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) {
+        if (!tr_utils_1.TrUtils.IsEmpty(value)) {
+            return value;
+        }
+        else {
+            return 'Not specified';
+        }
+    }
+    static GetProgress(value) {
+        if (!tr_utils_1.TrUtils.IsEmpty(value)) {
+            return value + '%';
+        }
+        else {
+            return '0' + '%';
+        }
+    }
+    static GetPriority(value) {
+        if (!tr_utils_1.TrUtils.IsEmpty(value)) {
+            return value;
+        }
+        else {
+            return 'None';
+        }
+    }
+    static GetTime(date) {
+        if (!tr_utils_1.TrUtils.IsNull(date)) {
+            let time = my_date_1.MyDate.ConvertUTCDateTimeToReadable(date);
+            return time;
+        }
+        else {
+            return 'Not specified';
+        }
+    }
+    static GetAssinessList(Members) {
+        let Assignees = '';
+        let membersData = Members.filter((member) => {
+            return !tr_utils_1.TrUtils.IsNull(member.Ass) && tr_utils_1.TrUtils.IsNull(member.EnDt);
+        });
+        membersData.forEach((member, index) => {
+            if (member.Role === 'Assignee') {
+                let comma = ' , ';
+                if (membersData.length === index + 1) {
+                    comma = ' ';
+                }
+                let date = my_date_1.MyDate.ConvertUTCDateToReadable(member.Ass);
+                Assignees = Assignees + member.Name + ' (' + date + ')' + comma;
+            }
+        });
+        return Assignees;
+    }
+    static GetOwner(Members) {
+        let Owner = '';
+        Members.forEach((member) => {
+            if (member.Role === 'Owner') {
+                Owner = member.Name;
+            }
+        });
+        return Owner;
+    }
+    static GetDetails(data) {
+        return {
+            style: 'tableExample',
+            fontSize: this.BodySize,
+            lineHeight: 1,
+            marginTop: 5,
+            table: {
+                widths: [150, '*'],
+                body: this.GetDetailsTable(data)
+            },
+            layout: shared_print_service_1.PrintSharedService.LayOutStyle()
+        };
+    }
+    static GetDetailsTable(data) {
+        var body = [];
+        data.forEach((row) => {
+            if (!tr_utils_1.TrUtils.IsEmpty(row.value)) {
+                var dataRow = [];
+                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, key) {
+        var seen = {};
+        return a.filter(function (item) {
+            var k = key(item);
+            return seen.hasOwnProperty(k) ? false : (seen[k] = true);
+        });
+    }
+}
+exports.TaskPDfService = TaskPDfService;
+TaskPDfService.BodySize = 8;

package/dist/services/task-reports-pdf.service.js

@@ -0,0 +1,296 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskReportsPDfService = void 0;
+const my_date_1 = require("../utils/my-date");
+const tr_utils_1 = require("../utils/tr-utils");
+const shared_pdf_service_1 = require("./shared-pdf.service");
+const shared_print_service_1 = require("./shared-print.service");
+class Group {
+    constructor() {
+        this.level = 0;
+        this.expanded = true;
+        this.Assignee = '';
+    }
+    get visible() {
+        return !this.parent || (this.parent.visible && this.parent.expanded);
+    }
+}
+class TaskReportsPDfService {
+    static GetPdfForUnAssignedTasks(TaskData, IsLandScape, ReportType, Image) {
+        let Images;
+        shared_pdf_service_1.SharedPDFService.convertImgToBase64URL(Image, function (base64Img) {
+            Images = base64Img.toString();
+        }, function (ntg) {
+            Images = null;
+        });
+        setTimeout(() => {
+            var dd = {
+                // 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),
+                ],
+                styles: shared_pdf_service_1.SharedPDFService.GetStyles(),
+            };
+            pdfMake.createPdf(dd).open();
+        }, 400);
+        // return dd;
+    }
+    static GetHeader(Images, ReportType) {
+        if (tr_utils_1.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, ReportType) {
+        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)
+            },
+            layout: shared_print_service_1.PrintSharedService.LayOutStyle()
+        };
+    }
+    static GetApprovalTableHeaderBody(TaskData, ReportType) {
+        var body = [];
+        let SNo = 1;
+        let columns = this.GetTableHeadersForApproval();
+        body.push(columns);
+        TaskData.forEach((task) => {
+            var dataRow = [];
+            columns.forEach((column) => {
+                if (!tr_utils_1.TrUtils.IsFixedZero(task[column.Field]) && !tr_utils_1.TrUtils.IsNull(task[column.Field])) {
+                    if (column.Field === 'SNo') {
+                        dataRow.push(task[column.Field].toString());
+                    }
+                    else {
+                        if (!tr_utils_1.TrUtils.IsNull(task['EstEnDt']) && column.Field === 'EstEnDt') {
+                            dataRow.push({ text: this.GetDueDate(task), 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 = [
+            { 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, IsLandScape, ReportType, Image) {
+        TaskData = this.PrepareDataForTable(TaskData);
+        let Images;
+        shared_pdf_service_1.SharedPDFService.convertImgToBase64URL(Image, function (base64Img) {
+            Images = base64Img.toString();
+        }, function (ntg) {
+            Images = null;
+        });
+        setTimeout(() => {
+            var dd = {
+                // 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: shared_pdf_service_1.SharedPDFService.GetStyles()
+            };
+            pdfMake.createPdf(dd).open();
+        }, 400);
+        // return dd;
+    }
+    static GetTableForApprovalUnAssignedTasks(TaskData, ReportType) {
+        return {
+            style: 'tableExample',
+            marginTop: 7,
+            lineHeight: 1,
+            dontBreakRows: true,
+            table: {
+                widths: [30, 50, '*', 100, 180],
+                body: this.GetApprovalTableHeaderUnAssignedTasksBody(TaskData, ReportType)
+            },
+            layout: shared_print_service_1.PrintSharedService.LayOutStyle()
+        };
+    }
+    static GetApprovalTableHeaderUnAssignedTasksBody(TaskData, ReportType) {
+        var body = [];
+        let SNo = 1;
+        let columns = this.GetOverDueTableHeadersForApproval();
+        body.push(columns);
+        TaskData.forEach((task) => {
+            var dataRow = [];
+            columns.forEach((column) => {
+                if (!tr_utils_1.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 (tr_utils_1.TrUtils.IsNull(task.level)) {
+                    if (!tr_utils_1.TrUtils.IsFixedZero(task[column.Field]) && !tr_utils_1.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 = [
+            { 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) {
+        if (!tr_utils_1.TrUtils.IsEmpty(params.EstEnDt)) {
+            let DueDays;
+            let TodayDate = my_date_1.MyDate.GetDateTimeNowInUTC();
+            let Days = my_date_1.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 = Math.abs(Days);
+                if (days === 1) {
+                    DueDays = '1 day overdue';
+                }
+                else {
+                    DueDays = Math.abs(Days) + ' ' + 'days overdue';
+                }
+            }
+            return my_date_1.MyDate.GetWeekAndDate(params.EstEnDt) + ' , ' + DueDays;
+        }
+        return '';
+    }
+    static PrepareDataForTable(overdueEmpTasks) {
+        this.overdueTasks = [];
+        overdueEmpTasks.forEach((overdueEmpTask) => {
+            overdueEmpTask.Tasks.forEach((Task) => {
+                let TaskInfo = {
+                    UserId: overdueEmpTask._id,
+                    TId: Task.Code,
+                    DueDt: this.GetDueDate(Task),
+                    Name: Task.Name,
+                    Assignee: Task.Assignee.Name,
+                    AssDate: (Task.Assignee.Ass === true || Task.Assignee.Ass === false) ? '' : my_date_1.MyDate.GetWeekAndDate(Task.Assignee.Ass)
+                };
+                this.overdueTasks.push(TaskInfo);
+            });
+        });
+        let TableData = this.addGroups(this.overdueTasks, this.groupByColumns);
+        return TableData;
+    }
+    static addGroups(data, groupByColumns) {
+        var rootGroup = new Group();
+        return this.getSublevel(data, 0, groupByColumns, rootGroup);
+    }
+    static getSublevel(data, level, groupByColumns, parent) {
+        // Recursive function, stop when there are no more levels.
+        if (level >= groupByColumns.length)
+            return data;
+        var groups = this.uniqueBy(data.map(row => {
+            var result = 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 = [];
+        groups.forEach((group) => {
+            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, key) {
+        var seen = {};
+        return a.filter(function (item) {
+            var k = key(item);
+            return seen.hasOwnProperty(k) ? false : (seen[k] = true);
+        });
+    }
+}
+exports.TaskReportsPDfService = TaskReportsPDfService;
+TaskReportsPDfService.overdueTasks = [];
+TaskReportsPDfService.groupByColumns = ['UserId'];