shareneus 1.7.4 → 1.7.6

package/src/services/technician-pdf.service.ts

@@ -0,0 +1,234 @@
+import { PayTypeEnum } from '../enums/enums';
+import { SharedPDFService } from '../shared/shared-pdf.service';
+import { TrUtils } from '../utils/tr-utils';
+declare var pdfMake: any;
+
+export class TechnicianpdfService {
+
+    static GetTechnicianPrint(RepairOrder: any, isOtherIndustry: boolean) {
+        var dd = {
+            info: {
+                title: 'Technician',
+            },
+            header: function (currentPage: any, pageCount: any) {
+                return { text: currentPage.toString() + ' of ' + pageCount, alignment: 'right', marginRight: 7, fontSize: 8, marginTop: 2 };
+            },
+            pageMargins: [10, 15, 10, 15],
+            content: [
+                // SharedPDFService.MainHeading(RepairOrder.Entity.CName, RepairOrder.Entity.Header, RepairOrder.Image, RepairOrder.HColor, null),
+                SharedPDFService.GetMainHeader(RepairOrder.Entity, RepairOrder.Image, RepairOrder.AColor, RepairOrder.HColor, null),
+                SharedPDFService.GetPrintType(RepairOrder.HeaderName),
+                SharedPDFService.HeaderAfterLine(),
+                SharedPDFService.GetCustomerAndVehicleDetails(RepairOrder._id, RepairOrder.CrDate, RepairOrder.PrDate,
+                    RepairOrder.MOut, RepairOrder.MIn, RepairOrder.Product, RepairOrder.PrintType, RepairOrder.For,
+                    RepairOrder.SurName, RepairOrder.SurPhone, RepairOrder.Type, RepairOrder.SurEmail, RepairOrder.InsComp,
+                    RepairOrder.PolNo, RepairOrder.PolType, RepairOrder.Customer, false, RepairOrder.Settings, null, isOtherIndustry, null, null,null,null, RepairOrder.DoS),
+                SharedPDFService.CustomerAndVehicleDetailsAfterLine(),
+                { stack: this.getComplaintsAndServices(RepairOrder.Comps, RepairOrder.Ops), marginBottom: 7 },
+                this.getLine(RepairOrder.Comps),
+                this.getOnlyServices(RepairOrder.Ops),
+                this.GetIndHeading(RepairOrder.Colli),
+                this.GetCollisionItems(RepairOrder.Colli, RepairOrder.Parts, RepairOrder.Ops),
+            ],
+            styles: SharedPDFService.GetStyles()
+        };
+        return dd;
+        // pdfMake.createPdf(dd).open();
+        // this.dd = TrUtils.Stringify(dd);
+        // pdfMake.createPdf(dd).getDataUrl(function (outDoc: any) {
+        //     document.getElementById('pdf').setAttribute('src', outDoc);
+        // });
+    }
+
+    static GetIndHeading(CollItems: any) {
+        if (!TrUtils.IsNull(CollItems) && CollItems.length !== 0) {
+            return [{ text: 'Accidental Repairs :', fontSize: 12, marginTop: 5, bold: true, decoration: 'underline' }];
+        } else {
+            let a: any = {};
+            return a;
+        }
+    }
+
+    static getLine(Comps: any) {
+        if (Comps.length !== 0) {
+            return SharedPDFService.GetUnderLine();
+        } else {
+            let a: any = {};
+            return a;
+        }
+    }
+
+    static GetCollisionItems(CollItems: any, Parts: any, Labors: any) {
+        if (!TrUtils.IsNull(CollItems) && CollItems.length !== 0) {
+            return {
+                style: 'tableExample',
+                marginTop: 10,
+                lineHeight: 1,
+                table: {
+                    widths: [20, 300, 20, 60, 60, 60],
+                    // headerRows: 1,
+                    body: this.GetCollisionItemsBody(CollItems, Parts, Labors)
+                },
+                layout: {
+                    hLineColor: function (i: any, node: any) {
+                        return 'lightgray';
+                    },
+                    vLineColor: function (i: any, node: any) {
+                        return 'lightgray';
+                    },
+                }
+            };
+        } else {
+            let a: any = {};
+            return a;
+        }
+    }
+
+    static GetCollisionItemsBody(CollItems: any, Parts: any, Labors: any) {
+        var body: any = [];
+        let columns: any = this.GetCollisionItemsHeader();
+        body.push(columns);
+        let SNo: number = 1;
+        CollItems.forEach((CollItem: any, i: any) => {
+            var dataRow: any = [];
+            columns.forEach((column: any) => {
+                if (column.Field === 'SNo') {
+                    CollItem[column.Field] = SNo;
+                    SNo = SNo + 1;
+                } else if (column.Field === 'Desc') {
+                    CollItem[column.Field] = CollItem.Desc;
+                } else if (column.Field === 'rr') {
+                    let CollLaborIndex: any = Labors.findIndex((Labor: any) => {
+                        return Labor._id === CollItem.RRFId;
+                    });
+                    if (CollLaborIndex !== -1) {
+                        CollItem[column.Field] = this.CheckPrice(Labors[CollLaborIndex]);
+                    } else {
+                        CollItem[column.Field] = '';
+                    }
+                } else if (column.Field === 'dtng') {
+                    let CollLaborIndex: any = Labors.findIndex((Labor: any) => {
+                        return Labor._id === CollItem.RepId;
+                    });
+                    if (CollLaborIndex !== -1) {
+                        CollItem[column.Field] = this.CheckPrice(Labors[CollLaborIndex]);
+                    } else {
+                        CollItem[column.Field] = '';
+                    }
+                } else if (column.Field === 'ptng') {
+                    let CollLaborIndex: any = Labors.findIndex((Labor: any) => {
+                        return Labor._id === CollItem.PainId;
+                    });
+                    if (CollLaborIndex !== -1) {
+                        CollItem[column.Field] = this.CheckPrice(Labors[CollLaborIndex]);
+                    } else {
+                        CollItem[column.Field] = '';
+                    }
+                } else if (column.Field === 'Qty') {
+                    let CollPartIndex: any = Parts.findIndex((Part: any) => {
+                        return Part.CollId === CollItem._id;
+                    });
+                    if (CollPartIndex !== -1) {
+                        CollItem[column.Field] = Parts[CollPartIndex][column.Field];
+                    } else {
+                        CollItem[column.Field] = '';
+                    }
+                } else {
+                    CollItem[column.Field] = '';
+                }
+                if (column.Field === 'Desc') {
+                    let DescData: any = [];
+                    DescData.push(CollItem[column.Field].toString());
+                    if (!TrUtils.IsEmpty(CollItem['EDesc'])) {
+                        DescData.push({ text: CollItem['EDesc'].toString(), color: 'grey' });
+                    }
+                    dataRow.push({ stack: DescData });
+                } else {
+                    dataRow.push({ text: CollItem[column.Field].toString(), alignment: 'center' });
+                }
+
+            });
+            body.push(dataRow);
+        });
+        return body;
+    }
+
+    static CheckPrice(Labor: any) {
+        if (Labor.PBy === PayTypeEnum.Insurance) {
+            if (!TrUtils.IsZero(Labor.AssPr)) {
+                return 'Yes';
+            } else {
+                return '';
+            }
+        }
+        if (Labor.PBy === PayTypeEnum.Customer) {
+            if (!TrUtils.IsZero(Labor.Pr)) {
+                return 'Yes';
+            } else {
+                return '';
+            }
+        }
+        if (Labor.PBy === PayTypeEnum.Shared) {
+            if (!TrUtils.IsZero(Labor.AssPr) && !TrUtils.IsZero(Labor.Pr)) {
+                return 'Yes';
+            } else {
+                return '';
+            }
+        }
+    }
+
+    static GetCollisionItemsHeader() {
+        let headersNames =
+            [{ text: 'S.No.', Field: 'SNo', style: ['tableheader', 'withOutApp'] },
+            { text: 'Description', Field: 'Desc', style: ['tableheader', 'withOutApp'] },
+            { text: 'Qty', Field: 'Qty', style: ['tableheader', 'withOutApp'] },
+            { text: 'R&R', Field: 'rr', style: ['tableheader', 'withOutApp'] },
+            { text: 'Denting', Field: 'dtng', style: ['tableheader', 'withOutApp'] },
+            { text: 'Painting', Field: 'ptng', style: ['tableheader', 'withOutApp'] }];
+
+        return headersNames;
+    }
+
+    static getComplaintsAndServices(Comps: any, Ops: any) {
+        var List: any = [];
+        if (!TrUtils.IsNull(Comps) && Comps.length !== 0) {
+            List.push({ text: 'Complaints :', fontSize: 12, marginTop: 5, bold: true, decoration: 'underline' });
+            for (var i = 0; i < Comps.length; i++) {
+                List.push({ ul: [{ text: Comps[i].Desc, fontSize: 10, bold: true, marginLeft: 10, marginTop: 5 }] });
+                for (var j = 0; j < Ops.length; j++) {
+                    if (Comps[i]._id === Ops[j].CompId) {
+                        List.push({ text: Ops[j].Desc, fontSize: SharedPDFService.TableHeaders, marginTop: 1.5, marginLeft: 30 });
+                    }
+                }
+            }
+            return List;
+        } else {
+            return List;
+        }
+    }
+
+    static getOnlyServices(Ops: any) {
+        let List: any = [];
+        let isTrue: boolean = false;
+        if (!TrUtils.IsNull(Ops) && Ops.length !== 0) {
+            for (var i = 0; i < Ops.length; i++) {
+                if (TrUtils.IsNull(Ops[i].CompId) && TrUtils.IsNull(Ops[i].CollId)) {
+                    isTrue = true;
+                    List.push({ ul: [{ text: Ops[i].Desc, fontSize: 10, bold: true, marginLeft: 10, marginTop: 5 }] });
+                }
+            }
+            if (isTrue) {
+                List.unshift({ text: 'Services :', fontSize: 12, marginTop: 5, bold: true, decoration: 'underline' });
+            }
+            return List;
+        } else {
+            return this.EmptyReturnValue();
+        }
+    }
+
+    static EmptyReturnValue() {
+        let Empty = '';
+        return Empty;
+    }
+
+}

package/src/services/technician-print.service.ts

@@ -0,0 +1,95 @@
+
+import { LaborStatusEnum, ROStatusEnum } from '../enums/enums';
+import { PrintSharedService } from '../shared/shared-print.service';
+import { MyDate } from '../utils/my-date';
+import { TrUtils } from '../utils/tr-utils';
+
+export class TechnicianPrintService {
+
+    static GetTechnicianPrintData(OriginalROData: any, OriginalCustomerData: any, OriginalVehicleData: any, EntityData: any, image: any) {
+        let TechnicianPrintData: any = {};
+
+        TechnicianPrintData.Entity = PrintSharedService.GetFormattedEntityDataForPrint(EntityData, "Technician Copy", OriginalROData);
+
+        TechnicianPrintData = PrintSharedService.GetEntityHeaderStyles(TechnicianPrintData, EntityData, image);
+        if(TrUtils.IsNull(OriginalROData.Comps)){
+            OriginalROData.Comps=[];
+        }
+        if(TrUtils.IsNull(OriginalROData.Ops)){
+            OriginalROData.Ops=[];
+        }
+        if(TrUtils.IsNull(OriginalROData.Parts)){
+            OriginalROData.Parts=[];
+        }
+        if(TrUtils.IsNull(OriginalROData.Colli)){
+            OriginalROData.Colli=[];
+        }
+        // Gets ROData From Service And Filters Only Valid Data
+        let argROData = TrUtils.Stringify(OriginalROData);
+        argROData = this.GetItemsForTechnicianPrint(argROData);
+        argROData = this.ReverseItemsForTechnicianPrint(argROData);
+
+        TechnicianPrintData.Comps = argROData.Comps;
+        TechnicianPrintData.Ops = argROData.Ops;
+        TechnicianPrintData.Parts = argROData.Parts;
+        TechnicianPrintData.Colli = argROData.Colli;
+
+        // Prepare Records Description In A Readable Format
+        // TechnicianPrintData.Comps = PrintSharedService.FilterRecordsDescription(TechnicianPrintData.Comps);
+        // TechnicianPrintData.Ops = PrintSharedService.FilterRecordsDescription(TechnicianPrintData.Ops);
+        // TechnicianPrintData.Parts = PrintSharedService.FilterRecordsDescription(TechnicianPrintData.Parts);
+        // TechnicianPrintData.Colli = PrintSharedService.FilterRecordsDescription(TechnicianPrintData.Colli);
+
+        TechnicianPrintData.PrDate = MyDate.ConvertUTCDateToReadable(argROData.PrDate);
+        TechnicianPrintData.CrDate = MyDate.ConvertUTCDateToReadable(argROData.CrDate);
+        TechnicianPrintData.MIn = OriginalVehicleData.MIn;
+
+        TechnicianPrintData.Product = PrintSharedService.GetVehicleFromServiceAndFormatData(OriginalVehicleData);
+        TechnicianPrintData.Customer = PrintSharedService.GetCustomerDataForTechnicianPrint(OriginalCustomerData);
+
+        TechnicianPrintData._id = argROData.Code;
+        TechnicianPrintData.Type = 'Technician Copy';
+        TechnicianPrintData.HeaderName = 'Technician Copy';
+        TechnicianPrintData.For = 'Technician';
+        return TechnicianPrintData;
+    }
+
+    static GetItemsForTechnicianPrint(argROData: any) {
+        if (argROData.Sts === ROStatusEnum.New || argROData.Sts === ROStatusEnum.WtngForAppr) {
+            argROData.Ops.forEach((Labor: any) => {
+                Labor.Sts = LaborStatusEnum.New;
+            });
+            argROData.Parts.forEach((Part: any) => {
+                if (!TrUtils.IsNull(Part.CollId)) {
+                    Part.Sts = LaborStatusEnum.New;
+                }
+            });
+            argROData.Colli.forEach((Collision: any) => {
+                Collision.Sts = LaborStatusEnum.New;
+            });
+        }
+        argROData.Ops = argROData.Ops.filter((Labor: any) => {
+            return Labor.Sts !== LaborStatusEnum.Cancelled && Labor.Sts !== LaborStatusEnum.Declined;
+        });
+        argROData.Parts = argROData.Parts.filter((Part: any) => {
+            if (!TrUtils.IsNull(Part.CollId)) {
+                return Part.Sts !== LaborStatusEnum.Cancelled && Part.Sts !== LaborStatusEnum.Declined;
+            } else {
+                return Part;
+            }
+        });
+        argROData.Colli = argROData.Colli.filter((Collision: any) => {
+            return Collision.Sts !== LaborStatusEnum.Cancelled && Collision.Sts !== LaborStatusEnum.Declined;
+        });
+        return argROData;
+    }
+
+    static ReverseItemsForTechnicianPrint(argROData: any) {
+        argROData.Comps = argROData.Comps.reverse();
+        argROData.Ops = argROData.Ops.reverse();
+        argROData.Parts = argROData.Parts.reverse();
+        argROData.Colli = argROData.Colli.reverse();
+        return argROData;
+    }
+
+}