@platform-x/hep-notification-client 1.3.0 → 1.3.2

package/src/platform-x/util/emailHandler.ts

@@ -0,0 +1,580 @@
+import { EmailDataSource } from '../dataSource/emailDataSource';
+import * as HTMLParser from 'node-html-parser';
+import { style } from '../constants/style';
+import config from '../../config';
+import { CREATE_USER_EMAIL_TEMPLATE, DynamicValues } from '../constants';
+import { isArray } from 'lodash';
+import { EmailTemplateHandler } from './emailTemplate';
+const moment = require('moment-timezone');
+const sgMail = require('@sendgrid/mail');
+const sgHelpers = require('@sendgrid/helpers');
+import * as ejs from 'ejs';
+// import DOMPurify from 'dompurify';  // Include DOMPurify for sanitization
+import FormBuilderDao from '../database/dao/formBuilder.dao';
+import createDOMPurify from 'dompurify';
+import { JSDOM } from 'jsdom';
+import { Logger } from '../../common/util/logger';
+import path from 'path';
+import { getIAMSecrets } from '../..';
+
+const window = new JSDOM('').window;
+const DOMPurify = createDOMPurify(window);
+// NOSONAR-NEXT-LINE
+interface EmailOptions {
+  email: string;
+  emailTemplate: string;
+  subject: string;
+  bcc?: string;
+  cc?: string | string[]; // Support both single CC email or array of CC emails
+  personalizations?: Personalize;
+}
+interface Personalize {
+  to: [ToWithSubstitutions];
+  cc?: [ToWithSubstitutions];
+  bcc?: [ToWithSubstitutions];
+}
+interface ToWithSubstitutions {
+  to: string;
+  substitutions?: [string];
+}
+
+interface Recipients {
+  name: string;
+  email: string;
+}
+interface Substitutions {
+  name?: string;
+  document_uri?: string;
+  sender_name?: string;
+}
+// NOSONAR-NEXT-LINE
+export class EmailHandler {
+  constructor() { } // NOSONAR
+  /**
+   * post - handler to do emails triggering
+   * @param emailConfig
+   * @returns
+   */
+  public async sendEmail(emailConfig: EmailOptions) {
+    Logger.info('EmailHandler: Reached sendEmail method', 'sendEmail');
+    const secrets = await getIAMSecrets();
+    sgMail.setApiKey(secrets?.[DynamicValues?.SENDGRID_API_KEY]);
+    
+    // Build personalization object
+    const personalization: any = {
+      to: [{ email: emailConfig.email }],
+    };
+    
+    // Add CC emails if provided
+    if (emailConfig.cc) {
+      const ccEmails = Array.isArray(emailConfig.cc) ? emailConfig.cc : [emailConfig.cc];
+      personalization.cc = ccEmails.map((email: string) => ({ email }));
+      Logger.info(`Adding CC emails to non-personalized email: ${ccEmails.join(', ')}`, 'sendEmail');
+    }
+    
+    // Add BCC if provided
+    if (emailConfig.bcc) {
+      personalization.bcc = [{ email: emailConfig.bcc }];
+    }
+    
+    const msg = {
+      personalizations: [personalization],
+      from: { email: config.EMAIL_FROM },
+      html: emailConfig.emailTemplate,
+      subject: emailConfig.subject,
+    };
+    
+    Logger.debug('Before sending email', 'sendEmail', msg);
+    return new Promise((resolve: any, reject: any) => {
+      sgMail
+        .send(msg)
+        .then((response: any) => {
+          Logger.info('EmailHandler: Successfull Response', 'sendEmail');
+          resolve(response[0]);
+        })
+        .catch((error: any) => {
+          Logger.error('EmailHandler: Error in sendEmail', 'sendEmail', error);
+          reject(error);
+          // throw error;
+        });
+    });
+  }
+
+  public async prepareEmailRequest(reqBody: any, emailType: any) {
+    Logger.info('Reached prepareEmailRequest', 'prepareEmailRequest');
+    try {
+      let dataSource = new EmailDataSource();
+      Logger.debug('Before preparing email request', 'prepareEmailRequest', dataSource);
+      let response = await dataSource.fetchPageModel(emailType);
+      Logger.debug('Response for preparing email request', 'prepareEmailRequest', response);
+      const start = moment.tz(reqBody.dateTime, 'UTC'); // original timezone
+      let curentTimeZone = start
+        .tz(reqBody.timezoneOffset)
+        .format('Do MMMM YYYY, h:mm a');
+
+      const root: any = HTMLParser.parse(response[0]?.hclplatformx_Body);
+      root.querySelector(
+        '#1_dynamic_text'
+      ).textContent = ` ${reqBody.userName}`;
+      root.querySelector(
+        '#2_dynamic_text'
+      ).textContent = DOMPurify.sanitize(`<b> ${reqBody.pageTitle} </b>`);
+      root.querySelector(
+        '#3_dynamic_text'
+      ).textContent = DOMPurify.sanitize(`<b>${curentTimeZone}</b>`);
+
+      root.querySelector(
+        '#dynamic_contentType'
+      ).textContent = DOMPurify.sanitize(`<b>${reqBody.contentType}</b>`);
+      root.querySelector('#dynamic_event').textContent = DOMPurify.sanitize(`<b>${reqBody.event[0] + reqBody.event.slice(1)
+        }</b>`);
+      if (reqBody?.event?.toLowerCase() === 'published') {
+        root
+          .querySelector('.dynamic_links_btn')
+          .setAttribute('href', reqBody.publishPageUrl);
+      } else {
+        root.querySelector('#viewButton').setAttribute('style', 'display:none');
+      }
+      const append: any = root.querySelector('head');
+      append.insertAdjacentHTML('beforeend', DOMPurify.sanitize(style));
+      let emailConfiguration: any = {
+        email: reqBody.emailTo,
+        emailTemplate: root.toString(),
+        subject: DOMPurify.sanitize(response[0].hclplatformx_Subject.replace('{{pageType}}', reqBody.contentType[0] + reqBody.contentType.slice(1))
+          .replace('{{publishOrUnpublish}}', reqBody.event[0] + reqBody.event.slice(1))
+        ),
+      };
+      Logger.debug('Reached prepareEmailRequest - emailConfiguration', 'prepareEmailRequest', emailConfiguration);
+      let emailResponse: any = await this.pushEmails(emailConfiguration);
+      Logger.debug('Reached prepareEmailRequest - emailResponse', 'prepareEmailRequest', emailResponse);
+      return emailResponse;
+    } catch (error: any) {
+      Logger.error(
+        'EmailHandler: Error in preparing email Request',
+        'prepareEmailRequest',
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   *
+   * @param reqBody
+   * @param emailType
+   * @returns
+   */
+  public async prepareSendEmailRequest(reqBody: any, emailType: any) {
+    Logger.info('Reached prepareSendEmailRequest in emailHandler', 'prepareSendEmailRequest');
+    try {
+      let dataSource = new EmailDataSource();
+
+      // disable SOLR because of connectivity issue
+      let templateData = await dataSource.fetchPageModel(emailType);
+      if (reqBody?.replacement_variables && templateData?.length) {
+        for (const key in reqBody.replacement_variables) {
+          if (key) {
+            templateData[0].hclplatformx_Body =
+              templateData[0]?.hclplatformx_Body?.replace(
+                `{{${key}}}`,
+                reqBody.replacement_variables[key]
+              );
+          }
+        }
+      }
+      const root = HTMLParser.parse(templateData[0]?.hclplatformx_Body);
+      let emailConfiguration: any = {
+        email: reqBody.replacement_variables?.EMAIL,
+        emailTemplate: root ? root.toString() : '',
+        subject: CREATE_USER_EMAIL_TEMPLATE[0].subject,
+      };
+      Logger.debug('Reached prepareSendEmailRequest - emailConfiguration', 'prepareSendEmailRequest', emailConfiguration);
+      let emailResponse: any = await this.pushEmails(emailConfiguration);
+      Logger.debug('Reached prepareSendEmailRequest - emailResponse END', 'prepareSendEmailRequest', emailResponse);
+      return emailResponse;
+    } catch (error: any) {
+      Logger.error(
+        'EmailHandler: Error in preparing email Request',
+        'prepareEmailRequest',
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   *
+   * @param emailConfiguration
+   * @returns
+   */
+  public async pushEmails(emailConfiguration: any) {
+    Logger.info('Reached pushEmails in emailHandler', 'pushEmails');
+    return await this.sendEmail(emailConfiguration).then(
+      async (response: any) => {
+        if (response?.statusCode === '202' || response.statusCode === 202) {
+          response.msg =
+            'Thanks for getting in touch with us. We shall contact you soon.';
+          return response;
+        } else {
+          Logger.error(
+            'solrResolver: Error in sendEmail resolver',
+            'sendEmail',
+            response
+          );
+          throw new Error('Error Sending in Email');
+        }
+      }
+    );
+  }
+
+  /**
+   * Function to send email with personalize data using sendgrid
+   * @param emailConfig
+   * @returns
+   */
+  public async sendEmailWithPersonalizations(emailConfig: any, email_from?: any) {
+    Logger.info(
+      `EmailHandler: Reached sendEmailWithPersonalizations method with emailConfig: ${JSON.stringify(
+        emailConfig
+      )}`, 'sendEmailWithPersonalizations'
+    );
+    Logger.info(`EMAIL_FROM-------> ${email_from}`, 'sendEmailWithPersonalizations');
+    const Mail = sgHelpers.classes.Mail;
+    // let email_from = isCFF ? config?.CFF_MAIL_FROM : config?.EMAIL_FROM;
+    Logger.info('sendEmailWithPersonalizations : Email From:', JSON.stringify(email_from));
+    const Personalization = sgHelpers.classes.Personalization;
+    const secrets = await getIAMSecrets();
+    sgMail.setApiKey(secrets?.[DynamicValues?.SENDGRID_API_KEY]);
+    const mail = new Mail();
+    mail.setFrom(email_from);
+    mail.setSubject(emailConfig.subject);
+    mail.addTextContent(emailConfig.emailTemplate);
+    mail.addHtmlContent(emailConfig.emailTemplate);
+    // Set personalizations as per the emailConfig
+    if (
+      emailConfig?.personalizations &&
+      emailConfig?.personalizations.to.length
+    ) {
+      const { to, cc } = emailConfig?.personalizations;
+      
+      // Create separate personalization for each TO recipient with their unique substitutions
+      to.forEach((toData: ToWithSubstitutions, index: number) => {
+        const personalization = new Personalization();
+        personalization.addTo(toData.to);
+        
+        // Add CC emails to EACH personalization (CC gets email for each TO recipient)
+        if (cc && cc.length > 0) {
+          cc.forEach((ccData: ToWithSubstitutions) => {
+            personalization.addCc(ccData.to);
+            Logger.info(`Adding CC email ${ccData.to} to personalization ${index + 1} for TO: ${toData.to}`, 'sendEmailWithPersonalizations');
+          });
+        }
+        
+        // Add unique substitutions for each TO recipient
+        if (toData?.substitutions) {
+          for (const key in toData?.substitutions) {
+            if (key) {
+              personalization?.addSubstitution(key, toData?.substitutions[key]);
+            }
+          }
+        }
+        
+        mail.addPersonalization(personalization);
+        Logger.info(`Personalization ${index + 1} created for TO: ${toData.to} with ${cc?.length || 0} CC recipients`, 'sendEmailWithPersonalizations');
+      });
+      
+      // Handle attachments
+      if (emailConfig?.attachments && Array.isArray(emailConfig.attachments)) {
+        emailConfig.attachments.forEach((attachment: any) => {
+          mail.addAttachment({
+            content: attachment.base64,  // base64 string
+            filename: attachment.filename,
+            type: attachment.type || 'application/octet-stream',
+            disposition: 'attachment',
+          });
+        });
+        Logger.info('sendEmailWithPersonalizations: Email Request:', JSON.stringify(emailConfig));
+      }
+    } else {
+      // set to email for non personalized email with CC support
+      const personalization = new Personalization();
+      personalization.addTo(emailConfig.email);
+      
+      // Add CC emails if provided in non-personalized mode
+      if (emailConfig.cc) {
+        const ccEmails = Array.isArray(emailConfig.cc) ? emailConfig.cc : [emailConfig.cc];
+        ccEmails.forEach((ccEmail: string) => {
+          personalization.addCc(ccEmail);
+          Logger.info(`Adding CC email to non-personalized email: ${ccEmail}`, 'sendEmailWithPersonalizations');
+        });
+      }
+      
+      Logger.info('sendEmailWithPersonalizations : Email personalizations:', JSON.stringify(personalization));
+      mail.addPersonalization(personalization);
+    }
+    return new Promise((resolve: any, reject: any) => {
+      sgMail
+        .send(mail)
+        .then((response: any) => {
+          Logger.info(
+            `EmailHandler: Successful Response from sendEmailWithPersonalizations: ${JSON.stringify(
+              response
+            )}`, 'sendEmailWithPersonalizations'
+          );
+          resolve(response[0]);
+        })
+        .catch((error: any) => {
+          Logger.error(
+            `EmailHandler: Error in sendEmailWithPersonalizations: ${JSON.stringify(
+              error
+            )}`,
+            'sendEmail',
+            error
+          );
+          reject(error);
+        });
+    });
+  }
+
+  /**
+   * Utility method to prepare CC emails in standardized format
+   * @param ccEmails - Can be string, array of strings, or Recipients array
+   * @returns Array of email strings
+   */
+  private prepareCCEmails(ccEmails: string | string[] | Recipients[]): string[] {
+    if (!ccEmails) return [];
+    
+    if (typeof ccEmails === 'string') {
+      return [ccEmails];
+    }
+    
+    if (Array.isArray(ccEmails)) {
+      return ccEmails.map((cc: any) => {
+        if (typeof cc === 'string') return cc;
+        if (cc.email) return cc.email; // Recipients object
+        return cc.to || cc; // ToWithSubstitutions object
+      }).filter(email => email && typeof email === 'string');
+    }
+    
+    return [];
+  }
+
+  /**
+   * prepare personalize email request to send email through sendgrid
+   * @param reqBody
+   * @returns
+   */
+  public async sendPersonalizeEmailRequest(reqBody: any) {
+    try {
+      let { email_type, replacement_variables, recipients, cc_recipients, isCFF = config?.EMAIL_FROM, sender_info = {} } = reqBody;
+      Logger.info(
+        `EmailHandler: reached in sendPersonalizeEmailRequest with emailType: ${email_type} and ${isCFF}`, 'sendPersonalizeEmailRequest'
+      );
+      // disable SOLR because of connectivity issue
+      Logger.debug('Reached sendPersonalizeEmailRequest in emailHandler', 'sendPersonalizeEmailRequest');
+      const { name, email,documentpath } = sender_info;
+      let templateData: any = await this.fetchEmailTemplateData(reqBody,documentpath);
+      Logger.debug('Reached sendPersonalizeEmailRequest in emailHandler', 'sendPersonalizeEmailRequest', templateData);
+      let recipientsData = {} as Personalize;
+      if (isArray(recipients)) {
+        const to = [] as unknown as [ToWithSubstitutions];
+        recipients.forEach((recipient: Recipients) => {
+          const substitutions = {
+            ...replacement_variables,
+            recipient_name: recipient?.name,
+          };
+          to.push({
+            to: recipient?.email,
+            substitutions,
+          });
+        });
+        recipientsData = {
+          to,
+        };
+
+         // Add CC recipients if they exist
+      if (cc_recipients && isArray(cc_recipients)) {
+        const cc = [] as unknown as [ToWithSubstitutions];
+        cc_recipients.forEach((ccRecipient: Recipients) => {
+          cc.push({
+            to: ccRecipient?.email,
+          });
+        });
+        recipientsData.cc = cc;
+      }
+      }
+      if (templateData && Object.keys(templateData)?.length !== 0) {
+        const root = HTMLParser.parse(templateData?.body);
+        isCFF = templateData?.email_from && templateData?.email_from !== '' ? templateData?.email_from : isCFF;
+        const emailConfiguration = {
+          email: reqBody.replacement_variables?.EMAIL,
+          emailTemplate: root ? root.toString() : '',
+          subject: templateData?.subject,
+          personalizations: recipientsData,
+          attachments: reqBody?.attachments,
+        };
+        // let is_cff: boolean = (isCFF && isCFF === true) ? true : false;
+        Logger.info(`sendPersonalizeEmailRequest -${JSON.stringify(emailConfiguration)}`, 'sendPersonalizeEmailRequest');
+        const senderFrom = email && name ? { email, name } : isCFF;
+        Logger.info(`sendPersonalizeEmailRequest - senderFrom: ${JSON.stringify(senderFrom)}`, 'sendPersonalizeEmailRequest');
+        return await this.sendEmailWithPersonalizations(emailConfiguration, senderFrom).then(
+          async (response: any) => {
+            if (response.statusCode === 202) {
+              response.msg =
+                'Thanks for getting in touch with us. We shall contact you soon.';
+                Logger.info(`sendPersonalizeEmailRequest - response: ${JSON.stringify(response)}`, 'sendPersonalizeEmailRequest');
+              return response;
+            } else {
+              Logger.error(
+                `EmailHandler: Error in sendEmailWithPersonalizations response - ${JSON.stringify(
+                  response
+                )}`,
+                'sendEmailWithPersonalizations',
+                response
+              );
+              throw new Error('Error Sending in Email');
+            }
+          }
+        );
+      }
+    } catch (error: any) {
+      Logger.error(
+        'EmailHandler: Error in preparing email Request',
+        'prepareEmailRequest',
+        error
+      );
+      throw error;
+    }
+  }
+
+  public async sendPlaceOrderEmail(reqBody: any) {
+    Logger.info('Redached sendPlaceOrderEmail', 'sendPlaceOrderEmail');
+    try {
+      let dataSource = new EmailDataSource();
+      await dataSource.fetchPageModel('orderPlaced');
+
+      const start = moment.tz(reqBody.dateTime, 'UTC'); // original timezone
+      start.tz(reqBody.timezoneOffset).format('Do MMMM YYYY, h:mm a');
+
+      let str = await EmailTemplateHandler.prepareEmailTemplate(reqBody);
+      let root: any = HTMLParser.parse(str);
+      root.querySelector('#1_dynamic_text').textContent = `${reqBody.userName}`;
+      root.querySelector(
+        '#2_dynamic_text'
+      ).textContent = DOMPurify.sanitize(`<b> ${reqBody.total_price} </b>`);
+      root.querySelector(
+        '#3_dynamic_text'
+      ).textContent = DOMPurify.sanitize(`<b>${reqBody.currency_code}</b>`);
+      root.querySelector(
+        '#4_dynamic_text'
+      ).textContent = DOMPurify.sanitize(`<b>${reqBody.shipping_address.streetName} ${reqBody.shipping_address.city} ${reqBody.shipping_address.state}  ${reqBody.shipping_address.country}${reqBody.shipping_address.postalCode} </b>`);
+      root.querySelector(
+        '#5_dynamic_text'
+      ).textContent = DOMPurify.sanitize(`<b>${reqBody.total_tax}</b>`);
+      root.querySelector(
+        '#6_dynamic_text'
+      ).textContent = DOMPurify.sanitize(`<b>${reqBody.orderNumber}</b>`);
+      const apeend: any = root.querySelector('head');
+      apeend.insertAdjacentHTML('beforeend', DOMPurify.sanitize(style));
+
+      let emailConfiguration: any = {
+        email: reqBody.emailTo,
+        emailTemplate: root.toString(),
+        subject: 'Order Confirmation',
+      };
+      let emailResponse: any = await this.pushEmails(emailConfiguration);
+      return emailResponse;
+    } catch (error: any) {
+      Logger.error(
+        'EmailHandler: Error in preparing email Request',
+        'prepareEmailRequest',
+        error
+      );
+      throw error;
+    }
+  }
+  public async sendPlaceOrderEmailv1(reqBody: any) {
+    Logger.info('Redached sendPlaceOrderEmailv1', 'sendPlaceOrderEmailv1');
+    try {
+      let dataSource = new EmailDataSource();
+      await dataSource.fetchPageModel('orderPlaced');
+      const start = moment.tz(reqBody.dateTime, 'UTC'); // original timezone
+      let curentTimeZone = start;
+      curentTimeZone.tz(reqBody.timezoneOffset).format('Do MMMM YYYY, h:mm a');
+      const emailTemplate = path.resolve(__dirname, '../../../templates/orderPlaced.ejs');
+      console.log('>>>>>>>>>>>>>>>>>>>>>>>>>>.',emailTemplate);
+      let billingStr = '';
+      billingStr +=
+        Object.keys(reqBody.billing_address).length !== 0
+          ? `${reqBody.billing_address.street_name}` ||
+          '' + `${reqBody.billing_address.city}` ||
+          '' + `${reqBody.billing_address.state}` ||
+          '' + `${reqBody.billing_address.country}` ||
+          '' + `${reqBody.billing_address.postal_code}` ||
+          ''
+          : '';
+      let shippingStr = '';
+      shippingStr +=
+        Object.keys(reqBody.shipping_address).length !== 0
+          ? `${reqBody.shipping_address.street_name}` ||
+          '' + `${reqBody.shipping_address.city}` ||
+          '' + ` ${reqBody.shipping_address.state}` ||
+          '' + ` ${reqBody.shipping_address.country}` ||
+          '' + `${reqBody.shipping_address.postal_code}` ||
+          ''
+          : '';
+      let templateData = await ejs.renderFile(emailTemplate, {
+        userName: reqBody.userName,
+        orderNumber: reqBody.orderNumber,
+        completeAddressStr: billingStr || shippingStr,
+        total_tax: `${reqBody.total_tax}`,
+        total_price: `${reqBody.total_price}`,
+        data: reqBody.line_item,
+      });
+      if (templateData) {
+        let emailConfiguration: any = {
+          email: reqBody.emailTo,
+          emailTemplate: templateData,
+          subject: 'Order Confirmation',
+        };
+        let emailResponse: any = await this.pushEmails(emailConfiguration);
+        return emailResponse;
+      } else {
+        return 'Error while rendering template';
+      }
+    } catch (error: any) {
+      Logger.error(
+        'EmailHandler: Error in preparing email Request',
+        'prepareEmailRequest',
+        error
+      );
+      throw error;
+    }
+  }
+
+  private async fetchEmailTemplateData(reqBody: any,documentpath?:string) {
+    try {
+      Logger.info('EmailHandler: Reached fetchEmailTemplateData', 'fetchEmailTemplateData');
+      let { email_type } = reqBody;
+      let dataSource = new EmailDataSource();
+      let templateData: any = {};
+      if (config?.MULTISITE_WITH_SOLR === 'true') {
+        let templateSolrRes: any = await dataSource.fetchPageModel(email_type,documentpath);
+        if (templateSolrRes?.length > 0) {
+          templateData.body = templateSolrRes?.[0]?.hclplatformx_Body || '';
+          templateData.subject = templateSolrRes?.[0]?.hclplatformx_Subject || '';
+          templateData.email_from = templateSolrRes?.[0]?.hclplatformx_To || '';
+        }
+      }
+      else {
+        let templateRes: any = await new FormBuilderDao().fetch('email_templates', { name: email_type });
+        templateData.body = templateRes?.[0]?.body;
+        templateData.subject = templateRes?.[0]?.subject;
+        templateData.email_from = templateRes?.[0]?.to || '';
+      }
+      return templateData;
+    } catch (error: any) {
+      Logger.error('EmailHandler: Error in fetchEmailTemplateData', 'fetchEmailTemplateData', error);
+      throw error;
+    }
+  }
+}

package/src/platform-x/util/emailTemplate.ts

@@ -0,0 +1,66 @@
+export class EmailTemplateHandler {
+  constructor() {}
+  public static async prepareEmailTemplate(reqBody: any) {
+    let str = `<!DOCTYPE html>\r\n            
+<html>
+   \r\n                
+   <head>\r\n                </head>
+   \r\n                
+   <body>
+      \r\n                    
+      <div>
+         \r\n                        
+         <div class=\"main_div\">
+            \r\n                            
+            <table>
+               \r\n                                
+               <tr>
+                  \r\n                                    
+                  <td>
+                     \r\n                                        
+                     <div class=\"table_div\">
+                        \r\n                                            
+                        <table class=\"table_2\">
+                           \r\n                                                
+                           <tr>
+                              \r\n                                                    
+                              <td valign=\"top\" class=\"w-400\">\r\n                                                        <img\r\n                                                            src=\"https://storage.googleapis.com/platx/dev/Setting/platform-x-logo-color%402x.png\"\r\n                                                            alt=\"logo\"\r\n                                                            class=\"w_h_30\"\r\n                                                        />\r\n                                                    </td>
+                              \r\n                                                
+                           </tr>
+                           \r\n                                            
+                        </table>
+                        \r\n                                            
+                        <p class=\"username\">Hi <span id=\"1_dynamic_text\">{{username}}</span>,</p>
+                        \r\n                                            
+                        <p class=\"main_text\">Your order <span id=\"6_dynamic_text\"><b>{{ordernumber}}</b></span> has been successfully placed for amount <span id=\"2_dynamic_text\"><b>{{totalAmt}}</b></span><span id=\"3_dynamic_text\"><b>{{currency}}</b></span>.</p>
+                        \r\n 
+                        <p class=\"main_text\">Address Details<span id=\"4_dynamic_text\"><b>{{addressStr}}</b></span></p>                                           
+                        \r\n    
+                        <p class=\"main_text\">Calculated Tax on your order is <span id=\"5_dynamic_text\"><b>{{totaltax}}</b></span>                                    
+                        <div class=\"border\">
+                        </div>
+                        \r\n                                            
+                        <div>
+                           \r\n                                                
+                           <p class=\"sub_text\">This emailer is copyright to Platform-X. All rights reserved.</p>
+                           \r\n                                            
+                        </div>
+                        \r\n                                        
+                     </div>
+                     \r\n                                    
+                  </td>
+                  \r\n                                
+               </tr>
+               \r\n                            
+            </table>
+            \r\n                        
+         </div>
+         \r\n                    
+      </div>
+      \r\n                
+   </body>
+   \r\n            
+</html>`;
+    return str;
+  }
+}