shareneus 1.0.5

package/dist/services/meeting-pdf.js

@@ -0,0 +1,369 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeetingPdfService = 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");
+class MeetingPdfService {
+    static MeetingPrintData(meetingData, isAgendata) {
+        let Images;
+        shared_pdf_service_1.SharedPDFService.convertImgToBase64URL(meetingData.image, function (base64Img) {
+            Images = base64Img.toString();
+        }, function (ntg) {
+            Images = null;
+        });
+        setTimeout(() => {
+            let dd = {
+                info: {
+                    title: 'Meeting',
+                },
+                header: function (currentPage, pageCount) {
+                    return { text: currentPage.toString() + ' of ' + pageCount, alignment: 'right', marginRight: 7, fontSize: 8, marginTop: 2 };
+                },
+                pageMargins: [10, 15, 10, 15],
+                content: [
+                    this.HeaderContent(meetingData, isAgendata, Images),
+                    shared_pdf_service_1.SharedPDFService.HeaderAfterLine(),
+                    this.GetMeetingDetails(meetingData, isAgendata),
+                    shared_pdf_service_1.SharedPDFService.HeaderAfterLine(),
+                    {
+                        stack: [{ text: 'Topics', bold: true, marginBottom: 7 }, this.GetTopicsAndSubTopicsAndItemsList(meetingData, meetingData.Items, isAgendata)], marginTop: 10
+                    },
+                ],
+                styles: shared_pdf_service_1.SharedPDFService.GetStyles()
+            };
+            // return dd;
+            pdfMake.createPdf(dd).open();
+        }, 400);
+    }
+    static HeadingforMeeting(isAgendata) {
+        if (isAgendata) {
+            return { text: 'AGENDA', alignment: 'center', bold: true, fontSize: 16 };
+        }
+        else {
+            return { text: 'MINUTES', alignment: 'center', bold: true, fontSize: 16 };
+        }
+    }
+    static HeaderContent(meetingData, isAgendata, Images) {
+        if (tr_utils_1.TrUtils.IsNull(Images)) {
+            return { columns: [this.Header(meetingData, isAgendata)], width: '*', marginBottom: 5 };
+        }
+        else {
+            return {
+                columns: [{ image: Images, width: 40 * 1 },
+                    this.Header(meetingData, isAgendata),
+                ], marginBottom: 5
+            };
+        }
+    }
+    static imageExists(image_url) {
+        var http = new XMLHttpRequest();
+        http.open('HEAD', image_url, false);
+        http.send();
+        return http.status != 404;
+    }
+    static Header(meetingData, isAgendata) {
+        // let Title: any;
+        // if (isAgendata) {
+        //     Title = 'Agenda for ' + meetingData.Title;
+        // } else {
+        //     Title = 'Minutes of  ' + meetingData.Title;
+        // }
+        return { stack: [this.HeadingforMeeting(isAgendata), { text: '' + meetingData.Title + '', style: ['meetingHeader'], width: '*', marginTop: 5, alignment: 'center' }] };
+    }
+    static GetMeetingDetails(meetingData, isAgendata) {
+        return {
+            stack: [
+                this.GetMeetingTimeDetails(meetingData, isAgendata),
+            ]
+        };
+    }
+    static GetMeetingTimeDetails(MeetingData, isAgendata) {
+        let MeetingFields = [
+            { name: 'Date and time', value: this.getDateAndTime(MeetingData) },
+            { name: 'Location', value: MeetingData.Loc }
+        ];
+        if (isAgendata) {
+            MeetingFields.push({ name: 'Participants', value: this.getParticipantsMembers(MeetingData.Members) });
+            MeetingFields.push({ name: 'Optional', value: this.GetOptionalMembers(MeetingData.Members) });
+            MeetingFields.push({ name: 'CC', value: this.getCCMembers(MeetingData.Members) });
+        }
+        else {
+            MeetingFields.push({ name: 'Present', value: this.getPresentMembers(MeetingData.Members) });
+            MeetingFields.push({ name: 'Absent', value: this.getAbsentMembers(MeetingData.Members) });
+            MeetingFields.push({ name: 'CC', value: this.getCCMembersAndOptionalAbsent(MeetingData.Members) });
+        }
+        return this.GetDetails(MeetingFields);
+    }
+    static getPresentMembers(Members) {
+        let Present = '';
+        let ReqMembers = Members.filter((member) => {
+            return (member.Type !== 'CC') && member.Att;
+        });
+        ReqMembers.forEach((member, Index) => {
+            Present += member.Name;
+            if (Index !== ReqMembers.length - 1) {
+                Present += ', ';
+            }
+        });
+        return Present;
+    }
+    static getAbsentMembers(Members) {
+        let Absent = '';
+        let ReqMembers = Members.filter((member) => {
+            return (member.Type !== 'CC' && member.Type !== 'OPT') && !member.Att;
+        });
+        ReqMembers.forEach((member, Index) => {
+            Absent += member.Name;
+            if (Index !== ReqMembers.length - 1) {
+                Absent += ', ';
+            }
+        });
+        return Absent;
+    }
+    static getDateAndTime(MeetingData) {
+        return MeetingData.StDate + ' to : ' + MeetingData.EnDate;
+    }
+    static getParticipantsMembers(Members) {
+        let Invites = '';
+        let ReqMembers = Members.filter((member) => {
+            return member.Type === 'ORG' || member.Type === 'REQ';
+        });
+        ReqMembers.forEach((member, Index) => {
+            Invites += member.Name;
+            if (Index !== ReqMembers.length - 1) {
+                Invites += ', ';
+            }
+        });
+        return Invites;
+    }
+    static GetOptionalMembers(Members) {
+        let Invites = '';
+        let ReqMembers = Members.filter((member) => {
+            return member.Type === 'OPT';
+        });
+        ReqMembers.forEach((member, Index) => {
+            Invites += member.Name;
+            if (Index !== ReqMembers.length - 1) {
+                Invites += ', ';
+            }
+        });
+        return Invites;
+    }
+    static getCCMembers(Members) {
+        let Optional = '';
+        let OptMembers = Members.filter((member) => {
+            return member.Type === 'CC';
+        });
+        OptMembers.forEach((member, index) => {
+            Optional += member.Name;
+            if (index !== OptMembers.length - 1) {
+                Optional += ', ';
+            }
+        });
+        return Optional;
+    }
+    static getCCMembersAndOptionalAbsent(Members) {
+        let Optional = '';
+        let OptMembers = Members.filter((member) => {
+            return member.Type === 'CC' || (member.Type === 'OPT' && !member.Att);
+        });
+        OptMembers.forEach((member, index) => {
+            Optional += member.Name;
+            if (index !== OptMembers.length - 1) {
+                Optional += ', ';
+            }
+        });
+        return Optional;
+    }
+    static GetDetails(data) {
+        return {
+            fontSize: this.BodySize,
+            lineHeight: 1,
+            // widths:['*','*',10],
+            margin: 10,
+            table: {
+                body: this.GetDetailsTable(data)
+            },
+            layout: 'noBorders',
+        };
+    }
+    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 });
+                dataRow.push(':');
+                dataRow.push({ text: (row.value).toString(), lineHeight: 1 });
+                body.push(dataRow);
+            }
+            else {
+                var a = [];
+                a.push('');
+                a.push('');
+                a.push('');
+                body.push(a);
+            }
+        });
+        return body;
+    }
+    static GetTopicsAndSubTopicsAndItemsList(meetingData, items, isAgendata) {
+        let tpcs = [];
+        meetingData.Topics.forEach((tpc, index) => {
+            let a;
+            if (tr_utils_1.TrUtils.IsNull(tpc.Prt)) {
+                a = { columns: [{ text: (index + 1) + ' . ', width: 20, marginTop: 5, marginBottom: 5, bold: true, fontSize: 12 }, { text: tpc.Desc, marginTop: 5, marginBottom: 5, bold: true, fontSize: 12 }] };
+                tpcs.push(a);
+                // tpcs.push({ stack: [this.SharedPrint.GetLightUnderLine(558, 'black')], marginLeft: 18 });
+                if (!isAgendata) {
+                    items.forEach((item) => {
+                        if (item.Tpc === tpc._id) {
+                            this.TopicsItemView(item, meetingData, tpcs);
+                        }
+                    });
+                }
+                tpc.SubTopics.forEach((subtpc, sindex) => {
+                    let STopic = {
+                        columns: [{ text: (index + 1 + '-' + (sindex + 1)) + ' . ', width: 25, bold: true, marginLeft: 20, marginTop: 10, marginBottom: 5, fontSize: 11 },
+                            { text: subtpc.Desc, bold: true, marginLeft: 20, marginTop: 10, marginBottom: 5, fontSize: 11 }]
+                    };
+                    tpcs.push(STopic);
+                    // tpcs.push({ stack: [this.SharedPrint.GetLightUnderLine(520, 'black')], marginLeft: 50 });
+                    if (!isAgendata) {
+                        items.forEach((item) => {
+                            if (item.Tpc === subtpc._id) {
+                                this.TopicsItemView(item, meetingData, tpcs);
+                            }
+                        });
+                    }
+                });
+            }
+        });
+        return tpcs;
+    }
+    static TopicsItemView(item, meetingData, tpcs) {
+        let ItemType = {
+            text: this.GetTypeOfItem(item.Type), marginLeft: 20, marginBottom: 5, marginTop: 5, width: 50,
+            color: this.GetColorsBasedOnType(item.Type), background: 'white', fontSize: this.BodySize,
+        };
+        let ItemDesc = this.GetDescrption(item, meetingData);
+        let TaskAssignees = this.getAssignee(item, meetingData);
+        let TaskDueDate = this.GetDueDate(item, meetingData);
+        let Item;
+        if (item.Type !== 'TAS') {
+            Item = {
+                columns: [ItemType, { text: ItemDesc, marginLeft: 2, marginTop: 6, marginBottom: 5, fontSize: this.BodySize }], marginTop: 5
+            };
+        }
+        else {
+            Item = {
+                columns: [ItemType,
+                    {
+                        stack: [{ text: ItemDesc, marginLeft: 2, fontSize: this.BodySize },
+                        ], marginTop: 6,
+                    }], marginTop: 5
+            };
+            if (!tr_utils_1.TrUtils.IsEmpty(TaskAssignees)) {
+                Item.columns[1].stack.push({
+                    columns: [{ text: 'Assignee(s) ', color: 'magenta', width: 55, fontSize: this.BodySize, marginTop: 2 },
+                        { text: TaskAssignees, fontSize: this.BodySize, marginTop: 2, marginBottom: 2 }]
+                });
+            }
+            if (!tr_utils_1.TrUtils.IsEmpty(TaskDueDate)) {
+                Item.columns[1].stack.push({
+                    columns: [{ text: 'Due Date ', color: 'magenta', width: 55, fontSize: this.BodySize, marginTop: 2 },
+                        { text: TaskDueDate, fontSize: this.BodySize, marginTop: 2, marginBottom: 5 }]
+                });
+            }
+        }
+        if (!tr_utils_1.TrUtils.IsEmpty(ItemDesc)) {
+            tpcs.push(Item);
+            tpcs.push({ stack: [shared_pdf_service_1.SharedPDFService.GetLightUnderLine(525, 'lightgray')], marginLeft: 50 });
+        }
+    }
+    static GetDescrption(Item, MeetingData) {
+        if (Item.Type === 'TAS' && !tr_utils_1.TrUtils.IsNull(MeetingData.MeetingTasks)) {
+            let Index = MeetingData.MeetingTasks.findIndex((task) => {
+                return task._id === Item.T_Id;
+            });
+            if (Index !== -1) {
+                return MeetingData.MeetingTasks[Index].Name;
+            }
+            else {
+                return '';
+            }
+        }
+        else {
+            return Item.Desc;
+        }
+    }
+    static GetDueDate(Item, MeetingData) {
+        if (Item.Type === 'TAS' && !tr_utils_1.TrUtils.IsNull(MeetingData.MeetingTasks)) {
+            let Index = MeetingData.MeetingTasks.findIndex((task) => {
+                return task._id === Item.T_Id;
+            });
+            if (Index !== -1) {
+                return tr_utils_1.TrUtils.IsNull(MeetingData.MeetingTasks[Index].EstEnDt) ? '' : my_date_1.MyDate.GetWeekAndDate(MeetingData.MeetingTasks[Index].EstEnDt);
+            }
+            else {
+                return '';
+            }
+        }
+        else {
+            return '';
+        }
+    }
+    static getAssignee(Item, MeetingData) {
+        if (Item.Type === 'TAS' && !tr_utils_1.TrUtils.IsNull(MeetingData.MeetingTasks)) {
+            let Index = MeetingData.MeetingTasks.findIndex((task) => {
+                return task._id === Item.T_Id;
+            });
+            if (Index !== -1) {
+                let Members = MeetingData.MeetingTasks[Index].Members.filter((member) => {
+                    return !tr_utils_1.TrUtils.IsNull(member.Ass) && tr_utils_1.TrUtils.IsNull(member.EnDt);
+                });
+                let Ass = '';
+                Members.forEach((member, index) => {
+                    if (!tr_utils_1.TrUtils.IsNull(member.Ass)) {
+                        Ass = Ass + member.Name;
+                        if (index !== Members.length - 1) {
+                            Ass = Ass + ', ';
+                        }
+                    }
+                });
+                return Ass;
+            }
+            else {
+                return '';
+            }
+        }
+        else {
+            return '';
+        }
+    }
+    static GetTypeOfItem(type) {
+        if (type === 'NOT') {
+            return 'Note';
+        }
+        else if (type === 'DEC') {
+            return 'Desc';
+        }
+        else {
+            return 'Task';
+        }
+    }
+    static GetColorsBasedOnType(type) {
+        if (type === 'NOT') {
+            return '#b30000';
+        }
+        else if (type === 'DEC') {
+            return 'blue';
+        }
+        else {
+            return 'green';
+        }
+    }
+}
+exports.MeetingPdfService = MeetingPdfService;
+MeetingPdfService.BodySize = 10;