Event processing and reminding method and device, equipment and medium

Abstract

The invention relates to the technical field of data processing, can be applied to business scenes such as financial science and technology and medical health, and discloses an event processing and reminding method, device, equipment and medium, and the method comprises the steps: receiving an uncompleted event, storing the uncompleted event in an event processing database, and setting an expected solution deadline and a priority level for the event; traversing the uncompleted events according to a preset time interval, comparing the expected solution deadline of the uncompleted events with the current time, marking the immediate events to be handled, and adding the immediate events to the latest task queue according to the priority level; the task queue is scanned, the difference value of the overdue events is calculated, and when the difference value is smaller than or equal to a preset reminding threshold value, a reminding event is generated and pushed to the user terminal; an event state updating instruction returned by the user terminal is received and updated, and updating is synchronized to the event processing database. By managing the priorities of the uncompleted events and a reminding mechanism, it is ensured that the events are processed in time, the reminding opportunity is accurate, and the timeliness and accuracy of event processing are enhanced.

Description

Technical Field

[0001] The present invention relates to the field of data processing technology, and in particular to an event processing and reminder method, device, equipment and storage medium. Background Art

[0002] Existing task management tools and reminder systems in the current market, such as Trello, Asana, and Microsoft To-Do, are widely used for both individual and team task management. These tools play an important role in general task management and reminders, helping users set and track to-do items. However, these tools have significant shortcomings in specific areas, particularly in the fintech and healthcare sectors.

[0003] In the fintech business sector, especially in the health insurance industry, the biggest challenge facing task management and reminder tools is the lack of customization capabilities for industry-specific needs. The financial industry has complex business processes, involving a large amount of customer information, contract management, claims review, and other links. Existing tools are generally unable to flexibly manage events based on the industry's unique processes and rules. For example, handling customer complaints, task management in the claims approval process, and processing new business needs all require flexible scheduling, dynamic priority adjustment, and automatic refresh capabilities. Existing tools often rely on manual intervention, cannot update task status in real time, and lack an automatic priority adjustment mechanism. This is particularly inefficient when handling urgent or sudden tasks, increasing the complexity of the work.

[0004] In the healthcare sector, particularly in health insurance and claims processing, the shortcomings of task management tools are equally significant. Healthcare tasks typically involve multiple processing steps, such as patient claim applications, examination reviews, and medical report analysis, each of which may require updates to the task status. Existing tools often fail to automatically track and record the progress of each step, resulting in tasks not being immediately reflected to users, increasing management difficulty and risk. Furthermore, existing tools lack detailed record-keeping and review capabilities for historical event processing, making it impossible to clearly demonstrate the progress of events throughout the processing cycle. Health insurance companies need to accurately track every step of the claims process and optimize and analyze it based on historical data. Existing tools are unable to provide detailed historical records by date or event, lack clear review capabilities, and are unable to effectively analyze and improve processing processes.

[0005] Furthermore, existing task management tools, whether in finance or healthcare, often lack effective reminder mechanisms and are unable to dynamically adjust reminder thresholds based on event priorities. This means that when tasks are about to expire, users may not receive timely notifications, leading to delayed event processing and impacting business operational efficiency. In finance, task delays can lead to customer churn or increased risk; in healthcare, task delays can impact patient health and the quality of medical services. Summary of the Invention

[0006] The main purpose of the present invention is to provide an event processing and reminder method, device, equipment and storage medium, aiming to solve the technical problem in the prior art that task management tools cannot automatically manage unfinished events according to the expected resolution period and priority level of the events, resulting in delayed processing of unfinished events and inaccurate reminder timing.

[0007] To achieve the above objectives, the present invention provides an event processing and reminder method, comprising:

[0008] Receiving unfinished events and storing the unfinished events in an event processing database, wherein the unfinished events are set with corresponding expected resolution deadlines and priority levels;

[0009] Traversing the unfinished events in the event processing database at preset time intervals, and comparing the expected resolution deadlines of the unfinished events with the current time;

[0010] Mark the unfinished events whose expected resolution deadline is later than the current time as pending events, and add the pending events to the latest task queue according to the corresponding priority level;

[0011] Scan the pending events in the latest task queue to determine the difference between the expected resolution deadline of each pending event and the current time;

[0012] When the difference is less than or equal to a preset reminder threshold, a reminder event corresponding to the pending event is generated and the reminder event is pushed to the user terminal;

[0013] Receive the event status update instruction returned by the user terminal, update the status of the corresponding pending event in the latest task queue according to the event status update instruction, and synchronize it to the event processing database.

[0014] Furthermore, to achieve the above-mentioned purpose, the present invention provides an event processing and reminder device, comprising:

[0015] An event receiving and storing module, configured to receive unfinished events and store them in an event processing database, wherein the unfinished events are set with corresponding expected resolution deadlines and priority levels;

[0016] An event traversal and comparison module, configured to traverse the unfinished events in the event processing database at preset time intervals and compare the expected resolution deadlines of the unfinished events with the current time;

[0017] An event marking and task queue management module is used to mark the unfinished events whose expected resolution deadline is later than the current time as pending events, and add the pending events to the latest task queue according to the corresponding priority level;

[0018] A task queue scanning and difference analysis module is used to scan the pending events in the latest task queue and determine the difference between the expected resolution period of each pending event and the current time;

[0019] a reminder generation and push module, configured to generate a reminder event corresponding to the pending event when the difference is less than or equal to a preset reminder threshold, and push the reminder event to a user terminal;

[0020] The event status update and synchronization module is used to receive the event status update instruction returned by the user terminal, update the status of the corresponding pending event in the latest task queue according to the event status update instruction, and synchronize it to the event processing database.

[0021] Furthermore, to achieve the above-mentioned purpose, the present invention also provides a computer device, which includes a memory, a processor, and an event processing and reminder program stored in the memory and runnable on the processor, and when the event processing and reminder program is executed by the processor, the steps of the event processing and reminder method described above are implemented.

[0022] Furthermore, to achieve the above-mentioned purpose, the present invention also provides a computer-readable storage medium, on which an event processing and reminder program is stored. When the event processing and reminder program is executed by a processor, the steps of the event processing and reminder method described above are implemented.

[0023] Beneficial effects: The present invention relates to the field of data processing technology and can be applied to business scenarios such as financial technology and medical health. It discloses an event processing and reminder method, including: receiving unfinished events and storing them in an event processing database, where the events are set with expected resolution deadlines and priority levels; traversing unfinished events at preset time intervals, comparing their expected resolution deadlines with the current time, marking pending events, and adding them to the latest task queue according to their priority levels; scanning the task queue, calculating the difference between overdue events, and when the difference is less than or equal to a preset reminder threshold, generating a reminder event and pushing it to the user terminal; receiving and updating the event status update instruction returned by the user terminal, and synchronizing the update to the event processing database. The present invention ensures that events are handled in a timely manner and reminders are accurate by managing the priority and reminder mechanism of unfinished events, thereby improving the automation and efficiency of task management and enhancing the timeliness and accuracy of event processing. BRIEF DESCRIPTION OF THE DRAWINGS

[0024] The present invention will be further described below with reference to the accompanying drawings and embodiments, in which:

[0025] Figure 1 A schematic diagram of an application environment of an event processing and reminder method according to an embodiment of the present invention;

[0026] Figure 2 This is a flow chart of an embodiment of an event processing and reminder method of the present invention;

[0027] Figure 3 Schematic diagram of the functional modules of a preferred embodiment of the event processing and reminder device of the present invention;

[0028] Figure 4 A schematic diagram of the structure of a computer device according to an embodiment of the present invention;

[0029] Figure 5 FIG. 2 is another structural diagram of a computer device according to an embodiment of the present invention. DETAILED DESCRIPTION

[0030] It should be understood that the specific embodiments described herein are only used to explain the present invention and are not intended to limit the present invention.

[0031] The event processing and reminder method provided by the embodiment of the present invention can be applied in Figure 1In an application environment, the user terminal communicates with the server terminal through a network. The server terminal can receive unfinished events through the user terminal and store them in an event processing database, where the events are set with an expected resolution deadline and a priority level; traverse the unfinished events according to a preset time interval, compare their expected resolution deadlines with the current time, mark the pending events, and add them to the latest task queue according to the priority level; scan the task queue, calculate the difference of overdue events, and when the difference is less than or equal to the preset reminder threshold, generate a reminder event and push it to the user terminal; receive and update the event status update instruction returned by the user terminal, and synchronize the update to the event processing database. The present invention ensures that the events are handled in a timely manner and the reminder timing is accurate by managing the priority and reminder mechanism of unfinished events, thereby improving the automation and efficiency of task management and enhancing the timeliness and accuracy of event processing. Among them, the user terminal can be, but is not limited to, various personal computers, laptops, smart phones, tablet computers and portable wearable devices. The server terminal can be implemented with an independent server or a server cluster consisting of multiple servers. The present invention is described in detail below through specific embodiments.

[0032] See also Figure 2 , Figure 2 This is a flow chart of an embodiment of the event processing and reminder method provided by the present invention. It should be noted that although a logical order is shown in the flow chart, in some cases, the steps shown or described may be performed in a different order than that shown here.

[0033] like Figure 2 As shown, the event processing and reminder method proposed by the present invention includes the following steps:

[0034] S10, receiving unfinished events and storing the unfinished events in an event processing database, wherein the unfinished events are set with corresponding expected resolution deadlines and priority levels;

[0035] In this embodiment, in the event management system, the process of receiving unfinished events and storing them in the event processing database is a core component of task management. The system receives external data or internally generated events and processes them as unfinished events. Each event has several core fields. The first is the event title, which is used to briefly describe the main content of the event to facilitate subsequent tracking and identification; the event description information provides users with detailed information about the event so that they can understand the specific background and execution requirements of the task. Next, the expected resolution deadline field represents the expected time point when the task should be completed. This field is very critical in subsequent operations and helps the system determine whether the event is in a delayed state or overdue. Finally, there is the priority level, which is used to determine the importance and urgency of the task, thereby determining the priority of the task in subsequent processing.

[0036] Within the system, all outstanding events are stored in an event processing database. This database, which can be a relational or NoSQL database, is appropriately structured to ensure efficient storage and retrieval of large amounts of data. The database design typically includes indexing mechanisms to facilitate fast queries and updates based on event identifiers (such as event IDs), expected resolution deadlines, or priority levels. Through efficient database management, the system can support a large number of concurrent event processing requests and maintain good system responsiveness.

[0037] In the event processing database, each event record contains core data fields such as the event title, description, expected resolution deadline, and priority level, allowing the system to flexibly utilize this data in different scenarios. The expected resolution deadline provides a time basis for subsequent task scheduling, while the priority level provides a basis for event sorting. This mechanism enables the system to schedule and sort tasks appropriately based on the time requirements and importance of the event.

[0038] In its implementation, the system receives external event data, including events generated by users or automated systems. The event receiving module parses the data, extracting key information such as the title, description, expected resolution period, and priority level. This data is then transferred to the event processing database, where each event's data is stored in a pre-set format. Within the system, event data can be uniquely identified by an event identifier and retrieved from the database. To ensure efficient management, the system uses an indexing mechanism to optimize data access performance. For example, the expected resolution period and priority level of an event can be used as index fields, enabling fast sorting and querying based on these fields during event processing. The database system employs efficient transaction management and concurrency control mechanisms to ensure stability and consistency when operating on a large number of concurrent events. The system is flexibly adaptable to different database types, such as relational and NoSQL databases. For example, for event data requiring relational queries, relational databases such as MySQL or PostgreSQL can be used; whereas for tasks requiring high concurrency and high throughput, NoSQL databases such as MongoDB and Cassandra can be used. The selection and configuration of these databases allows the system to flexibly adjust performance parameters based on business needs.

[0039] Example: In the healthcare sector, hospitals often need to handle various tasks such as patient medical records, treatment plans, and medical reports. Each medical event has an expected resolution deadline and a priority level. For example, a patient's treatment plan needs to be updated within 48 hours and has a high priority. The system will receive this medical task and sort it according to its expected resolution deadline and priority level. The system will automatically enter this high-priority medical task into the task queue based on its urgency, ensuring that it is processed in the shortest possible time. Through this intelligent management, the system can automatically adjust the processing order based on the urgency of the event, reducing manual intervention, improving the hospital's operational efficiency and the timeliness of patient treatment, thereby improving patient satisfaction and optimizing the hospital's resource allocation.

[0040] In the financial sector, insurance companies typically handle tasks such as customer claims, contract approvals, and customer service. Each claim has a clear processing deadline and priority level. For example, a customer's claim application requires approval within 7 days and has a high priority. The system will add the task to the task queue based on its expected resolution period (7 days) and priority level (high) and assign it priority processing within the system. Claims tasks are automatically sorted according to their importance and urgency, ensuring that high-priority tasks are handled and approved promptly. This intelligent sorting based on priority and time can help insurance companies process claims quickly and efficiently, reduce processing time, improve customer satisfaction, and optimize resource allocation, thereby improving operational efficiency and reducing the risk of delays.

[0041] By storing unfinished events in the event processing database and assigning expected resolution deadlines and priority levels, the system efficiently manages the status and priority of events throughout their lifecycle. The expected resolution deadlines provide a time basis for subsequent event sorting and scheduling, while the priority levels provide a basis for task allocation, ensuring that important and urgent events are handled promptly. By optimizing the database design, the system maintains a high responsiveness even under high load, improving the efficiency and accuracy of task management. This enhances the automation and intelligence of event management, avoids manual intervention, and reduces delays in event processing.

[0042] S20, traversing the unfinished events in the event processing database at preset time intervals, and comparing the expected resolution deadlines of the unfinished events with the current time;

[0043] In this embodiment, unfinished events are typically stored in an event processing database, and each unfinished event has a clear expected resolution deadline. To ensure that events can be processed and completed within a reasonable time, the status of these events needs to be monitored and checked regularly. The system will traverse all unfinished events in the event processing database at preset time intervals (such as every hour or every day) and compare them with the current time. The expected resolution deadline is a time point associated with each event, which indicates when the event should be completed. When the expected resolution deadline is compared with the current time, the system will determine which events are approaching or exceeding their expected resolution deadline, and decide whether these events need to be further processed. This process ensures that the system can dynamically monitor the progress of events and adjust their processing order according to the urgency of the events.

[0044] Specifically, during the traversal process, the system compares each event's "Expected Resolution Date" field with its "Current Time." If an event's expected resolution date is nearing or has expired, the system will mark it, alerting the user or automatically executing subsequent tasks. Furthermore, based on the event's priority and processing deadline, the system may automatically add the event to the task queue for priority processing in the next step.

[0045] In practical applications, this can be accomplished through database queries and scheduled tasks. Uncompleted events stored in the database typically include fields such as "event identifier," "expected resolution deadline," and "priority level." The system can periodically query the database for all uncompleted events using a scheduled task (such as a CRON expression) and compare each event's expected resolution deadline with the current time. Assuming the system's preset interval is one hour, the system will query the database for uncompleted events every hour. For each event, the system extracts the expected resolution deadline field and compares it with the current system time. If an event's expected resolution deadline is later than the current time and has not yet been completed, the system can mark it as "urgent pending event." If an event's expected resolution deadline has passed and has not yet been completed, the system can mark it as "overdue and unfinished." Subsequently, pending events or overdue and unfinished events are processed based on their priority level (for example, by adding them to the latest task queue). To improve processing efficiency, the system can leverage database indexes to accelerate the retrieval of uncompleted events, ensuring efficient query and comparison even with a large number of stored events. At the same time, the system can set different time intervals according to specific business needs, or set different processing frequencies according to the priority of the event.

[0046] Through periodic traversal and time comparison, the system monitors the status of each event in real time, promptly identifying pending or overdue events and handling them according to pre-set rules. This automated event management approach significantly reduces manual intervention and improves the efficiency and timeliness of event handling. Furthermore, it dynamically processes events based on their urgency and priority, ensuring that high-priority events receive priority, thereby improving the efficiency of the overall business process.

[0047] S30, marking the unfinished events whose expected resolution deadlines are later than the current time as pending events, and adding the pending events to the latest task queue according to the corresponding priority levels;

[0048] In this embodiment, the management of events covers multiple stages, aiming to ensure that all outstanding events can be processed within the expected time, especially to mark and prioritize the pending events that are close to the expected deadline in a timely manner.

[0049] Each incident is assigned an expected resolution deadline, determined by the incident type, urgency, and relevant business processes. As the system traverses the incident database, it compares each incident's expected resolution deadline with the current system time. If the expected resolution deadline for an incident is later than the current time, the incident is considered an urgent pending incident. This allows the system to clearly identify priority tasks and ensure that incidents approaching their expected resolution deadlines are promptly addressed.

[0050] After marking an urgent task, the system sorts it by priority. The task queue is sorted so that high-priority urgent tasks are added to the front of the queue, while lower-priority tasks are placed at the back. This prioritization ensures that the most urgent tasks are addressed first, effectively allocating resources and ensuring tasks are completed on time.

[0051] The system also calculates the difference between each incident's expected resolution deadline and the current time. This difference helps the system determine the urgency of the task. If the difference is less than or equal to the preset reminder threshold, the system generates a reminder event and pushes it to the user's terminal to remind them that the task is about to expire. The system can generate different reminder events based on task priority, ensuring that tasks are not overlooked and helping users complete them efficiently.

[0052] In actual applications, the system can use a scheduled task or event-driven approach to periodically traverse the event database and check the status of all outstanding events. Each time the system traverses an event, it compares the expected resolution date for each event with the current time. This comparison is performed through a database query, where the system compares the "Expected Resolution Date" field of each event with the current system time. If an event's expected resolution date is later than the current time and the event is still outstanding, the system modifies the event's status field, marking it as pending. This marking is performed through a database update, and the system adds pending events to the task queue based on their priority. The task queue is sorted based on the priority field, with high-priority events added to the front of the queue and low-priority events to the back. To optimize system performance, the system implements an automatic sorting mechanism in the task queue. This allows the system to prioritize the most important and urgent tasks during processing. The difference is calculated by taking the event's "Expected Resolution Date" field and the current system time. The difference value is stored in the status field of the event, and the system can use this difference value to determine whether an alert is needed. Only when the difference value is less than or equal to the set alert threshold will the system generate an alert event and push it to the user's terminal.

[0053] Example: In the healthcare sector, hospitals need to regularly monitor tasks such as patient treatment plans and medical reports. If a treatment plan requires completion within 48 hours, the system will periodically review all outstanding medical tasks and compare them with the current time. The system will periodically review all outstanding medical tasks and compare the expected resolution date for each task with the current time. If a treatment task's expected resolution date is later than the current time, the system will mark it as an "urgent pending event." For example, if a patient's treatment plan requires completion within 48 hours, and the current time is 30 hours after the treatment plan begins, the system will compare the expected resolution date (48 hours) with the current time. If the task is within the deadline, the system will mark the task as an "urgent pending event." The system will also assign a priority based on the importance and urgency of the task and add it to the most recent task queue. The ordering of the task queue is crucial. All "urgent pending events" are sorted by priority from highest to lowest, with higher-priority tasks placed at the front of the queue to ensure that the most urgent tasks are processed first.

[0054] By marking and prioritizing pending tasks, the system ensures that high-priority tasks are handled promptly, reducing the likelihood of delays. Furthermore, the automatic calculation of variances and generation of reminder events effectively prevents missed tasks and delayed processing, enhancing the system's responsiveness and real-time performance. Users can adjust their work schedules based on reminder events, improving work efficiency and processing quality.

[0055] S40, scanning the pending events in the latest task queue, and determining the difference between the expected resolution deadline of each pending event and the current time;

[0056] In this embodiment, scanning the latest pending tasks in the task queue and calculating the difference between each task's expected resolution deadline and the current time is a crucial step in the task management process. This ensures the system can understand the urgency of each task in real time and process them according to priority.

[0057] Each uncompleted event has an expected resolution deadline stored in the database. This deadline is typically set based on the event type, urgency, and specific business requirements. To accurately process these events, the system first needs to obtain the current system time, typically in milliseconds, and compare it with the stored expected resolution deadline. This difference, known as the event's "delta," is the amount of time between the expected resolution deadline and the current time. By calculating this delta, the system can identify tasks that are about to expire and perform subsequent processing based on the size of the delta.

[0058] This difference is calculated based on a timestamp comparison. A timestamp is a standardized time format, typically in Unix time format, representing the number of seconds or milliseconds from January 1, 1970, to the current time. The system converts the expected resolution deadline for each incident into a timestamp and then calculates the difference with the current system time. This difference helps the system identify tasks that are about to expire and prioritizes them based on the size of the difference. For example, the smaller the difference, the more urgent the task, and the system can adjust its handling strategy based on the urgency of the task, prioritize it, or generate a reminder event.

[0059] To ensure accuracy and efficiency, the system needs to perform this calculation regularly, typically automatically in the background of the event management system. This not only increases the system's automation level but also avoids manual intervention, improving work efficiency. Whenever the system scans the task queue, it obtains the current status of each event and calculates its overdue difference. If the difference is less than or equal to the preset reminder threshold (such as 24 hours), the system triggers a reminder, prompting the relevant personnel or users to handle the task as soon as possible. If the difference is larger, the system can set different reminder methods based on the priority of the event.

[0060] In real-world applications, task priorities are typically pre-set based on their importance and urgency. However, when processing real-world tasks, their urgency can change over time, necessitating dynamic adjustment of the set priorities. To this end, the system calculates a delta for each task—the difference between the task's expected deadline and the current deadline. The smaller the delta, the more urgent the task, and the system can dynamically adjust its priorities to optimize the order in which tasks are processed. For tasks that are already overdue, the delta is a negative number. A larger negative value indicates a longer delay, and therefore a higher urgency. These tasks are automatically promoted to a higher priority to ensure timely processing. In contrast, for tasks that are not yet overdue, the delta is a positive number, and the system dynamically increases the priority of the task based on the delta. A smaller delta (i.e., a shorter remaining time) indicates a more urgent task, and the system increases its priority to ensure that tasks approaching their due date are completed promptly. This delta-based priority adjustment mechanism allows the system to flexibly prioritize tasks, ensuring that overdue tasks are processed first while also providing timely reminders of tasks approaching their due date, thereby preventing delays. By dynamically adjusting priorities in this way, the system can manage tasks more intelligently and efficiently, and automatically optimize the processing order based on the actual urgency of the tasks, avoiding task delays and lags, and ensuring that tasks are completed on time.

[0061] By scanning the task queue and calculating the difference between the expected resolution deadline and the current time for each pending event, the system intelligently identifies the urgency of the task and generates reminder events when necessary. This automated processing significantly reduces human intervention and improves the timeliness and accuracy of event handling. It ensures that high-priority tasks are handled in the shortest possible time, preventing further delays and improving work efficiency.

[0062] S50, when the difference is less than or equal to a preset reminder threshold, generating a reminder event corresponding to the pending event, and pushing the reminder event to the user terminal;

[0063] In this embodiment, the difference is calculated by comparing the task's expected resolution deadline timestamp with the current timestamp. If the task's expected resolution deadline has passed, the difference is negative, indicating that the task has exceeded the deadline; if the difference is positive, the task has not yet exceeded the deadline. The system uses the difference to assess the urgency of the task; a smaller difference indicates a more urgent task.

[0064] To ensure timely task processing, the system sets a preset reminder threshold. This threshold is dynamically adjusted based on factors such as task priority, type, and historical processing data. When the difference between a task and the threshold is less than or equal to this threshold, the task requires urgent processing. At this point, the system generates a reminder event and pushes it to the user's terminal, reminding them to process the task. This ensures that high-priority tasks are processed promptly, preventing a backlog of overdue tasks.

[0065] The process of generating a reminder event consists of two steps: First, the system determines whether the task meets the conditions for generating a reminder, that is, whether the task's difference is less than or equal to the preset reminder threshold. Second, if the conditions are met, the system generates a reminder event based on the task's specific information (such as task identifier, remaining time, priority, etc.) and sends it to the user's terminal via an appropriate push protocol. These reminders can take the form of pop-ups, notification bar messages, etc., and the specific form is adapted according to the user's terminal device type.

[0066] In the task management system, the task storage module, the task processing module, and the reminder push module are the three core modules. Their close cooperation ensures the automated processing of tasks and the timely generation of reminders. The task storage module is responsible for receiving and storing all uncompleted events, saving key information about each event (such as event identifier, expected resolution deadline, priority level, etc.) in the event management database. The system generates a unique identifier based on the task type, priority, and expected resolution deadline, and adds the task record to the list of uncompleted events. Every time a new task enters the system, the task storage module ensures that it is accurately recorded and stored.

[0067] Once tasks are stored in the database, the task processing module begins to periodically iterate through unfinished events and process them. This module compares the expected resolution date of each task with the current time. By calculating the difference of the task (the expected resolution date minus the current time), it can be determined whether the task has exceeded the deadline or the distance between the current time and the deadline. If the difference is negative, it means that the task has exceeded the deadline; if the difference is positive, it means that the task has not exceeded the deadline. During this process, the system will evaluate the urgency of the task based on the difference and assign it a corresponding priority. The smaller the difference, the more urgent the task, and the system will process the task according to its urgency and generate a corresponding reminder event based on the set reminder threshold.

[0068] When the difference between tasks is less than or equal to the preset reminder threshold, the system automatically generates a reminder event. At this point, the task will be marked as urgent, and the system will promptly push the event to the user's terminal through a push mechanism. The reminder event includes key information such as the task identifier, remaining time, and task priority level. The system can select the appropriate push method based on the priority of the task and the device type, such as pop-up window, sound, vibration, etc. For lower priority tasks, the system may only remind you through the notification bar to avoid excessive interference with the processing of high-priority tasks.

[0069] The system also features an automatic escalation mechanism. If the user fails to respond to a reminder event within the preset response time, the system marks the event as urgent and reinserts it to the front of the task queue, ensuring timely processing. This mechanism prevents task delays and improves event processing efficiency and response speed. Through this intelligent task management approach, the system ensures timely task processing while reducing the user's operational burden and improving work efficiency.

[0070] Example: In the healthcare industry, hospital or clinic management systems need to handle a series of tasks for patients, including appointments, examinations, and treatments. Each task has an expected resolution deadline. For example, a patient may need an examination within 24 hours. The system calculates the difference between the expected resolution deadlines for the patient's tasks. If the difference is less than the preset reminder threshold (for example, 12 hours remaining), the system generates a reminder event and pushes it to the mobile devices or computers of the relevant medical staff. The reminder event includes information such as the remaining time of the task and the priority level, ensuring that medical staff can handle the patient's needs in a timely manner.

[0071] In the financial sector, especially for health insurance companies, handling tasks like insurance claims and customer complaints often requires resolving customer issues within a specific deadline. Insurance claims processing is subject to strict time constraints, so insurance companies' systems calculate the difference between the expected resolution deadline and the current time for each task. When this difference is less than or equal to a preset alert threshold, the system generates an alert, reminding claims personnel to process the customer's claim as soon as possible. This alert can be delivered to insurance company employees' mobile devices or computers, ensuring an efficient and timely claims process.

[0072] By presetting reminder thresholds and push mechanisms, the system can effectively avoid excessive reminders or delayed reminders during task management, thereby improving task processing efficiency and user experience.

[0073] S60: Receive an event status update instruction returned by the user terminal, update the status of the corresponding pending event in the latest task queue according to the event status update instruction, and synchronize it to the event processing database.

[0074] In this embodiment, when a user terminal returns an event status update instruction, the system needs to update the corresponding pending event in the latest task queue. The key to this process is receiving the event status update instruction from the user terminal and updating the event status in the queue according to the instruction. The system determines the task to be updated and its new status by parsing the operation type and target event identifier in the instruction. The event status update process includes legitimacy verification of the event status to ensure that the update complies with preset rules and conditions.

[0075] After processing an instruction, the system updates the status of the corresponding task based on the action type (e.g., completed, deferred, or delayed). If the task is completed, the system removes it from the latest task queue and moves it to the completed event partition. For deferred or delayed tasks, the system updates the task status based on the new expected resolution deadline timestamp or the delay start timestamp. These changes are also synchronized with the event processing database to ensure that the information in the database is up to date and consistent.

[0076] This operation must ensure data integrity and consistency. Specifically, when an event's status changes, the system not only updates the tasks in the queue but also synchronizes the relevant data stored in the database, ensuring that subsequent queries and processing can obtain the latest information. To ensure efficient and accurate event processing, the system may also prioritize tasks to ensure that high-priority tasks are processed first.

[0077] In practice, the system's event processing module periodically receives event status update instructions from user terminals. Upon receiving each instruction, the system parses the instruction's action type (complete, postpone, delayed) and target event identifier, then performs validation. For example, the system verifies whether the task's current status permits the action (e.g., a postpone action cannot be applied to a completed task). If the instruction is valid, the system updates the task's status accordingly and adjusts the queue accordingly based on the task's priority. For database updates, the system performs transactional operations on the event processing database to ensure data consistency during the update process. For example, if a task's status is marked as "completed," the system moves the task to the "completed" partition. If a task is delayed, the system updates the task's expected resolution deadline and synchronizes this change to the database for subsequent processing by the task management module. Through this mechanism, the system ensures that the latest task status is promptly and accurately reflected in the queue and database.

[0078] Example: In the financial sector, especially in insurance claims processing, managing and handling claims in a timely manner is crucial. Whenever a claim is created, the system sets an expected resolution deadline based on the insurance company's internal processes and categorizes the claim by priority. Over time, tasks are dynamically managed based on their completion status and time delta. For each uncompleted claim task, the system first calculates the task's "delta," the difference between the expected resolution deadline and the current time. If the claim has not yet exceeded the deadline (the delta is a positive number), the system generates a reminder based on the remaining time. For these tasks, the reminder intensity is less severe, such as a notification message reminding the relevant personnel that the task needs to be addressed. Specifically, the system categorizes overdue events into different time periods and generates reminders of varying intensity. For example, if a claim task has an expected resolution deadline of 48 hours and the current time has exceeded 48 hours, if the task is not completed, the system calculates a delta of -12 hours, indicating that the task is 12 hours overdue. Based on pre-set rules, the system adjusts the reminder intensity based on the length of the overdue period:

[0079] Overdue within 12 hours: The system will generate a moderate reminder (such as SMS reminder or email notification) to remind relevant personnel that the task has just exceeded the deadline. The reminder intensity is moderate.

[0080] If the deadline is between 12 and 24 hours, the system will generate a strong reminder (such as a pop-up window and vibration reminder) to ensure that relevant personnel can immediately pay attention to and handle the task.

[0081] If the deadline exceeds 24 hours: the system will generate an emergency reminder (such as a phone notification or a prominent screen prompt) to ensure that the task is processed immediately to avoid further impact on customer experience or business due to excessive delays.

[0082] For tasks that are not overdue, the intensity of the reminder is adjusted according to the remaining time of the task. For example, if a task is not completed for 24 hours, the system will remind the relevant personnel to deal with it in time through a lighter reminder (such as a notification bar message).

[0083] In this way, insurance companies can ensure that the priority and urgency of tasks are automatically managed and optimized. For overdue tasks, the system dynamically adjusts the intensity of reminders based on the length of the overdue period to ensure that tasks are processed as quickly as possible. At the same time, tasks that are not overdue are also promptly reminded, avoiding unnecessary delays.

[0084] By receiving and processing event status update commands, we ensure timely event status updates, improving task management efficiency. Not only can we dynamically update task status, but we also ensure synchronization between the queue and database, avoiding data inconsistencies. Through proper queue sorting and task status updates, the system can effectively improve the processing efficiency of high-priority events and further optimize the task processing process.

[0085] The present invention relates to the field of data processing technology and can be applied to business scenarios such as financial technology and medical health. It discloses an event processing and reminder method, including: receiving unfinished events and storing them in an event processing database, where the events are set with expected resolution deadlines and priority levels; traversing unfinished events at preset time intervals, comparing their expected resolution deadlines with the current time, marking pending events, and adding them to the latest task queue according to the priority level; scanning the task queue, calculating the difference between overdue events, and when the difference is less than or equal to a preset reminder threshold, generating a reminder event and pushing it to the user terminal; receiving and updating the event status update instruction returned by the user terminal, and synchronizing the update to the event processing database. The present invention ensures that events are handled in a timely manner and reminder timing is accurate by managing the priority and reminder mechanism of unfinished events, thereby improving the automation and efficiency of task management and enhancing the timeliness and accuracy of event processing.

[0086] In one embodiment, the above step S10 includes:

[0087] S101, receiving an event creation request, extracting the user ID, event title, description information, expected resolution deadline and priority level in the event creation request;

[0088] S102, querying a user authority database based on the user ID to verify the legitimacy of the user ID and the event creation authority;

[0089] S103, if the verification is successful, calling the event identifier generation module to generate an event identifier based on the timestamp, user ID and random hash value;

[0090] S104, if the priority level is not specified in the event creation request, matching a preset priority rule library based on the keywords of the event title to generate a default priority level as the priority level;

[0091] S105, if the expected resolution deadline is not specified in the event creation request, generating a default expected resolution deadline as the expected resolution deadline based on the default priority level and using a deadline analysis model;

[0092] S106, binding the event title, description information, expected resolution deadline, priority level, and user ID to the event identifier to generate a structured unfinished event;

[0093] S107: Allocate the structured unfinished event to an unfinished event partition of an event processing database according to a hash value of the event identifier, and create an event identifier index.

[0094] In this embodiment, new unfinished events are received and stored in the event processing database, ensuring that all unfinished events can be effectively managed according to their expected resolution deadlines and priority levels. In practical applications, unfinished events typically include tasks, complaints, work orders, and other business-related items. The status of these events needs to be continuously tracked and updated to ensure their eventual resolution.

[0095] When an incident is created, the system first receives an incident creation request from a user or system. This request typically contains several key pieces of information, including the incident title, detailed description, expected resolution deadline, priority level, and user ID. The incident title and description allow the user or system to quickly identify the incident type and content. The expected resolution deadline defines the timeframe for the incident, the priority level helps the system prioritize incident handling, and the user ID helps associate the responsible individual and authority for handling the incident.

[0096] Upon receiving an event creation request, the system queries the user permissions database to verify the user's legitimacy and event creation permissions. Verifying the legitimacy of user identification is essential for ensuring system security and preventing unauthorized event creation. This ensures that only users with appropriate permissions can create new events and that event creation complies with the organization's defined permission management system.

[0097] If the user's permission is verified, the system generates a unique event identifier for the event. This identifier is typically generated based on a timestamp, user ID, and a random hash value, ensuring the uniqueness of the event within the system. The timestamp ensures the sequential nature of the event identifier, the user ID associates the identifier with a specific user, and the hash value further enhances the randomness and security of the identifier, preventing identifier conflicts.

[0098] If a priority level isn't explicitly specified in the incident creation request, the system will generate a default priority level for the incident based on keywords in the incident title, matching it against a pre-defined priority rule library. This algorithm automatically infers the urgency of the task, preventing human error or omissions. If a resolution deadline isn't specified, the system uses a deadline analysis model to calculate a reasonable default resolution deadline based on the incident's default priority level. This model uses historical data, business rules, and industry standards to determine the most appropriate resolution deadline, ensuring that the incident is resolved within a reasonable timeframe.

[0099] Once all relevant information about an incident has been determined, the system binds the incident title, description, expected resolution deadline, priority level, and user ID to the incident identifier to generate a structured unfinished incident. This information is structured in a unified system format for easy management and retrieval. The generated structured unfinished incident is stored in the unfinished incident partition of the incident processing database and indexed based on the incident identifier. This ensures efficient storage, retrieval, and updating of incidents, providing a foundation for subsequent incident management and processing.

[0100] In one specific embodiment, the system can receive event creation requests initiated by external systems or users through an API. When verifying user permissions, the system accesses a centrally managed permissions database to verify the legitimacy of the user's identity in real time. Based on the user's role and permissions, the system determines whether the user has permission to create the event. If the user's permissions meet the requirements, the event processing continues. Automatic priority generation and resolution deadline calculation provide a high degree of automation for the event management system. The priority rule library and deadline analysis model can be continuously adjusted and optimized based on historical event processing records. Machine learning methods are used to dynamically adjust and optimize the generated rules, improving the system's responsiveness to complex events. In practice, priority and resolution deadline derivation can be performed using various algorithms or models, such as using keyword-matching rules to generate priorities or automatically predicting event processing times based on machine learning models. Event storage uses a hashing algorithm to ensure the uniqueness of each event identifier and prevent identity conflicts. Stored events are optimized through indexing, enabling rapid response to query requests and ensuring that the system avoids performance bottlenecks when processing massive event volumes. In distributed systems, database partitioning and indexing can further improve data processing efficiency and scalability.

[0101] By automatically generating priorities and expected resolution deadlines, this embodiment allows the system to better adapt to different types of event processing requirements, thereby increasing the flexibility of task allocation and processing. The event identifier generation and indexing functions during storage ensure efficient storage and rapid retrieval of event data, safeguarding the system's performance and stability when handling large-scale events.

[0102] In one embodiment, the above step S30 includes:

[0103] S301, if the expected resolution deadline timestamp of an unfinished event is less than the current timestamp, the unfinished event is determined to be an urgent pending event, and the status of the urgent pending event is updated in the event processing database as an urgent unprocessed state;

[0104] S302, sorting the pending events from high to low priority, with the pending events with high priority being placed before the pending events with low priority;

[0105] S303: When there are multiple pending events with the same priority level, the pending events are sorted in ascending order according to their expected resolution deadline timestamps, with the pending events with earlier expected resolution deadline timestamps being placed before the pending events with later expected resolution deadline timestamps.

[0106] S304: Add the sorted pending events to the latest task queue.

[0107] In this embodiment, the expected resolution deadline of each event is compared with the current time. If the expected resolution deadline of an event is later than the current time, the system will mark it as an "urgent pending event." In actual applications, an urgent pending event refers to a task or request that is about to reach the expected resolution deadline but has not yet been completed. This operation is an important basis for judging whether an event needs to be handled as a priority, ensuring that events that are about to expire receive timely attention. If the timestamp of the expected resolution deadline of an event is later than the current timestamp, it means that the event has not expired and is pending. The system will update the status of the event and mark it as an imminent unprocessed state.

[0108] Once the system identifies pending events, it sorts them by priority. High-priority pending events are placed before lower-priority events. This ranking ensures that high-priority events are addressed first, preventing delays in important tasks. Priority levels are typically defined by parameters specified when the event is created or generated through intelligent system analysis. These priorities may be based on task urgency, user role, or historical processing data.

[0109] When multiple pending events have the same priority, the system further sorts them based on their expected resolution deadline timestamps. Events with earlier expected resolution deadlines are prioritized over other events of the same priority. This sorting ensures that events with earlier deadlines are prioritized. Events with earlier expected resolution deadlines are typically more urgent and should be addressed as soon as possible to avoid further business impact.

[0110] Eventually, the sorted pending events are added to the latest task queue, awaiting further processing. The task queue is typically a prioritized list, and the system continuously updates this queue based on the status and priority of each event to ensure orderly processing. The task queue is automatically updated, reflecting the status and priority of each event in real time, thereby improving overall task processing efficiency.

[0111] In one specific implementation, the system regularly checks the expected resolution deadlines of all outstanding events. This operation can be performed through database triggers or scheduled tasks, ensuring that the time status of all outstanding events is updated promptly. If the expected resolution deadline for an event approaches the current time, the system automatically marks it as pending and adds it to a priority queue. Prioritization can be performed using custom rules or machine learning models. For example, the system can automatically assign priorities based on the nature of the event (such as a customer complaint or funding application), or allow users to specify a priority level when creating an event. The system then sorts pending events based on this priority information, ensuring that the most urgent tasks are handled promptly. If multiple pending events have the same priority, the system automatically sorts them in ascending order of expected resolution deadlines. This ensures that tasks with more urgent processing times are processed first, preventing them from being missed during processing. This functionality can be implemented through an ORDER BY statement in the database query language or by using a backend service to sort events. Updating the task queue is a crucial component of the system. The task queue not only reflects the current status and processing priority of tasks but also influences system resource allocation and processing efficiency. Whenever a new pending task is added to the queue, the system recalculates the order in which tasks should be processed. The task queue can be managed through memory management or a distributed queue system to ensure the order and timeliness of task processing.

[0112] Example: During the insurance claims process, claims typically need to be processed within a specific timeframe. Suppose a customer submits a claim, and the system automatically assigns a priority and expected resolution deadline to the claim. If the claim's expected resolution deadline is close to the current time, the system adds it to the latest task queue based on its priority and chronological order, ensuring that the insurance claims department prioritizes these upcoming claims. If multiple claims have the same priority, the system sorts them by their expected resolution deadline timestamps, prioritizing those closer to their expiration date to avoid customer dissatisfaction and potential risks.

[0113] This embodiment dynamically manages the task queue based on event imminence and priority, ensuring that the most urgent tasks are processed first. By sorting by priority and ascending timestamp, pending events are handled promptly, avoiding delays caused by delayed tasks. The system automatically updates the task queue, improving task processing efficiency and reducing the need for manual intervention, thereby enhancing the automation and accuracy of the workflow.

[0114] In one embodiment, after the above step S30, the method further includes:

[0115] S305, scanning the pending events in the latest task queue to detect whether there is a pending event marked as suspended or with a lowered priority level;

[0116] S306, if there is an impending event marked as suspended or with a priority level lowered, assigning a preset visual distinguishing identifier to the impending event marked as suspended or with a priority level lowered, and associating the visual distinguishing identifier with the corresponding event identifier and storing it in a visual identifier field of the event processing database;

[0117] S307, adjusting the rendering parameters of the visual distinguishing mark according to the display resolution and screen color gamut parameters of the user terminal;

[0118] S308: Push the latest task queue containing the visual distinguishing identifier to the user terminal.

[0119] In this embodiment, the system will compare the expected resolution deadline of the task with the current time. If the expected resolution deadline of the task is later than the current time, the event will be marked as an "urgent event". The processing priority of urgent events is very high, so the event needs to be added to the latest task queue immediately. In actual operation, the update of the task queue can be sorted based on the priority level of the task, and high-priority urgent events will be placed at the front of the queue. The update of the task queue is a dynamic process, which ensures the priority processing of urgent tasks to improve overall work efficiency and reduce the risk of delays.

[0120] Next, the system scans the pending events in the latest task queue to detect whether there are any tasks marked as paused or with a lowered priority level. The paused status of a task usually means that the task has been temporarily interrupted for some reason but has not yet been completed, while a lowered priority level means that the importance or urgency of the task has changed. These events require special identification so that staff can quickly identify them. For these tasks, the system will assign preset visual distinguishing marks, such as colors, icons, or text labels, to help users quickly find these tasks that require special attention in the task list.

[0121] The system assigns visual identifiers to pending events marked as paused or with a lowered priority. These identifiers typically include visual elements such as brightened color, status icons, or text labels. These visual identifiers can be implemented through simple UI operations, such as using a specific color background to indicate a paused state, or using icons (such as a pause symbol or a down arrow) to indicate a lowered priority. All visual identifiers and their corresponding event identifiers are stored in the visual identifier field of the event processing database for subsequent query and update.

[0122] User terminals may have different hardware parameters, such as device type, display resolution, and screen color gamut. To ensure consistency in visual identification across different devices, the system adjusts the logo's rendering parameters based on the user's terminal's display resolution and screen color gamut. By appropriately adjusting rendering parameters (such as color brightness, contrast, or icon size), the task logo is clearly displayed on all types of terminal devices, avoiding any impact on logo recognition due to device differences.

[0123] Finally, the latest task queue, visually distinguished by a visual indicator, is pushed to the user's terminal, ensuring that workers are immediately aware of the updated task list. Task queues pushed to the terminal include at least one visual indicator: a brightened color, a status icon, or a text label. Furthermore, to ensure that users receive updated task queues in real time, the system simultaneously triggers a refresh command on the terminal interface. This allows users to instantly see changes in task status or identifiers, improving responsiveness and overall productivity.

[0124] In different implementations, different technical means can be adopted for the generation and push of visual identification. For example, on the mobile side, push notifications and color highlights on the interface are used to show the importance of the task. On the PC side, pop-up windows and icons in the status bar can be used to prompt the user's attention. If the task involves multiple users or teams, the system can dynamically adjust the task queue according to the assigned task priority to ensure that the most important tasks can be processed in a timely manner. Devices and screen configurations on different platforms may result in different display effects. Therefore, when pushing task queues, the system should adapt to different display resolutions and hardware parameters to ensure consistency of visual effects. The priority level, pause status and priority reduction judgment of the task can be dynamically adjusted through the rule engine configured in the system. When new information or higher priority events appear during event processing, the system can respond in real time and update the task queue and regenerate the visual identification. According to different user needs, the system can provide a variety of visual prompts, including but not limited to color changes, icon updates or text label prompts.

[0125] Example: During the insurance claims process, a task may be paused or delayed for various reasons. For example, a claim may require additional documentation from a customer, but while the claim is pending, the task is marked as paused. In this case, the system scans the latest task queue, detects pending tasks marked as paused, and assigns them a special visual indicator, such as a gray background and a "pause" icon. Paused tasks are distinguished to alert staff that they are currently unavailable, ensuring that resources are not wasted on paused tasks. If a task's priority is lowered, the system assigns a color indicator to the task based on the priority rules, typically a yellow background and a "priority lowered" icon, to remind staff that the task's urgency has decreased and that it can be delayed. While tasks are paused, the system pushes these tasks to the user terminal based on the task queue scan results, visually indicating them as paused or with a lowered priority. The user terminal adjusts the visual indicator based on the device's screen color gamut and display resolution parameters, ensuring that staff can quickly identify these tasks in special status and respond appropriately.

[0126] By dynamically updating the task queue and assigning visual identifiers, this embodiment can significantly improve work efficiency and reduce work delays caused by missed tasks or improper priority handling. The task queue display can be dynamically updated based on the task's paused status or priority reduction mark, ensuring that task management and processing meet actual needs and avoiding resource waste or delays in task processing. At the same time, by adjusting the rendering parameters of the visual identifier, the system can adapt to the display characteristics of different terminal devices, ensuring that the identifier can be clearly presented on various devices, thereby improving the user experience.

[0127] In one embodiment, the above step S50 includes:

[0128] S501, based on the historical event processing efficiency and the current load of the latest task queue, a dynamic reminder threshold is generated through a machine learning model;

[0129] S502, if the difference is greater than the dynamic reminder threshold and less than or equal to the preset reminder threshold, generate a primary reminder event;

[0130] S503: If the difference is less than or equal to the dynamic reminder threshold, generate a high-level reminder event;

[0131] S504, matching the appropriate push protocol based on the device type of the user terminal and the current network status;

[0132] S505: Sending the primary reminder event or the advanced reminder event to the user terminal via the push protocol;

[0133] S506, if the user terminal does not perform an operation on the advanced reminder event within the preset response time, the corresponding pending event is marked as urgent and inserted into the head of the latest task queue;

[0134] S507: Synchronize the emergency status mark and the update timestamp to the event processing database.

[0135] In this embodiment, when the expected resolution deadline of a task is later than the current time but is still not completed, the system determines the urgency of the task by calculating the "difference" (i.e., the difference between the expected resolution time and the current time), and generates a corresponding reminder event based on this difference.

[0136] When a task approaches the expected resolution deadline, the system will dynamically adjust the intensity of the reminder based on the degree of proximity to ensure that the task can be processed in a timely manner.

[0137] A machine learning model generates a dynamic reminder threshold based on historical event processing efficiency and the current task queue load. This threshold is not fixed but dynamically adjusts as system load and historical processing efficiency change. The machine learning model is trained based on historical data (such as task processing time, queue length, and handler response speed) to automatically calculate the most appropriate reminder trigger threshold based on different task conditions and load conditions. This ensures that reminders are triggered promptly and appropriately under different workload conditions, avoiding premature or late reminders.

[0138] When the difference is less than or equal to the preset reminder threshold, the system determines the intensity of the reminder based on the calculated difference. If the difference is less than or equal to the dynamic reminder threshold, it means that the task is very close to the expected resolution deadline and there is still a chance to process it in time, so a high-level reminder event needs to be generated to ensure that the task is processed as soon as possible. For example, these reminders usually directly attract the user's attention through pop-ups, vibrations, etc. When the difference is greater than the dynamic reminder threshold but is still within the preset reminder threshold, it means that the task is still a certain amount of time away from the expected resolution deadline but is also relatively urgent. The system will generate a primary reminder event to remind the user in a gentler way (such as text messages, emails, etc.).

[0139] The system will match the appropriate push protocol based on the user's device type (e.g., mobile, PC) and current network status (e.g., online or offline). This ensures that users of different devices receive reminders in a timely manner and that reminders are delivered reliably under varying network conditions.

[0140] If the user terminal does not take action on a high-level alert within the preset response time, the system marks the corresponding pending event as urgent and inserts it at the head of the task queue to ensure it receives priority processing. The urgent status flag and update timestamp are synchronized with the event processing database to maintain data consistency and real-time performance.

[0141] In practical applications, machine learning models can be trained based on different task types and historical processing data to adjust alert thresholds. For example, for more urgent tasks (such as fraud detection in banking systems or medical emergencies), the system might set a lower dynamic alert threshold, while for routine, lower-priority tasks (such as standard customer service issues), the dynamic alert threshold might be higher. By adjusting the alert threshold based on real-time system load and task urgency, work efficiency can be improved and "alert fatigue" caused by excessive alerts can be avoided. The adaptability of push protocols across different devices is crucial. Mobile devices may require more frequent and direct alerts, such as vibration or pop-up windows, while PCs can use desktop notifications or email notifications. By matching the appropriate push protocol, different devices can smoothly receive and process alerts. Furthermore, pre-set response times and emergency status flag handling mechanisms can be customized to suit different business scenarios. For example, in the healthcare industry, response times might be set to be shorter to ensure timely processing of urgent tasks; whereas in the banking sector, response times for non-urgent financial tasks might be longer to avoid unnecessary emergency response.

[0142] Example: In an insurance claims scenario, for example, if the expected resolution period for a claim is 48 hours, but the current time is 47 hours, the calculated difference is 1 hour. In this case, the system will generate a high-level reminder event, such as a pop-up reminder or vibration reminder, to ensure that the claims adjuster can handle the case immediately. If the difference is larger, such as within 12 hours but greater than the dynamic reminder threshold, the system will generate a low-level reminder event, notifying the claims adjuster via email or text message that the processing deadline is approaching.

[0143] This embodiment dynamically adjusts the reminder threshold based on real-time task load and historical processing efficiency, ensuring that the timing and intensity of the reminder mechanism are more in line with actual needs, thereby improving the efficiency of task management. By generating reminder events of different levels, the urgency of the task can be more accurately reflected, avoiding the risk of tasks being ignored or overly interfered with. In addition, the dynamic adjustment of emergency status markings and task queues can effectively increase the priority of task processing, reduce the backlog of pending tasks, ensure timely processing of tasks, and avoid further delays.

[0144] In one embodiment, the above step S60 includes:

[0145] S601, receiving an event status update instruction returned by the user terminal, and parsing the operation type and the corresponding target event identifier in the event status update instruction;

[0146] S602, if the operation type is completed, remove the target pending event corresponding to the target event identifier from the latest task queue, migrate the target pending event to the completed event partition of the event processing database, and update the status of the target pending event to completed;

[0147] S603: If the operation type is postpone, parse the new expected resolution deadline timestamp in the event status update instruction, update the expected resolution deadline timestamp of the target urgent pending event to the new expected resolution deadline timestamp, and update the status mark of the target urgent pending event to postpone.

[0148] S604: If the operation type is delay, the status of the target pending event is updated to delay, the delay start timestamp is recorded, a delay alarm event is generated, and pushed to the responsible terminal;

[0149] S605: Write the operation type, target event identifier, operation timestamp, and user identifier into the event processing history chain.

[0150] In this embodiment, the system first receives an event status update instruction from a user terminal. These instructions are typically triggered by the task leader or automatically by the system. The instruction includes the action type (e.g., completed, postponed, delayed) and the target event identifier (i.e., the unique identifier of the task). The purpose of parsing the instruction is to extract the event identifier and action type from it. Subsequent operations will use this information to update the task status.

[0151] When the action type is "Completed," it indicates that the pending event has been processed. The system removes the event from the latest task queue, ensuring that the queue no longer displays completed pending events. The event's status is then updated to "Completed," and the event is moved to the completed events partition in the database. This partition stores all completed events, providing data support for subsequent historical queries and statistical analysis.

[0152] When the action type is "Postpone," it indicates that the pending event needs to be postponed. The system interprets the new expected resolution deadline timestamp in the instruction as the postponed completion time. The system updates the expected resolution deadline based on the new timestamp and changes the event status to "Postpone." This action typically occurs when an event cannot be completed as planned due to external reasons (such as awaiting third-party feedback).

[0153] If the action type is "Delayed," it indicates that an impending event cannot be completed on time due to various reasons. However, it has not yet reached the overdue stage and is only in a warning state requiring an adjustment to the estimated time. At this point, the system updates the event status to "Delayed" and records the delay start timestamp, which marks the specific time when the event entered the delayed state. The system also generates a delay alert event and pushes it to the responsible terminal, alerting the relevant personnel to take urgent action.

[0154] All operations are recorded in the event processing history chain. Each status update records the operation type, target event identifier, operation timestamp, and user ID, allowing for subsequent tracing and analysis of the event processing process. The history chain provides a detailed operation track, helping managers evaluate the efficiency and accuracy of event processing and providing data support for optimizing similar events in the future.

[0155] In one specific implementation method, the system first needs to have the ability to receive and parse event status update instructions sent by the user terminal. The format and content of the instructions can be customized according to the specific application scenario. For example, a JSON format structure can be used to transmit instructions, which includes event identifiers, operation types, timestamps and other information. By parsing these instructions, the system can extract key event information and perform corresponding status updates based on the operation type. For the "complete" operation, the system needs to find the corresponding event in the latest task queue and remove it from the queue. After removal, the event will be stored in the "completed events" partition of the database, which is used to store all completed events and provide query and analysis support for completed events.

[0156] When processing "postponement" and "delay" operations, the system will update the event record in the database according to the new expected resolution deadline or delay start timestamp specified by the user. When the event status is updated to "delay", the system will generate a delay alarm event and deliver the event to the responsible terminal via push notification. These terminals may be specific staff terminals or the devices of the management personnel responsible for the event. The notification method can select different push protocols (such as SMS, email, APP notification, etc.) according to the urgency of the event and the user's device.

[0157] Every update to the event status is recorded in the event processing history chain. This history chain record includes not only the operation type and timestamp, but also the user identifier of the operation. This historical record provides essential data support for subsequent event analysis, helping managers review the event handling process, evaluate the effectiveness of the handling, and identify potential bottlenecks or delays.

[0158] This embodiment provides an efficient event management framework through real-time updates of pending event status and historical tracing of operation records. When handling pending events, it can flexibly respond to different event status changes and ensure event processing efficiency and accuracy. By promptly alerting and assigning responsibilities for delayed events, it ensures that events approaching expiration or with adjusted processing times receive timely attention and processing. Furthermore, through historical chain records, the system can provide detailed event processing records, facilitating subsequent audits, optimization, and efficiency assessments.

[0159] In one embodiment, after the above step S60, the method further includes:

[0160] S701, extracting the completion mark of the completed event, the postponement mark of the postponed event, and the delay mark of the delayed event from the event processing history chain;

[0161] S702, counting the number of completed events according to the completion marks, and determining the ratio of the number of completed events to the total number of pending events to generate an event completion rate;

[0162] S703, counting the number of deferred processing events according to the deferred mark, and determining the ratio of the number of deferred processing events to the total number of status update operations to generate a deferred processing frequency;

[0163] S704, counting the total number of delay processing events according to the delay mark to generate a delay processing number;

[0164] S705, assigning a weight to each delayed processing event according to the priority level of the pending events, and generating a weighted score for delayed processing;

[0165] S706, determining a delayed processing penalty point based on the delayed processing frequency and a preset delayed penalty coefficient;

[0166] S707, determining a final performance score based on the event completion rate, delayed processing weighted score, and delayed processing penalty points;

[0167] S708: Integrate the event completion rate, delayed processing frequency, delayed processing quantity and final performance score into visual performance feedback data.

[0168] In this embodiment, the system first extracts three key markers from the event processing history chain: the completed marker, the postponed marker, and the delayed marker. These markers record the final status of the event and the significant changes in the processing process during the lifecycle of the pending event. The completed marker indicates that the event has been completed; the postponed marker indicates that the expected resolution date of the event has been extended; and the delayed marker indicates that the event was not processed within the scheduled resolution date and requires special attention. By analyzing these markers, the system can accurately understand the status of each event during its processing.

[0169] By counting completed events, the system calculates the number of completed events. Furthermore, the system calculates the ratio of completed events to the total number of pending events, which is the event completion rate. This metric reflects the efficiency of event completion. Especially when handling pending events, a higher event completion rate indicates a stronger system's handling capability and efficiency.

[0170] By counting deferred events, the system can calculate the number of deferred events. The system then calculates the ratio of deferred events to the total number of status updates, which is the deferred frequency. This metric helps the system identify how often events are deferred; excessive delays may indicate problems or bottlenecks in the event management process.

[0171] By counting delayed events, the system calculates the number of delayed events and uses this as the number of delayed events. This metric directly reflects the system's timeliness and responsiveness in handling pending events. If there are significant delays, improvement measures may be needed to ensure timely completion.

[0172] When calculating the weighted score for delay handling, the system assigns a weight to each delayed event based on the priority level of pending events. High-priority events, due to their importance, typically warrant prioritization and therefore receive a higher weighted score. This weighted score allows the system to identify which high-priority events are experiencing the most significant delays and adjust subsequent handling strategies accordingly.

[0173] The system calculates a penalty point based on the frequency of delays and a preset penalty coefficient. The penalty coefficient reflects the severity of the delay. The higher the coefficient, the more frequent the delays, and the more points will be deducted. This penalty mechanism effectively encourages timely completion of events and reduces delays.

[0174] The system calculates a final performance score based on the event completion rate, weighted score for delays, and penalty points for late processing. This score comprehensively reflects the overall quality of event handling, taking into account factors such as event completion efficiency, delays, and the frequency of delays.

[0175] In practical applications, event flags (such as completed, deferred, and delayed) are typically stored in an event processing database. Each event in the database has a corresponding status flag, which is dynamically updated based on the progress of the event. To facilitate subsequent analysis, all flag information can be stored as a timestamp and mapped to the event identifier. This allows the system to easily trace and analyze the processing progress of each event.

[0176] The system regularly scans event records in the database and counts each event's marking status. For example, the system can scan the event processing history chain daily or hourly to obtain the latest data for each marking. For completed markings, the system calculates the number of completed events and compares this with the number of pending events to calculate the event completion rate. Similarly, for deferred and delayed markings, the system calculates the number of deferred and delayed events, and uses this data to calculate the deferred processing frequency and the number of delayed events.

[0177] When implementing performance scoring, the system not only evaluates event completion but also considers event priority. Delays and postponements are more severe for high-priority events, so when calculating weighted scores, the system assigns higher weights to high-priority events. The performance scoring formula incorporates these factors to generate a final performance score and provide real-time feedback to users.

[0178] The system also needs to generate visual feedback based on calculated performance scores, event completion rates, and other data. Using charts (such as bar charts and line graphs) or heat maps, users can intuitively understand the completion status of events, as well as the distribution of delays and postponements. To improve management efficiency, the system can also provide a comprehensive scorecard, consolidating multiple performance indicators into a single, easy-to-understand score, helping managers make faster decisions.

[0179] This embodiment uses statistics and analysis of various markers during event processing to comprehensively evaluate events and generate a performance score reflecting event processing efficiency. This not only helps managers identify bottlenecks in event processing but also provides improvement plans to improve event processing efficiency. Through visual feedback, the system helps users monitor task progress in real time, ensuring that pending events receive timely attention and processing.

[0180] In one embodiment, an event processing and reminder device is provided, which corresponds one-to-one with the event processing and reminder method in the above embodiment. Figure 3 , Figure 3This is a functional module diagram of a preferred embodiment of the event processing and reminder device of the present invention. It includes an event receiving and storage module 10, an event traversal and comparison module 20, an event marking and task queue management module 30, a task queue scanning and difference analysis module 40, a reminder generation and push module 50, and an event status update and synchronization module 60. Each functional module is described in detail below:

[0181] An event receiving and storing module 10 is configured to receive unfinished events and store them in an event processing database, wherein the unfinished events are set with corresponding expected resolution deadlines and priority levels;

[0182] An event traversal and comparison module 20 is configured to traverse the unfinished events in the event processing database at preset time intervals and compare the expected resolution deadlines of the unfinished events with the current time;

[0183] An event marking and task queue management module 30 is configured to mark the unfinished events whose expected resolution deadline is later than the current time as pending events, and add the pending events to the latest task queue according to the corresponding priority level;

[0184] The task queue scanning and difference analysis module 40 is used to scan the pending events in the latest task queue and determine the difference between the expected resolution deadline of each pending event and the current time;

[0185] The reminder generation and push module 50 is used to generate a reminder event corresponding to the pending event when the difference is less than or equal to a preset reminder threshold, and push the reminder event to the user terminal;

[0186] The event status update and synchronization module 60 is configured to receive the event status update instruction returned by the user terminal, update the status of the corresponding pending event in the latest task queue according to the event status update instruction, and synchronize it to the event processing database.

[0187] In one embodiment, the event receiving and storing module 10 is specifically configured to:

[0188] Receive an event creation request, and extract the user ID, event title, description information, expected resolution period, and priority level from the event creation request;

[0189] Querying a user authority database based on the user ID to verify the legitimacy of the user ID and the event creation authority;

[0190] If the verification is successful, the event identifier generation module is called to generate an event identifier based on the timestamp, user ID and random hash value;

[0191] If the priority level is not specified in the event creation request, a default priority level is generated as the priority level based on keyword matching of the event title with a preset priority rule library;

[0192] If the expected resolution deadline is not specified in the event creation request, generating a default expected resolution deadline as the expected resolution deadline based on the default priority level through a deadline analysis model;

[0193] Binding the event title, description information, expected resolution period, priority level, and user ID to the event identifier to generate a structured unfinished event;

[0194] The structured unfinished events are assigned to an unfinished event partition of an event processing database according to a hash value of the event identifier, and an event identifier index is established.

[0195] In one embodiment, the event marking and task queue management module 30 is specifically configured to:

[0196] If the expected resolution deadline timestamp of an unfinished event is less than the current timestamp, the unfinished event is determined to be an impending event, and the status of the impending event is updated in the event processing database as an impending unprocessed state;

[0197] sorting the pending events from high to low priority, with the pending events with high priority being placed before the pending events with low priority;

[0198] When there are multiple pending events with the same priority level, they are sorted in ascending order according to the expected resolution deadline timestamps of each pending event. The pending events with earlier expected resolution deadline timestamps are placed before the pending events with later expected resolution deadline timestamps.

[0199] Add the sorted pending events to the latest task queue.

[0200] In one embodiment, the event marking and task queue management module 30 is specifically configured to:

[0201] Scan the pending events in the latest task queue to detect whether there are pending events marked as suspended or with a lowered priority level;

[0202] If there is an impending event marked as suspended or with a lowered priority level, a preset visual distinguishing identifier is assigned to the impending event marked as suspended or with a lowered priority level, and the visual distinguishing identifier is associated with the corresponding event identifier and stored in a visual identifier field of the event processing database;

[0203] Adjusting the rendering parameters of the visual distinguishing mark according to the display resolution and screen color gamut parameters of the user terminal;

[0204] Push the latest task queue containing the visual distinguishing identifier to the user terminal.

[0205] In one embodiment, the reminder generation and push module 50 is specifically configured to:

[0206] Generate dynamic alert thresholds through machine learning models based on historical event processing efficiency and the current load of the latest task queue;

[0207] If the difference is greater than the dynamic reminder threshold and less than or equal to the preset reminder threshold, a primary reminder event is generated;

[0208] If the difference is less than or equal to the dynamic reminder threshold, generating a high-level reminder event;

[0209] Match the appropriate push protocol based on the device type and current network status of the user terminal;

[0210] Sending the primary reminder event or the advanced reminder event to the user terminal through the push protocol;

[0211] If the user terminal does not perform an operation on the advanced reminder event within the preset response time, the corresponding pending event will be marked as urgent and inserted into the head of the latest task queue;

[0212] Synchronize the emergency status flag and update timestamp to the incident processing database.

[0213] In one embodiment, the event status update and synchronization module 60 is specifically configured to:

[0214] receiving an event status update instruction returned by the user terminal, and parsing the operation type and the corresponding target event identifier in the event status update instruction;

[0215] If the operation type is completed, the target pending event corresponding to the target event identifier is removed from the latest task queue, and the target pending event is migrated to the completed event partition of the event processing database, and the status of the target pending event is updated to be completed;

[0216] If the operation type is postpone, then parse the new expected resolution deadline timestamp in the event status update instruction, update the expected resolution deadline timestamp of the target pending event to the new expected resolution deadline timestamp, and update the status mark of the target pending event to postpone;

[0217] If the operation type is delay, the status of the target pending event is updated to delay, the delay start timestamp is recorded, a delay alarm event is generated and pushed to the responsible terminal;

[0218] The operation type, target event identifier, operation timestamp and user identifier are written into the event processing history chain.

[0219] In one embodiment, the event status update and synchronization module 60 is specifically configured to:

[0220] Extract the completion mark of the completed event, the deferred mark of the deferred processing event, and the delay mark of the delayed processing event from the event processing history chain;

[0221] Counting the number of completed events according to the completion marks, and determining the ratio of the number of completed events to the total number of pending events to generate an event completion rate;

[0222] Counting the number of deferred processing events according to the deferred mark, and determining the ratio of the number of deferred processing events to the total number of state update operations to generate a deferred processing frequency;

[0223] Counting the total number of delayed processing events according to the delay mark to generate a delayed processing number;

[0224] According to the priority level of pending events, each delayed processing event is assigned a weight according to the priority level to generate a weighted score for delayed processing;

[0225] Determining the deduction points for delayed processing based on the delayed processing frequency and a preset delay penalty coefficient;

[0226] The final performance score is determined based on the completion rate of the event, the weighted score for delayed processing, and the penalty points for delayed processing;

[0227] The event completion rate, delayed processing frequency, delayed processing quantity and final performance score are integrated into visual performance feedback data.

[0228] In one embodiment, a computer device is provided. The computer device may be a server, and its internal structure diagram may be as follows: Figure 4As shown. The computer device includes a processor, memory, network interface and database connected via a system bus. The processor of the computer device is used to provide computing and control capabilities. The memory of the computer device includes non-volatile and / or volatile storage media and internal memory. The non-volatile storage medium stores an operating system, a computer program and a database. The internal memory provides an environment for the operation of the operating system and computer program in the non-volatile storage medium. The network interface of the computer device is used to communicate with an external user terminal via a network connection. When the computer program is executed by the processor, it implements the functions or steps of the service side of an event processing and reminder method.

[0229] In one embodiment, a computer device is provided. The computer device may be a user terminal, and its internal structure diagram may be as follows: Figure 5 As shown. The computer device includes a processor, memory, network interface, display screen and input device connected via a system bus. The processor of the computer device is used to provide computing and control capabilities. The memory of the computer device includes a non-volatile storage medium and an internal memory. The non-volatile storage medium stores an operating system and a computer program. The internal memory provides an environment for the operation of the operating system and computer program in the non-volatile storage medium. The network interface of the computer device is used to communicate with an external server via a network connection. When the computer program is executed by the processor, it realizes the functions or steps of a user-side event processing and reminder method.

[0230] In one embodiment, a computer device is provided, including a memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the computer program, the following steps are performed:

[0231] Receiving unfinished events and storing the unfinished events in an event processing database, wherein the unfinished events are set with corresponding expected resolution deadlines and priority levels;

[0232] Traversing the unfinished events in the event processing database at preset time intervals, and comparing the expected resolution deadlines of the unfinished events with the current time;

[0233] Mark the unfinished events whose expected resolution deadline is later than the current time as pending events, and add the pending events to the latest task queue according to the corresponding priority level;

[0234] Scan the pending events in the latest task queue to determine the difference between the expected resolution deadline of each pending event and the current time;

[0235] When the difference is less than or equal to a preset reminder threshold, a reminder event corresponding to the pending event is generated and the reminder event is pushed to the user terminal;

[0236] Receive the event status update instruction returned by the user terminal, update the status of the corresponding pending event in the latest task queue according to the event status update instruction, and synchronize it to the event processing database.

[0237] In one embodiment, a computer-readable storage medium is provided, on which a computer program is stored. When the computer program is executed by a processor, the following steps are implemented:

[0238] Receiving unfinished events and storing the unfinished events in an event processing database, wherein the unfinished events are set with corresponding expected resolution deadlines and priority levels;

[0239] Traversing the unfinished events in the event processing database at preset time intervals, and comparing the expected resolution deadlines of the unfinished events with the current time;

[0240] Mark the unfinished events whose expected resolution deadline is later than the current time as pending events, and add the pending events to the latest task queue according to the corresponding priority level;

[0241] Scan the pending events in the latest task queue to determine the difference between the expected resolution deadline of each pending event and the current time;

[0242] When the difference is less than or equal to a preset reminder threshold, a reminder event corresponding to the pending event is generated and the reminder event is pushed to the user terminal;

[0243] Receive the event status update instruction returned by the user terminal, update the status of the corresponding pending event in the latest task queue according to the event status update instruction, and synchronize it to the event processing database.

[0244] It should be noted that the above functions or steps that can be implemented by the computer-readable storage medium or computer device can be found in the relevant descriptions of the server side and the user side in the aforementioned method embodiment. To avoid repetition, they will not be described one by one here.

[0245] Those skilled in the art will appreciate that all or part of the processes in the above-mentioned embodiments can be implemented by instructing the relevant hardware through a computer program. The computer program can be stored in a non-volatile computer-readable storage medium. When the computer program is executed, it can include the processes of the embodiments of the above-mentioned methods. Among them, any reference to memory, storage, database or other media used in the embodiments provided in this application can include non-volatile and / or volatile memory. Non-volatile memory can include read-only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM) or flash memory. Volatile memory can include random access memory (RAM) or external cache memory. By way of illustration and not limitation, RAM is available in various forms, such as static RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), double data rate SDRAM (DDRSDRAM), enhanced SDRAM (ESDRAM), synchronous link (Synchlink) DRAM (SLDRAM), memory bus (Rambus) direct RAM (RDRAM), direct memory bus dynamic RAM (DRDRAM), and memory bus dynamic RAM (RDRAM).

[0246] Those skilled in the art will clearly understand that for the sake of convenience and brevity of description, only the division of the above-mentioned functional units and modules is used as an example. In actual applications, the above-mentioned functions can be distributed and completed by different functional units and modules as needed, that is, the internal structure of the device can be divided into different functional units or modules to complete all or part of the functions described above.

[0247] It should be noted that if any software tools or components other than those of the Company appear in the embodiments of this application, they are merely for illustration and do not represent actual use. The above embodiments are intended only to illustrate the technical solutions of the present invention, not to limit them. Although the present invention has been described in detail with reference to the above embodiments, those skilled in the art should understand that they can still modify the technical solutions described in the above embodiments, or replace some of the technical features therein with equivalents. These modifications or replacements do not deviate the essence of the corresponding technical solutions from the spirit and scope of the technical solutions of the embodiments of the present invention, and should all be included in the scope of protection of the present invention.

Claims

1. An event processing and reminder method, characterized in that: The following steps are involved: Receiving unfinished events and storing the unfinished events in an event processing database, wherein the unfinished events are set with corresponding expected resolution deadlines and priority levels; Traversing the unfinished events in the event processing database at preset time intervals, and comparing the expected resolution deadlines of the unfinished events with the current time; Mark the unfinished events whose expected resolution deadline is later than the current time as pending events, and add the pending events to the latest task queue according to the corresponding priority level; Scan the pending events in the latest task queue to determine the difference between the expected resolution deadline of each pending event and the current time; When the difference is less than or equal to a preset reminder threshold, a reminder event corresponding to the pending event is generated and the reminder event is pushed to the user terminal; Receive the event status update instruction returned by the user terminal, update the status of the corresponding pending event in the latest task queue according to the event status update instruction, and synchronize it to the event processing database.

2. The event processing and reminder method according to claim 1, wherein: Receive unfinished events and store them in an event processing database, wherein the unfinished events are set with corresponding expected resolution deadlines and priority levels, including: Receive an event creation request, and extract the user ID, event title, description information, expected resolution period, and priority level from the event creation request; Querying a user authority database based on the user ID to verify the legitimacy of the user ID and the event creation authority; If the verification is successful, the event identifier generation module is called to generate an event identifier based on the timestamp, user ID and random hash value; If the priority level is not specified in the event creation request, a default priority level is generated as the priority level based on keyword matching of the event title with a preset priority rule library; If the expected resolution deadline is not specified in the event creation request, generating a default expected resolution deadline as the expected resolution deadline based on the default priority level through a deadline analysis model; Binding the event title, description information, expected resolution period, priority level, and user ID to the event identifier to generate a structured unfinished event; The structured unfinished events are assigned to an unfinished event partition of an event processing database according to a hash value of the event identifier, and an event identifier index is established.

3. The event processing and reminder method according to claim 1, wherein: Marking the unfinished events whose expected resolution deadlines are later than the current time as pending events, and adding the pending events to the latest task queue according to the corresponding priority levels, including: If the expected resolution deadline timestamp of an unfinished event is later than the current timestamp, the unfinished event is determined to be an impending event, and the status of the impending event is updated in the event processing database as an impending unprocessed state; sorting the pending events from high to low priority, with the pending events with high priority being placed before the pending events with low priority; When there are multiple pending events with the same priority level, they are sorted in ascending order according to the expected resolution deadline timestamps of each pending event. The pending events with earlier expected resolution deadline timestamps are placed before the pending events with later expected resolution deadline timestamps. Add the sorted pending events to the latest task queue.

4. The event processing and reminder method according to claim 1, wherein: After marking the unfinished events whose expected resolution deadlines are later than the current time as pending events, and adding the pending events to the latest task queue according to the corresponding priority levels, the method further includes: Scan the pending events in the latest task queue to detect whether there are pending events marked as suspended or with a lowered priority level; If there is an impending event marked as suspended or with a priority level lowered, a preset visual distinguishing identifier is assigned to the impending event marked as suspended or with a priority level lowered, and the visual distinguishing identifier is associated with the corresponding event identifier and stored in a visual identifier field of the event processing database; Adjusting the rendering parameters of the visual distinguishing mark according to the display resolution and screen color gamut parameters of the user terminal; Push the latest task queue containing the visual distinguishing identifier to the user terminal.

5. The event processing and reminder method according to claim 1, wherein: When the difference is less than or equal to a preset reminder threshold, generating a reminder event corresponding to the pending event and pushing the reminder event to the user terminal includes: Generate dynamic alert thresholds through machine learning models based on historical event processing efficiency and the current load of the latest task queue; If the difference is greater than the dynamic reminder threshold and less than or equal to the preset reminder threshold, a primary reminder event is generated; If the difference is less than or equal to the dynamic reminder threshold, generating a high-level reminder event; Match the appropriate push protocol based on the device type and current network status of the user terminal; Sending the primary reminder event or the advanced reminder event to the user terminal through the push protocol; If the user terminal does not perform an operation on the advanced reminder event within the preset response time, the corresponding pending event will be marked as urgent and inserted into the head of the latest task queue; Synchronize the emergency status flag and update timestamp to the incident processing database.

6. The event processing and reminder method according to claim 1, wherein: Receiving the event status update instruction returned by the user terminal, updating the status of the corresponding pending event in the latest task queue according to the event status update instruction, and synchronizing it to the event processing database, including: receiving an event status update instruction returned by the user terminal, and parsing the operation type and the corresponding target event identifier in the event status update instruction; If the operation type is completed, the target pending event corresponding to the target event identifier is removed from the latest task queue, and the target pending event is migrated to the completed event partition of the event processing database, and the status of the target pending event is updated to be completed; If the operation type is postpone, then parse the new expected resolution deadline timestamp in the event status update instruction, update the expected resolution deadline timestamp of the target pending event to the new expected resolution deadline timestamp, and update the status mark of the target pending event to postpone; If the operation type is delay, the status of the target pending event is updated to delay, the delay start timestamp is recorded, a delay alarm event is generated and pushed to the responsible terminal; The operation type, target event identifier, operation timestamp and user identifier are written into the event processing history chain.

7. The event processing and reminder method according to claim 1, wherein: After receiving the event status update instruction returned by the user terminal, updating the status of the corresponding pending event in the latest task queue according to the event status update instruction, and synchronizing it to the event processing database, the method further includes: Extract the completion mark of the completed event, the deferred mark of the deferred processing event, and the delay mark of the delayed processing event from the event processing history chain; Counting the number of completed events according to the completion marks, and determining the ratio of the number of completed events to the total number of pending events to generate an event completion rate; Counting the number of deferred processing events according to the deferred mark, and determining the ratio of the number of deferred processing events to the total number of state update operations to generate a deferred processing frequency; Counting the total number of delayed processing events according to the delay mark to generate a delayed processing number; According to the priority level of pending events, each delayed processing event is assigned a weight according to the priority level to generate a weighted score for delayed processing; Determining the deduction points for delayed processing based on the delayed processing frequency and a preset delay penalty coefficient; The final performance score is determined based on the completion rate of the event, the weighted score for delayed processing, and the penalty points for delayed processing; The event completion rate, delayed processing frequency, delayed processing quantity and final performance score are integrated into visual performance feedback data.

8. An event processing and reminder device, characterized in that: The event processing and reminding device includes: An event receiving and storing module, configured to receive unfinished events and store them in an event processing database, wherein the unfinished events are set with corresponding expected resolution deadlines and priority levels; An event traversal and comparison module, configured to traverse the unfinished events in the event processing database at preset time intervals and compare the expected resolution deadlines of the unfinished events with the current time; An event marking and task queue management module is used to mark the unfinished events whose expected resolution deadline is later than the current time as pending events, and add the pending events to the latest task queue according to the corresponding priority level; A task queue scanning and difference analysis module is used to scan the pending events in the latest task queue and determine the difference between the expected resolution period of each pending event and the current time; a reminder generation and push module, configured to generate a reminder event corresponding to the pending event when the difference is less than or equal to a preset reminder threshold, and push the reminder event to a user terminal; The event status update and synchronization module is used to receive the event status update instruction returned by the user terminal, update the status of the corresponding pending event in the latest task queue according to the event status update instruction, and synchronize it to the event processing database.

9. A computer device, characterized in that: The computer device includes a memory, a processor, and an event processing and reminder program stored in the memory and capable of running on the processor. When the event processing and reminder program is executed by the processor, the steps of the event processing and reminder method as described in any one of claims 1 to 7 are implemented.

10. A computer-readable storage medium, characterized in that The storage medium stores an event processing and reminder program, which, when executed by the processor, implements the steps of the event processing and reminder method according to any one of claims 1 to 7.

Images