@capillarytech/creatives-library 8.0.148 → 8.0.149

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@capillarytech/creatives-library",
   "author": "meharaj",
-  "version": "8.0.148",
+  "version": "8.0.149",
   "description": "Capillary creatives ui",
   "main": "./index.js",
   "module": "./index.es.js",

package/utils/tests/transformerUtils.test.js

@@ -11,7 +11,10 @@ import {
   MOBILE_PUSH,
   WHATSAPP,
   PUSH,
-  ZALO
+  ZALO,
+  RCS,
+  LINE,
+  VIBER,
 } from "../../v2Containers/CreativesContainer/constants";
 
 describe("transformerUtils", () => {
@@ -819,6 +822,366 @@ describe("transformerUtils", () => {
     });
   });
 
+  describe("RCS payload transformation", () => {
+    it("should transform RCS data with all options", () => {
+      const mockData = {
+        channel: RCS,
+        messageBody: "test rcs message",
+        accountId: "rcs-account-123",
+        accountName: "RCS Official Account",
+        templateConfigs: {
+          id: "template-789",
+          name: "notification_template",
+          template: "https://example.com/rcs-template",
+          varMapped: {
+            customer: "Mike Johnson",
+            notification: "Important Update",
+            urgency: "HIGH"
+          }
+        }
+      };
+
+      const options = {
+        loyaltyMetaData: {
+          actionId: "action-123",
+          ouId: 456,
+          clientName: "TestClient",
+          module: "TestModule",
+          transformedMessageDetails: {
+            rcsDeliverySettings: {
+              sendDate: "2023-01-01",
+              priority: "URGENT"
+            }
+          }
+        }
+      };
+
+      const result = transformChannelPayload(mockData, options);
+
+      // Check base payload
+      expect(result.centralCommsPayload.sourceEntityId).toEqual("action-123");
+      expect(result.centralCommsPayload.ouId).toEqual(456);
+      expect(result.centralCommsPayload.clientName).toEqual("TestClient");
+      expect(result.centralCommsPayload.module).toEqual("TestModule");
+      // Check RCS-specific content
+      expect(result.centralCommsPayload.rcsMessageContent.messageBody).toEqual(
+        "test rcs message"
+      );
+      expect(result.centralCommsPayload.rcsMessageContent.accountId).toEqual(
+        "rcs-account-123"
+      );
+      expect(result.centralCommsPayload.rcsMessageContent.accountName).toEqual(
+        "RCS Official Account"
+      );
+      // Check template configs
+      expect(
+        result.centralCommsPayload.rcsMessageContent.templateConfigs.id
+      ).toEqual("template-789");
+      expect(
+        result.centralCommsPayload.rcsMessageContent.templateConfigs.name
+      ).toEqual("notification_template");
+      expect(
+        result.centralCommsPayload.rcsMessageContent.templateConfigs.template
+      ).toEqual("https://example.com/rcs-template");
+      expect(
+        result.centralCommsPayload.rcsMessageContent.templateConfigs.varMapped
+      ).toEqual({
+        customer: "Mike Johnson",
+        notification: "Important Update",
+        urgency: "HIGH"
+      });
+      // Check delivery settings
+      expect(result.centralCommsPayload.rcsDeliverySettings).toEqual({
+        sendDate: "2023-01-01",
+        priority: "URGENT"
+      });
+    });
+
+    it("should handle missing template configs", () => {
+      const mockData = {
+        channel: RCS,
+        messageBody: "test rcs message"
+      };
+
+      const result = transformChannelPayload(mockData);
+
+      expect(
+        result.centralCommsPayload.rcsMessageContent.templateConfigs
+      ).toEqual({});
+    });
+
+    it("should handle undefined rcsDeliverySettings", () => {
+      const mockData = {
+        channel: RCS,
+        messageBody: "test rcs message"
+      };
+
+      const options = {
+        loyaltyMetaData: {
+          transformedMessageDetails: {}
+        }
+      };
+
+      const result = transformChannelPayload(mockData, options);
+
+      expect(result.centralCommsPayload.rcsDeliverySettings).toEqual({});
+    });
+
+    it("should initialize default values when fields are missing", () => {
+      const mockData = {
+        channel: RCS
+      };
+
+      const result = transformChannelPayload(mockData);
+
+      expect(result.centralCommsPayload.rcsMessageContent.messageBody).toEqual(
+        ""
+      );
+      expect(result.centralCommsPayload.rcsMessageContent.accountId).toEqual(
+        ""
+      );
+      expect(result.centralCommsPayload.rcsMessageContent.accountName).toEqual(
+        ""
+      );
+    });
+  });
+
+  describe("LINE payload transformation", () => {
+    it("should transform LINE data correctly with minimal data", () => {
+      const mockData = {
+        channel: LINE,
+        messageBody: "test line message"
+      };
+
+      const result = transformChannelPayload(mockData);
+
+      expect(result.centralCommsPayload).toBeDefined();
+      expect(result.centralCommsPayload.channel).toEqual(LINE);
+      expect(result.centralCommsPayload.lineMessageContent.messageBody).toEqual(
+        "test line message"
+      );
+      expect(result.centralCommsPayload.clientName).toEqual("VENENO");
+    });
+
+    it("should transform LINE data with all options", () => {
+      const mockData = {
+        channel: LINE,
+        messageBody: "test line message",
+        accountId: 12345,
+        accountDetails: "LINE Official Account Details"
+      };
+
+      const options = {
+        loyaltyMetaData: {
+          actionId: "action-123",
+          ouId: 456,
+          clientName: "TestClient",
+          module: "TestModule",
+          transformedMessageDetails: {
+            lineDeliverySettings: {
+              sendDate: "2023-01-01",
+              priority: "NORMAL"
+            }
+          }
+        }
+      };
+
+      const result = transformChannelPayload(mockData, options);
+
+      // Check base payload
+      expect(result.centralCommsPayload.sourceEntityId).toEqual("action-123");
+      expect(result.centralCommsPayload.ouId).toEqual(456);
+      expect(result.centralCommsPayload.clientName).toEqual("TestClient");
+      expect(result.centralCommsPayload.module).toEqual("TestModule");
+
+      // Check LINE-specific content
+      expect(result.centralCommsPayload.lineMessageContent.messageBody).toEqual(
+        "test line message"
+      );
+      expect(result.centralCommsPayload.lineMessageContent.accountId).toEqual(12345);
+      expect(result.centralCommsPayload.lineMessageContent.accountDetails).toEqual(
+        "LINE Official Account Details"
+      );
+
+      // Check delivery settings
+      expect(result.centralCommsPayload.lineDeliverySettings).toEqual({
+        sendDate: "2023-01-01",
+        priority: "NORMAL"
+      });
+    });
+
+    it("should handle undefined lineDeliverySettings", () => {
+      const mockData = {
+        channel: LINE,
+        messageBody: "test line message"
+      };
+
+      const options = {
+        loyaltyMetaData: {
+          transformedMessageDetails: {}
+        }
+      };
+
+      const result = transformChannelPayload(mockData, options);
+
+      expect(result.centralCommsPayload.lineDeliverySettings).toEqual({});
+    });
+
+    it("should initialize default values when fields are missing", () => {
+      const mockData = {
+        channel: LINE
+      };
+
+      const result = transformChannelPayload(mockData);
+
+      expect(result.centralCommsPayload.lineMessageContent.messageBody).toEqual(
+        ""
+      );
+      expect(result.centralCommsPayload.lineMessageContent.accountId).toEqual(0);
+      expect(result.centralCommsPayload.lineMessageContent.accountDetails).toEqual(
+        ""
+      );
+    });
+
+    it("should preserve all original LINE data properties", () => {
+      const mockData = {
+        channel: LINE,
+        messageBody: "test line message",
+        accountId: 12345,
+        accountDetails: "LINE Official Account Details",
+        customField1: "custom value 1",
+        customField2: "custom value 2"
+      };
+
+      const result = transformChannelPayload(mockData);
+
+      expect(result.centralCommsPayload.lineMessageContent.customField1).toEqual(
+        "custom value 1"
+      );
+      expect(result.centralCommsPayload.lineMessageContent.customField2).toEqual(
+        "custom value 2"
+      );
+    });
+  });
+
+  describe("VIBER payload transformation", () => {
+    it("should transform VIBER data correctly with minimal data", () => {
+      const mockData = {
+        channel: VIBER,
+        messageBody: "test viber message"
+      };
+
+      const result = transformChannelPayload(mockData);
+
+      expect(result.centralCommsPayload).toBeDefined();
+      expect(result.centralCommsPayload.channel).toEqual(VIBER);
+      expect(result.centralCommsPayload.viberMessageContent.messageBody).toEqual(
+        "test viber message"
+      );
+      expect(result.centralCommsPayload.clientName).toEqual("VENENO");
+    });
+
+    it("should transform VIBER data with all options", () => {
+      const mockData = {
+        channel: VIBER,
+        messageBody: "test viber message",
+        accountId: 67890,
+        accountDetails: "VIBER Official Account Details"
+      };
+
+      const options = {
+        loyaltyMetaData: {
+          actionId: "action-123",
+          ouId: 456,
+          clientName: "TestClient",
+          module: "TestModule",
+          transformedMessageDetails: {
+            viberDeliverySettings: {
+              sendDate: "2023-01-01",
+              priority: "HIGH"
+            }
+          }
+        }
+      };
+
+      const result = transformChannelPayload(mockData, options);
+
+      // Check base payload
+      expect(result.centralCommsPayload.sourceEntityId).toEqual("action-123");
+      expect(result.centralCommsPayload.ouId).toEqual(456);
+      expect(result.centralCommsPayload.clientName).toEqual("TestClient");
+      expect(result.centralCommsPayload.module).toEqual("TestModule");
+
+      // Check VIBER-specific content
+      expect(result.centralCommsPayload.viberMessageContent.messageBody).toEqual(
+        "test viber message"
+      );
+      expect(result.centralCommsPayload.viberMessageContent.accountId).toEqual(67890);
+      expect(result.centralCommsPayload.viberMessageContent.accountDetails).toEqual(
+        "VIBER Official Account Details"
+      );
+
+      // Check delivery settings
+      expect(result.centralCommsPayload.viberDeliverySettings).toEqual({
+        sendDate: "2023-01-01",
+        priority: "HIGH"
+      });
+    });
+
+    it("should handle undefined viberDeliverySettings", () => {
+      const mockData = {
+        channel: VIBER,
+        messageBody: "test viber message"
+      };
+
+      const options = {
+        loyaltyMetaData: {
+          transformedMessageDetails: {}
+        }
+      };
+
+      const result = transformChannelPayload(mockData, options);
+
+      expect(result.centralCommsPayload.viberDeliverySettings).toEqual({});
+    });
+
+    it("should initialize default values when fields are missing", () => {
+      const mockData = {
+        channel: VIBER
+      };
+
+      const result = transformChannelPayload(mockData);
+
+      expect(result.centralCommsPayload.viberMessageContent.messageBody).toEqual(
+        ""
+      );
+      expect(result.centralCommsPayload.viberMessageContent.accountId).toEqual(0);
+      expect(result.centralCommsPayload.viberMessageContent.accountDetails).toEqual(
+        ""
+      );
+    });
+
+    it("should preserve all original VIBER data properties", () => {
+      const mockData = {
+        channel: VIBER,
+        messageBody: "test viber message",
+        accountId: 67890,
+        accountDetails: "VIBER Official Account Details",
+        customField1: "custom value 1",
+        customField2: "custom value 2"
+      };
+
+      const result = transformChannelPayload(mockData);
+
+      expect(result.centralCommsPayload.viberMessageContent.customField1).toEqual(
+        "custom value 1"
+      );
+      expect(result.centralCommsPayload.viberMessageContent.customField2).toEqual(
+        "custom value 2"
+      );
+    });
+  });
+
   describe("getTemplateDiffState", () => {
     it("should return false for unsupported channel", () => {
       const result = getTemplateDiffState("UNSUPPORTED_CHANNEL", {}, {});
@@ -2124,4 +2487,501 @@ describe("transformerUtils", () => {
       ).toBe(true);
     });
   });
+
+  describe("LINE template diff checking", () => {
+    it("should detect changes in message content", () => {
+      const oldData = {
+        transformedMessageDetails: {
+          lineMessageContent: {
+            messageBody: "old line message",
+            accountId: "same-account",
+            accountDetails: "same-details",
+          },
+        },
+      };
+
+      const newData = {
+        messageBody: "new line message",
+        accountId: "same-account",
+        accountDetails: "same-details",
+      };
+
+      const result = getTemplateDiffState(LINE, oldData, newData);
+
+      expect(result).toBe(true);
+    });
+
+    it("should detect changes in accountId", () => {
+      const oldData = {
+        transformedMessageDetails: {
+          lineMessageContent: {
+            messageBody: "same line message",
+            accountId: "old-account-123",
+            accountDetails: "same-details",
+          },
+        },
+      };
+
+      const newData = {
+        messageBody: "same line message",
+        accountId: "new-account-123",
+        accountDetails: "same-details",
+      };
+
+      const result = getTemplateDiffState(LINE, oldData, newData);
+
+      expect(result).toBe(true);
+    });
+
+    it("should detect changes in accountDetails", () => {
+      const oldData = {
+        transformedMessageDetails: {
+          lineMessageContent: {
+            messageBody: "same line message",
+            accountId: "same-account",
+            accountDetails: "old-account-details",
+          },
+        },
+      };
+
+      const newData = {
+        messageBody: "same line message",
+        accountId: "same-account",
+        accountDetails: "new-account-details",
+      };
+
+      const result = getTemplateDiffState(LINE, oldData, newData);
+
+      expect(result).toBe(true);
+    });
+
+    it("should return false when LINE content is the same", () => {
+      const oldData = {
+        transformedMessageDetails: {
+          lineMessageContent: {
+            messageBody: "same line message",
+            accountId: "same-account",
+            accountDetails: "same-details",
+          },
+        },
+      };
+
+      const newData = {
+        messageBody: "same line message",
+        accountId: "same-account",
+        accountDetails: "same-details",
+      };
+
+      const result = getTemplateDiffState(LINE, oldData, newData);
+
+      expect(result).toBe(false);
+    });
+
+    it("should detect actual changes despite type differences", () => {
+      const oldData = {
+        transformedMessageDetails: {
+          lineMessageContent: {
+            messageBody: "same message",
+            accountId: 12345,
+            accountDetails: "same details",
+          },
+        },
+      };
+
+      const newData = {
+        messageBody: "same message",
+        accountId: "12346",
+        accountDetails: "same details",
+      };
+
+      // Should return true because "12345" !== "12346"
+      const result = getTemplateDiffState(LINE, oldData, newData);
+
+      expect(result).toBe(true);
+    });
+
+    it("should handle undefined/null values gracefully", () => {
+      // Both values undefined
+      expect(
+        getTemplateDiffState(
+          LINE,
+          { transformedMessageDetails: { lineMessageContent: {} } },
+          {}
+        )
+      ).toBe(false);
+
+      // Old value undefined, new value defined
+      expect(
+        getTemplateDiffState(
+          LINE,
+          { transformedMessageDetails: { lineMessageContent: {} } },
+          { messageBody: "new message" }
+        )
+      ).toBe(true);
+
+      // Old value defined, new value undefined
+      expect(
+        getTemplateDiffState(
+          LINE,
+          {
+            transformedMessageDetails: {
+              lineMessageContent: { messageBody: "old message" }
+            }
+          },
+          {}
+        )
+      ).toBe(true);
+    });
+  });
+
+  describe("VIBER template diff checking", () => {
+    it("should detect changes in message content", () => {
+      const oldData = {
+        transformedMessageDetails: {
+          viberMessageContent: {
+            messageBody: "old viber message",
+            accountId: "same-account",
+            accountDetails: "same-details",
+          },
+        },
+      };
+
+      const newData = {
+        messageBody: "new viber message",
+        accountId: "same-account",
+        accountDetails: "same-details",
+      };
+
+      const result = getTemplateDiffState(VIBER, oldData, newData);
+
+      expect(result).toBe(true);
+    });
+
+    it("should detect changes in accountId", () => {
+      const oldData = {
+        transformedMessageDetails: {
+          viberMessageContent: {
+            messageBody: "same viber message",
+            accountId: "old-account-123",
+            accountDetails: "same-details",
+          },
+        },
+      };
+
+      const newData = {
+        messageBody: "same viber message",
+        accountId: "new-account-123",
+        accountDetails: "same-details",
+      };
+
+      const result = getTemplateDiffState(VIBER, oldData, newData);
+
+      expect(result).toBe(true);
+    });
+
+    it("should detect changes in accountDetails", () => {
+      const oldData = {
+        transformedMessageDetails: {
+          viberMessageContent: {
+            messageBody: "same viber message",
+            accountId: "same-account",
+            accountDetails: "old-account-details",
+          },
+        },
+      };
+
+      const newData = {
+        messageBody: "same viber message",
+        accountId: "same-account",
+        accountDetails: "new-account-details",
+      };
+
+      const result = getTemplateDiffState(VIBER, oldData, newData);
+
+      expect(result).toBe(true);
+    });
+
+    it("should return false when VIBER content is the same", () => {
+      const oldData = {
+        transformedMessageDetails: {
+          viberMessageContent: {
+            messageBody: "same viber message",
+            accountId: "same-account",
+            accountDetails: "same-details",
+          },
+        },
+      };
+
+      const newData = {
+        messageBody: "same viber message",
+        accountId: "same-account",
+        accountDetails: "same-details",
+      };
+
+      const result = getTemplateDiffState(VIBER, oldData, newData);
+
+      expect(result).toBe(false);
+    });
+
+    it("should detect actual changes despite type differences", () => {
+      const oldData = {
+        transformedMessageDetails: {
+          viberMessageContent: {
+            messageBody: "same message",
+            accountId: 67890,
+            accountDetails: "same details",
+          },
+        },
+      };
+
+      const newData = {
+        messageBody: "same message",
+        accountId: "67891",
+        accountDetails: "same details",
+      };
+
+      // Should return true because "67890" !== "67891"
+      const result = getTemplateDiffState(VIBER, oldData, newData);
+
+      expect(result).toBe(true);
+    });
+
+    it("should handle undefined/null values gracefully", () => {
+      // Both values undefined
+      expect(
+        getTemplateDiffState(
+          VIBER,
+          { transformedMessageDetails: { viberMessageContent: {} } },
+          {}
+        )
+      ).toBe(false);
+
+      // Old value undefined, new value defined
+      expect(
+        getTemplateDiffState(
+          VIBER,
+          { transformedMessageDetails: { viberMessageContent: {} } },
+          { messageBody: "new message" }
+        )
+      ).toBe(true);
+
+      // Old value defined, new value undefined
+      expect(
+        getTemplateDiffState(
+          VIBER,
+          {
+            transformedMessageDetails: {
+              viberMessageContent: { messageBody: "old message" }
+            }
+          },
+          {}
+        )
+      ).toBe(true);
+    });
+  });
+
+  describe("RCS template diff checking", () => {
+    it("should detect changes in accountId", () => {
+      const oldData = {
+        transformedMessageDetails: {
+          rcsMessageContent: {
+            accountId: "old-account-123",
+            accountName: "same-account-name",
+            templateConfigs: {
+              id: "same-template-123",
+              name: "same_template_name",
+              template: "same_template_content",
+              varMapped: { customer: "John" },
+            },
+          },
+        },
+      };
+
+      const newData = {
+        accountId: "new-account-123",
+        accountName: "same-account-name",
+        templateConfigs: {
+          id: "same-template-123",
+          name: "same_template_name",
+          template: "same_template_content",
+          varMapped: { customer: "John" },
+        },
+      };
+
+      const result = getTemplateDiffState(RCS, oldData, newData);
+
+      expect(result).toBe(true);
+    });
+
+    it("should detect changes in accountName", () => {
+      const oldData = {
+        transformedMessageDetails: {
+          rcsMessageContent: {
+            accountId: "same-account",
+            accountName: "old-account-name",
+            templateConfigs: {
+              id: "same-template-123",
+              name: "same_template_name",
+              template: "same_template_content",
+              varMapped: { customer: "John" },
+            },
+          },
+        },
+      };
+
+      const newData = {
+        accountId: "same-account",
+        accountName: "new-account-name",
+        templateConfigs: {
+          id: "same-template-123",
+          name: "same_template_name",
+          template: "same_template_content",
+          varMapped: { customer: "John" },
+        },
+      };
+
+      const result = getTemplateDiffState(RCS, oldData, newData);
+
+      expect(result).toBe(true);
+    });
+
+    it("should detect changes in template configs structure", () => {
+      const oldData = {
+        transformedMessageDetails: {
+          rcsMessageContent: {
+            accountId: "same-account",
+            accountName: "same-account-name",
+            templateConfigs: {
+              id: "same-template-123",
+              name: "same_template_name",
+              // Missing template and varMapped properties
+            },
+          },
+        },
+      };
+
+      const newData = {
+        accountId: "same-account",
+        accountName: "same-account-name",
+        templateConfigs: {
+          id: "same-template-123",
+          name: "same_template_name",
+          template: "same_template_content",
+          varMapped: { customer: "John" },
+        },
+      };
+
+      const result = getTemplateDiffState(RCS, oldData, newData);
+
+      expect(result).toBe(true);
+    });
+
+    it("should detect changes in account details", () => {
+      const oldData = {
+        transformedMessageDetails: {
+          rcsMessageContent: {
+            accountId: "old-account-123",
+            accountName: "old-account-name",
+            templateConfigs: {
+              id: "same-template-123",
+              name: "same_template_name",
+              template: "same_template_content",
+              varMapped: { customer: "John" },
+            },
+          },
+        },
+      };
+
+      const newData = {
+        accountId: "new-account-123",
+        accountName: "new-account-name",
+        templateConfigs: {
+          id: "same-template-123",
+          name: "same_template_name",
+          template: "same_template_content",
+          varMapped: { customer: "John" },
+        },
+      };
+
+      const result = getTemplateDiffState("RCS", oldData, newData);
+
+      expect(result).toBe(true);
+    });
+
+    it("should return false when RCS content is the same", () => {
+      const oldData = {
+        transformedMessageDetails: {
+          rcsMessageContent: {
+            accountId: "same-account",
+            accountName: "same-account-name",
+            templateConfigs: {
+              id: "same-template-123",
+              name: "same_template_name",
+              template: "same_template_content",
+              varMapped: { customer: "John" },
+            },
+          },
+        },
+      };
+
+      const newData = {
+        accountId: "same-account",
+        accountName: "same-account-name",
+        templateConfigs: {
+          id: "same-template-123",
+          name: "same_template_name",
+          template: "same_template_content",
+          varMapped: { customer: "John" },
+        },
+      };
+
+      const result = getTemplateDiffState(RCS, oldData, newData);
+
+      expect(result).toBe(false);
+    });
+
+    it("should handle missing transformedMessageDetails with default values", () => {
+      const oldData = {
+        // Missing transformedMessageDetails completely
+      };
+
+      const newData = {
+        accountId: "new-account",
+        accountName: "new-account-name",
+        templateConfigs: {
+          id: "template-123",
+          name: "template_name",
+        },
+      };
+
+      // This should trigger default value assignments in destructuring
+      const result = getTemplateDiffState(RCS, oldData, newData);
+
+      // Should return true because oldData has no rcsMessageContent
+      expect(result).toBe(true);
+    });
+
+    it("should handle empty newData with default values", () => {
+      const oldData = {
+        transformedMessageDetails: {
+          rcsMessageContent: {
+            accountId: "old-account",
+            accountName: "old-account-name",
+            templateConfigs: {
+              id: "template-123",
+              name: "template_name",
+            },
+          },
+        },
+      };
+
+      const newData = null;
+
+      // This should trigger default value assignments in destructuring for newData
+      const result = getTemplateDiffState(RCS, oldData, newData);
+
+      // Should return true because newData is null
+      expect(result).toBe(true);
+    });
+  });
 });

package/utils/transformerUtils.js

@@ -7,6 +7,9 @@ import {
   WHATSAPP,
   PUSH,
   ZALO,
+  RCS,
+  LINE,
+  VIBER,
   EMF,
   VENENO,
   TEXT,
@@ -54,6 +57,12 @@ export const transformChannelPayload = (data, options = {}) => {
       return transformWhatsappPayload(data, options);
     case ZALO:
       return transformZaloPayload(data, options);
+    case RCS:
+      return transformRcsPayload(data, options);
+    case LINE:
+      return transformLinePayload(data, options);
+    case VIBER:
+      return transformViberPayload(data, options);
     default:
       return data; // Return unchanged for unsupported channels
   }
@@ -231,6 +240,83 @@ const transformZaloPayload = (zaloData, options = {}) => {
   return payload;
 };
 
+/**
+ * Transforms RCS data to the required payload format
+ * @param {Object} rcsData - Current RCS data
+ * @param {Object} options - Additional options (ouId, sourceEntityId, etc.)
+ * @returns {Object} - Transformed RCS payload
+ */
+// TODO: RCS is currently not supported by the CCS - BE. We need to make changes in future as per the BE changes.
+const transformRcsPayload = (rcsData, options = {}) => {
+  const { loyaltyMetaData = {} } = options;
+  const { transformedMessageDetails = {} } = loyaltyMetaData;
+  const { rcsDeliverySettings = {} } = transformedMessageDetails || {};
+
+  // Get base payload structure
+  const payload = createBasePayload(RCS, loyaltyMetaData);
+
+  // Add RCS-specific properties
+  payload.centralCommsPayload.rcsMessageContent = {
+    channel: RCS,
+    messageBody: "",
+    accountId: rcsData?.accountId || "",
+    accountName: rcsData?.accountName || "",
+    ...rcsData,
+    // Ensure templateConfigs is preserved (it might contain complex nested objects)
+    templateConfigs: rcsData?.templateConfigs || {},
+  };
+  payload.centralCommsPayload.rcsDeliverySettings = rcsDeliverySettings;
+
+  return payload;
+};
+
+/**
+ * Transforms LINE data to the required payload format
+ * @param {Object} lineData - Current LINE data
+ * @param {Object} options - Additional options (ouId, sourceEntityId, etc.)
+ * @returns {Object} - Transformed LINE payload
+ */
+const transformLinePayload = (lineData, options = {}) => {
+  const { loyaltyMetaData = {} } = options;
+  const { transformedMessageDetails = {} } = loyaltyMetaData;
+  const { lineDeliverySettings = {} } = transformedMessageDetails || {};
+
+  // Get base payload structure
+  const payload = createBasePayload(LINE, loyaltyMetaData);
+  payload.centralCommsPayload.lineMessageContent = {
+    channel: LINE,
+    accountId: lineData?.accountId || 0,
+    accountDetails: lineData?.accountDetails || "",
+    messageBody: lineData?.messageBody || "",
+    ...lineData,
+  };
+  payload.centralCommsPayload.lineDeliverySettings = lineDeliverySettings;
+  return payload;
+};
+
+/**
+ * Transforms VIBER data to the required payload format
+ * @param {Object} viberData - Current VIBER data
+ * @param {Object} options - Additional options (ouId, sourceEntityId, etc.)
+ * @returns {Object} - Transformed VIBER payload
+ */
+const transformViberPayload = (viberData, options = {}) => {
+  const { loyaltyMetaData = {} } = options;
+  const { transformedMessageDetails = {} } = loyaltyMetaData;
+  const { viberDeliverySettings = {} } = transformedMessageDetails || {};
+  // Get base payload structure
+  const payload = createBasePayload(VIBER, loyaltyMetaData);
+  payload.centralCommsPayload.viberMessageContent = {
+    channel: VIBER,
+    accountId: viberData?.accountId || 0,
+    accountDetails: viberData?.accountDetails || "",
+    messageBody: viberData?.messageBody || "",
+    ...viberData,
+  };
+  payload.centralCommsPayload.viberDeliverySettings = viberDeliverySettings;
+  return payload;
+};
+
 // Checks if the template has changed
 export const getTemplateDiffState = (channel, oldData, newData) => {
   switch (channel.toUpperCase()) {
@@ -245,6 +331,13 @@ export const getTemplateDiffState = (channel, oldData, newData) => {
       return checkWhatsappDiff(oldData, newData);
     case ZALO:
       return checkZaloDiff(oldData, newData);
+    case LINE:
+      return checkLineDiff(oldData, newData);
+    case VIBER:
+      return checkViberDiff(oldData, newData);
+    // TODO: RCS is currently not supported by the CCS - BE. We need to make changes in future as per the BE changes.
+    case RCS:
+      return checkRcsDiff(oldData, newData);
     default:
       return false;
   }
@@ -418,3 +511,78 @@ const checkZaloDiff = (oldData, newData) => {
   // Use deep comparison for template configs
   return !isEqual(oldTemplateConfigs, newTemplateConfigs);
 };
+
+/**
+ * Checks differences between old and new RCS data
+ * @param {Object} oldData - Previous RCS template data
+ * @param {Object} newData - Updated RCS template data
+ * @returns {Boolean} - Whether the template has changed
+ */
+// TODO: RCS is currently not supported by the CCS - BE. We need to make changes in future as per the BE changes.
+const checkRcsDiff = (oldData, newData) => {
+  // Extract old RCS content
+  const { templateConfigs: oldTemplateConfigs = {}, accountId: oldAccountId = "", accountName: oldAccountName = "" } = 
+    oldData?.transformedMessageDetails?.rcsMessageContent || {};
+
+  // Extract new RCS content
+  const { templateConfigs: newTemplateConfigs = {}, accountId: newAccountId = "", accountName: newAccountName = "" } = newData || {};
+
+  // Compare simple properties for quick rejection
+  if (oldAccountId !== newAccountId) return true;
+  if (oldAccountName !== newAccountName) return true;
+
+  // If template configs have different structures, they've changed
+  if (
+    Object.keys(newTemplateConfigs)?.length
+    !== Object.keys(oldTemplateConfigs)?.length
+  ) {
+    return true;
+  }
+
+  // Use deep comparison for template configs
+  return !isEqual(oldTemplateConfigs, newTemplateConfigs);
+};
+
+/**
+ * Checks differences between old and new LINE data
+ * @param {Object} oldData - Previous LINE template data
+ * @param {Object} newData - Updated LINE template data
+ * @returns {Boolean} - Whether the template has changed
+ */
+const checkLineDiff = (oldData, newData) => {
+  // Extract old LINE content
+  const { messageBody: oldMessageBody = "", accountId: oldAccountId = "", accountDetails: oldAccountDetails = "" } = 
+    oldData?.transformedMessageDetails?.lineMessageContent || {};
+
+  // Extract new LINE content
+  const { messageBody: newMessageBody = "", accountId: newAccountId = "", accountDetails: newAccountDetails = "" } = newData || {};
+
+  // Compare simple properties for quick rejection
+  if (oldMessageBody !== newMessageBody) return true;
+  if (oldAccountId !== newAccountId) return true;
+  if (oldAccountDetails !== newAccountDetails) return true;
+
+  return false;
+};
+
+/**
+ * Checks differences between old and new VIBER data
+ * @param {Object} oldData - Previous VIBER template data
+ * @param {Object} newData - Updated VIBER template data
+ * @returns {Boolean} - Whether the template has changed
+ */
+const checkViberDiff = (oldData, newData) => {
+  // Extract old VIBER content
+  const { messageBody: oldMessageBody = "", accountId: oldAccountId = "", accountDetails: oldAccountDetails = "" } = 
+    oldData?.transformedMessageDetails?.viberMessageContent || {};
+
+  // Extract new VIBER content
+  const { messageBody: newMessageBody = "", accountId: newAccountId = "", accountDetails: newAccountDetails = "" } = newData || {};
+
+  // Compare simple properties for quick rejection
+  if (oldMessageBody !== newMessageBody) return true;
+  if (oldAccountId !== newAccountId) return true;
+  if (oldAccountDetails !== newAccountDetails) return true;
+
+  return false;
+};