Multi-contact arrangement method based on easy-flow process designer and message sending system

Abstract

The invention provides a multi-contact arrangement method based on an easy-flow process designer and a message sending system, and belongs to the technical field of workflow arrangement. According to the method, a user creates a contact arrangement process which comprises process definition and process node configuration; the arrangement process at least comprises a contact node and an execution control node, and the process definition comprises starting time, ending time, a client base and a trigger type; starting an arrangement process, obtaining a next node id of a starting node in the arrangement process, reading node information of a first contact according to the id, packaging the node information into a task, decomposing the task, and selecting a corresponding interface according to a contact type to send a message to a user terminal; continuing to traverse the next node until the execution of all nodes is completed; and performing real-time statistics on contact sending results through flink streaming calculation, storing the contact sending results into an event block, and updating the contact sending results into connecting lines among the flow nodes. According to the invention, automatic configuration of a complex scene and multi-dimensional interaction with clients can be effectively realized, a target client group of an enterprise is comprehensively reached, and the operation cost is reduced.

Description

Technical Field

[0001] This invention belongs to the field of workflow orchestration technology, specifically relating to a multi-touchpoint orchestration method and message sending system based on the easy-flow workflow designer. Background Technology

[0002] In existing technologies, enterprise marketing campaigns typically rely on multi-channel, multi-touchpoint customer communication strategies. However, the fragmentation between channels and the difficulty in unifying process orchestration lead to low customer outreach efficiency and inconsistent experiences. Traditional messaging systems lack support for dynamic combination of multiple strategies and automated scenario adaptation, making it difficult to personalize content delivery based on real-time user behavior and tag changes, thus limiting the effectiveness of precision marketing. Furthermore, cumbersome data access and user segmentation processes, coupled with insufficient cross-channel touchpoint collaboration capabilities, hinder enterprises from building agile, data-driven digital marketing systems. Therefore, there is an urgent need for an integrated messaging service platform that can integrate multi-touchpoint processes, support dynamic strategy orchestration, and enable real-time intelligent outreach to improve operational efficiency and overall marketing automation. Summary of the Invention

[0003] This invention addresses the shortcomings of existing technologies by providing a multi-touchpoint orchestration method and message sending system based on the easy-flow workflow designer. The purpose of this invention is to solve the problems of scattered message touchpoints, ineffective touchpoint management, and inefficient touchpoint orchestration in enterprises. It aims to achieve automated configuration of complex scenarios and multi-dimensional interaction with customers, comprehensively reaching the enterprise's target customer base and reducing operating costs. Therefore, this invention uses a drag-and-drop approach to flexibly create orchestration processes, helping businesses quickly build complex marketing scenarios. The message sending system integrates different touchpoint channel capabilities and, through the design of a message sending processor, achieves automatic adaptation of multi-touchpoint tasks and touchpoint message sending functions, improving message sending efficiency and scalability.

[0004] To achieve the above objectives, the present invention adopts the following technical solution: In a first aspect, the present invention provides a multi-touchpoint orchestration method based on the easy-flow process designer, comprising the following steps: Step S1: The user creates a touchpoint orchestration process, including process definition and process node configuration; the orchestration process must contain at least one touchpoint node and an execution control node, and the process definition includes start time, end time, customer group and trigger type; Step S2: Start the orchestration process, obtain the next node ID of the starting node in the orchestration process, read the first touchpoint node information according to the ID, encapsulate it into a task, decompose the task, select the corresponding interface according to the touchpoint type and send the message to the user terminal; continue to traverse the next node until all nodes have been executed. Step S3: Real-time statistics of contact sending results are collected through Flink streaming computation, stored in event blocks, and updated in the connection lines between various process nodes.

[0005] Optionally, in step S1, the easy-flow process designer is used to create process nodes. The designer implements three draggable components: touchpoint nodes, execution control nodes, and event nodes.

[0006] Optionally, step S1 specifically includes the following sub-steps: Step S11: Start orchestration process. The process initialization state contains only one start node. Step S12: Select the first touchpoint node, configure the customer group and touchpoint template, generate a unique ID for the node, and use the ID as a parameter to associate the next node with the starting node; Step S13: Select the next node: If it is an end node, generate a unique ID for the node and use the ID as a parameter to associate the next node with the previous touchpoint node. The process orchestration ends. If it is an event node, configure the event judgment conditions, generate a unique ID for the node, and use the ID as a parameter to associate the next node with the previous touchpoint node. Step S14: Continue to select touchpoint nodes, configure the sending customer groups and touchpoint templates, generate a unique ID for the node, and use the ID as the next node association parameter for the event node condition branch; Step S15: Repeat steps S13 and S14 until the last node of all branches in the process is the end node, and the process orchestration is completed.

[0007] Optionally, in step S1, the orchestration process is encapsulated into a JSON object, and process information is generated by combining the process start time, end time, customer group and trigger type; the content of each node in the orchestration process is encapsulated into a JSON object, and node information is generated by combining the previous node ID, the next node ID, the process ID to which it belongs and the node type name, and the process information and node information are stored in the database.

[0008] Optionally, in step S2, firstly, obtain the next node ID of the starting node in the process, read the first touchpoint node information based on the ID, generate the corresponding event block and load it into the cache; send the encapsulated task into the queue, read the task and decompose it, select the corresponding interface according to the touchpoint type and send the message to the user terminal; continue to traverse the next node until all nodes have been executed.

[0009] Optionally, step S2 specifically includes the following sub-steps: Step S21: Query the touchpoint node information based on the next node ID, generate the corresponding event block and load it into the cache; Step S22: Encapsulate the touchpoint type, touchpoint template, and customer group into a task and put it into the task decomposition queue; Step S23: Read the tasks in the queue, filter the tasks by customer group, reach the users through the message sending processor, and store the customer reach results in the message sending result queue; Step S24: Query the next node ID through the event block, and determine the node type based on the node information according to the ID. If it is the end node, proceed to step S25; otherwise, proceed to step S26. Step S25: Customer outreach process ends; Step S26: Obtain the event node information based on the next node ID, traverse the conditional branches of the event node, match the branch information based on the customer outreach results obtained in step S23, and obtain the next node ID of the branch; Step S27: Repeat steps S21 to S26 until all customer outreach processes in the customer group are completed.

[0010] Optionally, in step S23, the blacklist and number sending rate limiting filtering of all tasks are uniformly processed through AOP aspects, and the filtered customers are put into the message sending failure queue; according to the contact type of the task, the corresponding message sending processor is matched to reach the customer; and the contact channel sending result is sent to the message sending result queue.

[0011] Optionally, step S3 specifically includes: Flink reads customers from the message sending failure queue, performs statistics according to a certain time window and touch point type, and updates the customer reach statistics to the corresponding event block; Flink reads customers from the message sending result queue, performs statistics based on a certain time window, touch point type, and reach status, and updates the customer reach statistics to the corresponding event block; Based on the previous node ID and the next node ID of the event block, the customer reach statistics are displayed on the connection lines between process nodes.

[0012] Secondly, the present invention provides a multi-touch orchestration and message sending system, comprising: The orchestration process design module is used to orchestrate touchpoints. Based on the easy-flow process designer, it pre-encapsulates process control nodes, touchpoint nodes, and event nodes, provides a process canvas and drag-and-drop components, and stores the orchestration processes and event blocks corresponding to touchpoint nodes created by users in the database. The orchestration process execution module is used to drive the automated execution of orchestration processes. It automatically executes process nodes through powerJob scheduled tasks and node-previous-step association IDs. The task decomposition module is used to acquire tasks to be processed, filter tasks, and select message senders to reach users based on the task's touchpoint type. The message sending module is used to call the touch channel interface, send the message content to the user terminal through the interface, parse the touch channel callback information, encapsulate the message sending result and send it to the message sending result queue. The message delivery result statistics module is used to count the reach results of the customer group. It reads data from the message delivery failure queue and the message delivery result queue through the Flink consumer, performs statistics according to a certain time window, and updates the event block in real time.

[0013] Optionally, the touchpoint nodes support text messages, video messages, message reading, 5G messages, and AI outbound calls. The execution control nodes include start and end nodes, and the event nodes include event judgment and outbound call fallback.

[0014] The beneficial effects of this invention are as follows: This invention encapsulates process information into complete JSON and stores it in a database. The JSON records the configuration information and canvas position of each node. The page renders the orchestration process in real time by reading the JSON. Process nodes are automatically executed through PowerJob scheduled tasks and node-related IDs. Event node information is generated into event blocks and stored in a cache, avoiding frequent database queries for the next node information during process execution. Message queues are used to handle touchpoint sending tasks and task execution results. Task processing and result statistics are handled asynchronously, and a strategy pattern is used to flexibly match message sending processors. Multiple process nodes are designed based on the easy-flow process designer, providing a process canvas and drag-and-drop components, allowing users to create marketing processes flexibly and quickly. Flink streaming computing provides real-time statistics on touchpoint sending results, providing real-time feedback on data during the orchestration process. Customer sending details for all touchpoints in the process are stored in a MongoDB database. Clicking on numbers between process nodes allows users to query sending details, facilitating monitoring of the marketing process. Attached Figure Description

[0015] Figure 1 This is a flowchart based on the multi-touchpoint orchestration method of the easy-flow process designer.

[0016] Figure 2 This is a diagram illustrating the user-created touchpoint orchestration process.

[0017] Figure 3 This is a diagram illustrating the scheduled task startup orchestration process.

[0018] Figure 4 This is a schematic diagram of Flink streaming computation.

[0019] Figure 5This is a flowchart of a multi-touch orchestration and message sending system.

[0020] Figure 6 This is an architecture diagram of a multi-touch orchestration and message sending system. Detailed Implementation

[0021] The invention will now be described in further detail with reference to the accompanying drawings.

[0022] Example 1 like Figure 1 As shown, this embodiment provides a multi-touchpoint orchestration method based on the easy-flow process designer. The specific process is as follows: Step S1: The user creates a touchpoint orchestration process, including process definition and process node configuration; the orchestration process must contain at least one touchpoint node and an execution control node. The process definition includes start time, end time, customer group and trigger type (immediate execution / scheduled execution).

[0023] Specifically, if a user needs to remind a group of members to claim their benefits, they first select the customer group that has not yet claimed their benefits, and then define the start and end times of the reminder process, select the selected customer group, and define the process trigger type.

[0024] User-created touchpoint orchestration processes, such as Figure 2 As shown, the specific process is as follows: Step S11: Start orchestrating the process. The process initialization state contains only one start node.

[0025] Step S12: Select the first touchpoint node, select the customer group and touchpoint template, generate a unique ID for the node, and use the ID as a parameter for associating the next node with the starting node.

[0026] Step S13: Select the next node: If it is an end node, generate a unique ID for the node and use the ID as a parameter to associate the next node with the previous touch node. The branch arrangement ends. If it is an event node, configure the event judgment conditions, generate a unique ID for the node, and use the ID as a parameter to associate the next node with the previous touch node.

[0027] Step S14: Continue to select the next touchpoint node, generate a unique ID for the node, and use the ID as the next node association parameter for the event node condition branch.

[0028] Step S15: Check if all other branches in the process have been arranged. If not, repeat steps S13 and S14 until the last node of all branches in the process is the end node, and the process arrangement is completed.

[0029] Specifically, in this embodiment, the user needs to make outbound calls to remind users who have claimed benefits, and send a text message reminder that the benefits have been claimed based on the button selection made by the user during the outbound call process; for users who have not been reached or have not made a selection during the call process, a text message reminder that the benefits are yet to be claimed is sent.

[0030] The workflow canvas is initialized with only one start node. The user selects an AI outbound call touchpoint node as the next node after the start node. The node's target audience is configured as customers, the outbound call template is a coupon redemption reminder template, the AI ​​outbound call start time and the available working time range for the outbound call task are set, and a unique ID is generated after saving the node. At this point, the node association parameters in the start node JSON are as follows: ("stepId":"b85602f8-9a1b-46bd-905e-a9aece81c350","nextStep": "6e6e46a9-6cc1-4fe2-b084-eec9d8f9790c"), where stepId is the start node ID and nextStep is the AI ​​outbound call node ID. The user continues to select the next node as an event multi-branch node, with the event type being AI event. Branch 1 corresponds to the customer selecting button 1, branch 2 corresponds to the customer selecting button 2, branch 3 corresponds to the customer selecting button 3, branch 4 corresponds to no action taken by the corresponding customer, and branch 5 corresponds to the customer not being reached by the call. At this point, the node association parameters in the AI ​​outbound call node JSON are as follows: ("stepId": "6e6e46a9-6cc1-4fe2-b084-eec9d8f9790c","nextStep":"02b6c566-0a9d-4b92-85e7-22b120cc0ad7"), where stepId is the AI ​​outbound call node ID and nextStep is the event multi-branch node ID. Continue by selecting the first touchpoint node, configuring the recipient to be the customer, and selecting the Tencent VIP membership redemption SMS as the SMS template. This node serves as the next step in branch 1. Select an ending node as the next step in branch 1. Next, select the second touchpoint node, configuring the recipient to be the customer, and selecting the iQiyi VIP membership redemption SMS as the SMS template. This node serves as the next step in branch 2. Select an ending node as the next step in branch 2. Finally, select the third touchpoint node, configuring the recipient to be the customer, and selecting the Youku VIP membership redemption SMS as the SMS template. This node serves as the next step in branch 3. Select an ending node as the next step after the third touchpoint node; select the fourth touchpoint node, configure the recipient of the node to be the customer, and select the SMS template as "Member Benefits to be Claimed SMS". This node is the next step after branch 4. Select an ending node as the next step after the fourth touchpoint node; select the fifth touchpoint node, configure the recipient of the node to be the customer, and select the SMS template as "Member Benefits to be Claimed SMS". This node is the next step after branch 5. Select an ending node as the next step after the fifth touchpoint node; at this point, the last node of all branches is the ending node, and the process orchestration is complete.

[0031] After a user submits an orchestration process, the system encapsulates all steps of the process into a JSON object, and generates complete process information by combining the process start time, end time, customer group, and trigger type. The content of each node in the process is encapsulated into a JSON object, and complete node information is generated by combining the previous node ID, the next node ID, the process ID, and the node type name. The process information and node information are stored in a MySQL database.

[0032] Scheduled task startup orchestration process, such as Figure 3 As shown, the system obtains the next node ID from the starting node in the process, reads the information of the first touchpoint node based on the ID, generates the corresponding event block, and loads it into the cache. The touchpoint sending task is encapsulated and sent to a queue. After the system reads the task and decomposes it, it selects the corresponding interface based on the touchpoint type to send a message to the user terminal; it then continues to traverse the next node until all nodes have been executed. Specifically, the steps include: Step S21: Query the touch node information based on the next node ID, generate the corresponding event block and load it into the cache.

[0033] Step S22: Encapsulate the node ID, touchpoint type, touchpoint template, and customer group into a task, store it in the database, and send it to the task decomposition queue.

[0034] Step S23: The consumer reads the tasks in the queue, filters the tasks by customer group, reaches the users through the message sending processor, and stores the user reach results in the message sending result queue.

[0035] Step S24: Query the next node ID through the event block, query the node information based on the ID, and determine the node type. If it is the end node, proceed to step S25; otherwise, proceed to step S26.

[0036] Step S25: Customer outreach process ends.

[0037] Step S26: Obtain the event node information based on the next node ID, traverse the conditional branches of the event node, match the branch information based on the message reach result obtained in step S23, and obtain the next node ID of the branch.

[0038] Step S27: Repeat the above process until all customer outreach processes in the customer group are completed.

[0039] Specifically, after the scheduled task starts, it first obtains the JSON information of the starting node based on the process ID, reads the value of nextStep, obtains the JSON information of the next touchpoint node based on nextStep, reads the touchpoint type, outbound call template, and outbound call working time from the JSON, and encapsulates it into a sending task by combining the node ID and the list of customers claiming benefits, storing it in the database. Each task generates a unique serial number. The producer puts the sending task into the task decomposition message queue, and also encapsulates the next node ID, the number of customers, and the previous node ID of the outbound call node into an event block and stores it in the cache, with the node ID as the cache key. After the consumer reads the outbound call task, it performs customer group filtering. Through AOP aspect methods, it uniformly handles customer group filtering for all tasks, implementing blacklist and number sending rate limiting filtering, and placing filtered customers into the message sending failure queue. It matches the outbound call message processor according to the outbound call task type, splits the customer list according to the maximum number of customers pushed by the outbound call channel at one time, and generates multiple message objects to be sent by combining the task serial number, template information, outbound call working time, etc., and reaches out to customers through the outbound call channel interface.

[0040] After the outbound call channel interface receives the call result, it encapsulates the call result object and sends it to the message sending result queue. Simultaneously, it retrieves the node ID corresponding to the task based on the serial number in the callback information, then queries the cached event block based on the node ID. Through the event block, it queries the next node ID, determining if the next node is a multi-branch event node. Based on the event node ID, it retrieves the event node information and iterates through the conditional branches of the event node. For example, if the call result indicates the customer selected button 1, it reads the `nextStep` value from the JSON of the conditional branch corresponding to button 1, retrieves the JSON information of the next touchpoint node based on `nextStep`, reads the touchpoint type and SMS template from the JSON, and combines them with the node ID and the customer's mobile number to encapsulate a sending task and store it in the database. Each task generates a unique serial number. The producer places the sending task in the task decomposition message queue and encapsulates the next node ID, customer group quantity, and previous node ID of the SMS node into an event block and stores it in the cache. The cache key is the node ID. After the consumer reads the SMS sending task, it performs customer group filtering, placing filtered customers into the message sending failure queue. The system matches the SMS processor with the SMS sending task type, generates a message object to be sent by combining the task serial number, SMS template and other information, and then sends the message to the customer through the SMS channel interface.

[0041] After the SMS channel interface callback sends the result, the sent result object is encapsulated and sent to the message sending result queue. Simultaneously, the node ID corresponding to the task is obtained based on the serial number in the callback information. Then, the event block in the cache is queried based on the node ID, and the next node ID is retrieved through the event block. It is determined that the next node is the end node, thus concluding the outreach process for that customer. This process is repeated until the outreach process for all customers in the customer group is completed.

[0042] The results of contact point transmissions are statistically analyzed in real time using Flink streaming computation, stored in event blocks, and updated in the connections between various process nodes, such as... Figure 4 As shown, it specifically includes: Flink reads customers from the message sending failure queue, performs statistics based on a certain time window and touchpoint type, and updates the customer reach statistics to the corresponding event block.

[0043] Flink reads customers from the message sending result queue, performs statistics based on a certain time window, touchpoint type, and reach status, and updates the customer reach statistics to the corresponding event block.

[0044] The system displays customer reach statistics on the connection lines between process nodes based on the previous node ID and the next node ID of the event block.

[0045] Specifically, the Flink consumer batches messages from the message sending failure queue. Each message stores the touchpoint type, node ID, and customer information. The number of customers who failed to send is counted by node ID and touchpoint type. An event block is retrieved based on the node ID, and the number of customers with failed sending is updated in the event block. The Flink consumer also batches messages from the message sending result queue, counting customers by node ID, touchpoint type, and reach status. The number of customers corresponding to different reach statuses is updated in the event block. The event block sums the number of customers with failed sending and the number of customers in all reach statuses to obtain the number of customers flowing into the previous node. It then sums the number of customers in all reach statuses to obtain the number of customers flowing into the next node. The system reads the number of processed customers from the previous and next nodes in the event block and displays the results on the connection lines between the process nodes. Customer sending details for all touchpoints in the process are stored in a MongoDB database; clicking on the numbers between process nodes allows querying the sending details.

[0046] Example 2 like Figure 5 As shown, this embodiment further proposes a multi-touch orchestration and message sending system, which can implement the multi-touch orchestration method based on the easy-flow process designer described in Embodiment 1. The system includes: The orchestration workflow design module is used to orchestrate touchpoints. Based on the easy-flow workflow designer, it pre-encapsulates workflow control nodes, touchpoint nodes, and event nodes. Touchpoint nodes support various touchpoints such as SMS, video SMS, message reading, 5G messages, and AI outbound calls. Execution control nodes include start and end nodes, and event nodes include event judgment and outbound call fallback. A workflow canvas and drag-and-drop components are provided to store user-created orchestration workflows and corresponding event blocks for touchpoint nodes in the database.

[0047] The orchestration process execution module is used to drive the automated execution of orchestration processes. It automatically executes process nodes through powerJob scheduled tasks and node-preceding step association IDs.

[0048] The task decomposition module is used to acquire tasks to be processed, filter tasks, and select message senders to reach users based on the task's touchpoint type.

[0049] The message sending module is used to call the touch channel interface, send the message content to the user terminal through the interface, parse the touch channel callback information, encapsulate the message sending result and send it to the message sending result queue.

[0050] The message delivery result statistics module is used to count the reach results of the customer group. It reads data from the message delivery failure queue and the message delivery result queue through the Flink consumer, performs statistics according to a certain time window, and updates the event block in real time.

[0051] To implement the above embodiments, and to allow this embodiment to be gradually improved and iterated, this embodiment also designs a contact orchestration and transmission system architecture diagram, as follows: Figure 6 As shown, the presentation layer consists of web pages and mobile terminals, the business layer includes touchpoint template management, customer group management, process canvas, automation engine, process node configuration, orchestration task management, material management and log query, the middleware includes Kafka message queue, Redis, Flink and PowerJob, and the storage layer includes MySQL database, MongoDB database, ElasticSearch log storage and HDFS.

[0052] The above are merely preferred embodiments of the present invention. The scope of protection of the present invention is not limited to the above embodiments. All technical solutions falling within the scope of the present invention's concept are within the scope of protection of the present invention. It should be noted that for those skilled in the art, any improvements and modifications made without departing from the principles of the present invention should be considered within the scope of protection of the present invention.

Claims

1. A multi-touchpoint orchestration method based on the easy-flow process designer, characterized in that, Includes the following steps: Step S1: The user creates a touchpoint orchestration process, including process definition and process node configuration; the orchestration process must contain at least one touchpoint node and an execution control node, and the process definition includes start time, end time, customer group and trigger type; Step S2: Start the orchestration process, obtain the next node ID of the starting node in the orchestration process, read the first touchpoint node information according to the ID, encapsulate it into a task, decompose the task, select the corresponding interface according to the touchpoint type and send the message to the user terminal. Continue traversing to the next node until all nodes have been executed; Step S3: Real-time statistics of contact sending results are collected through Flink streaming computation, stored in event blocks, and updated in the connection lines between various process nodes.

2. The multi-touchpoint orchestration method based on the easy-flow process designer as described in claim 1, characterized in that: In step S1, the easy-flow process designer is used to create process nodes. The designer implements three draggable components: touchpoint nodes, execution control nodes, and event nodes.

3. The multi-touchpoint orchestration method based on the easy-flow process designer as described in claim 1, characterized in that: Step S1 specifically includes the following sub-steps: Step S11: Start orchestration process. The process initialization state contains only one start node. Step S12: Select the first touchpoint node, configure the customer group and touchpoint template, generate a unique ID for the node, and use the ID as a parameter to associate the next node with the starting node; Step S13: Select the next node: If it is the end node, generate a unique ID for the node and use the ID as a parameter associated with the next node of the previous touchpoint node. The process orchestration ends. If it is an event node, configure the event judgment conditions, generate a unique ID for the node, and use the ID as a parameter to associate the next node with the previous touchpoint node; Step S14: Continue to select touchpoint nodes, configure the sending customer groups and touchpoint templates, generate a unique ID for the node, and use the ID as the next node association parameter for the event node condition branch; Step S15: Repeat steps S13 and S14 until the last node of all branches in the process is the end node, and the process orchestration is completed.

4. The multi-touchpoint orchestration method based on the easy-flow process designer as described in claim 3, characterized in that: In step S1, the orchestration process is encapsulated into a JOSN object, and process information is generated by combining the process start time, end time, customer group and trigger type; In the orchestration process, the content of each node is encapsulated into a JSON object. The node information is generated by combining the previous node ID, the next node ID, the process ID, and the node type name. The process information and node information are then stored in the database.

5. The multi-touchpoint orchestration method based on the easy-flow process designer as described in claim 1, characterized in that: In step S2, firstly, obtain the next node ID of the starting node in the process, read the first touchpoint node information based on the ID, generate the corresponding event block and load it into the cache; send the encapsulated task into the queue, read the task and decompose it, select the corresponding interface according to the touchpoint type and send the message to the user terminal; continue to traverse the next node until all nodes have been executed.

6. The multi-touchpoint orchestration method based on the easy-flow process designer as described in claim 5, characterized in that: Step S2 specifically includes the following sub-steps: Step S21: Query the touchpoint node information based on the next node ID, generate the corresponding event block and load it into the cache; Step S22: Encapsulate the touchpoint type, touchpoint template, and customer group into a task and put it into the task decomposition queue; Step S23: Read the tasks in the queue, filter the tasks by customer group, reach the users through the message sending processor, and store the customer reach results in the message sending result queue; Step S24: Query the next node ID through the event block, and determine the node type based on the node information according to the ID. If it is the end node, proceed to step S25; otherwise, proceed to step S26. Step S25: Customer outreach process ends; Step S26: Obtain the event node information based on the next node ID, traverse the conditional branches of the event node, match the branch information based on the customer outreach results obtained in step S23, and obtain the next node ID of the branch; Step S27: Repeat steps S21 to S26 until all customer outreach processes in the customer group are completed.

7. The multi-touchpoint orchestration method based on the easy-flow process designer as described in claim 6, characterized in that: In step S23, the blacklist and number sending rate limiting filtering of all tasks are handled uniformly through AOP aspects, and the filtered customers are put into the message sending failure queue; according to the contact type of the task, the corresponding message sending processor is matched to reach the customer; and the contact channel sending result is sent to the message sending result queue.

8. The multi-touchpoint orchestration method based on the easy-flow process designer as described in claim 7, characterized in that: Step S3 specifically includes: Flink reads customers from the message sending failure queue, performs statistics according to a certain time window and touch point type, and updates the customer reach statistics to the corresponding event block; Flink reads customers from the message sending result queue, performs statistics based on a certain time window, touch point type, and reach status, and updates the customer reach statistics to the corresponding event block; Based on the previous node ID and the next node ID of the event block, the customer reach statistics are displayed on the connection lines between process nodes.

9. A multi-touch orchestration and message sending system, characterized in that, include: The orchestration process design module is used to orchestrate touchpoints. Based on the easy-flow process designer, it pre-encapsulates process control nodes, touchpoint nodes, and event nodes, provides a process canvas and drag-and-drop components, and stores the orchestration processes and event blocks corresponding to touchpoint nodes created by users in the database. The orchestration process execution module is used to drive the automated execution of orchestration processes. It automatically executes process nodes through powerJob scheduled tasks and node-previous-step association IDs. The task decomposition module is used to acquire tasks to be processed, filter tasks, and select message senders to reach users based on the task's touchpoint type. The message sending module is used to call the touch channel interface, send the message content to the user terminal through the interface, parse the touch channel callback information, encapsulate the message sending result and send it to the message sending result queue. The message delivery result statistics module is used to count the reach results of the customer group. It reads data from the message delivery failure queue and the message delivery result queue through the Flink consumer, performs statistics according to a certain time window, and updates the event block in real time.

10. The multi-touch orchestration and message sending system as described in claim 9, characterized in that: The touchpoint nodes support text messages, video messages, message reading, 5G messages, and AI outbound calls. The execution control nodes include start and end nodes, and the event nodes include event judgment and outbound call fallback.

Images