Task pushing method and related device

Abstract

The invention relates to the technical field of computers, and provides a task pushing method and a related device. The method comprises the steps that when it is determined that task pushing is conducted on a to-be-executed task set, target tasks recommended to be executed are screened out from all the to-be-executed tasks to be pushed on the basis of task execution duration and task failure time of all the to-be-executed tasks in combination with target pushing time. Through the task execution duration and the task failure time, the target task is screened and pushed, the to-be-executed task which is about to fail can be effectively reminded, and a recommendation object is assisted to complete as many tasks as possible before the task fails to the greatest extent, so that the overall completion degree of the task is improved.

Description

Technical Field

[0001] The present application relates to the field of computer technology and provides a task pushing method and related devices. Background Art

[0002] With the continuous development of computer technology, in order to improve production efficiency, for tasks with time-sensitive processing, task reminders are usually sent to the executors after the task is published. For example, in home school applications, to facilitate the use of teachers and students, learning reminders are sent to teachers and students after the required courses are published.

[0003] However, since this type of task is time-sensitive, a task expiration time is usually set. After the task is released, if the execution object misses the execution of the task within the task expiration time, the task will become invalid and can no longer be executed, thereby affecting the completion of the task. Summary of the Invention

[0004] The embodiments of the present application provide a task recommendation method and related devices for timely reminding execution objects associated with tasks to be executed, thereby improving task completion.

[0005] In a first aspect, an embodiment of the present application provides a task recommendation method, comprising:

[0006] When it is determined to push tasks for the set of tasks to be executed, task information of each task to be executed in the set of tasks to be executed is obtained, where each task information includes at least: the task execution time and the task expiration time of the corresponding task to be executed;

[0007] Based on the task execution time and task expiration time of each of the tasks to be executed, combined with the target push time, at least one target task that meets the set recommended execution conditions is screened out from the tasks to be executed;

[0008] Based on the at least one target task, tasks are pushed to each push object associated with the set of tasks to be executed.

[0009] In a second aspect, an embodiment of the present application provides a task recommendation device, comprising:

[0010] An information acquisition unit is configured to, when determining to push a task for a set of tasks to be executed, acquire task information of each task to be executed in the set of tasks to be executed, wherein each task information includes at least: a task execution time and a task expiration time of the corresponding task to be executed;

[0011] a task screening unit, configured to screen out at least one target task that meets a set recommended execution condition from the tasks to be executed based on the task execution duration and task expiration time of each of the tasks to be executed, in combination with the target push time;

[0012] The task pushing unit is configured to push tasks to each push object associated with the set of tasks to be executed based on the at least one target task.

[0013] As a possible implementation, when screening at least one target task that meets the set recommended execution conditions from the tasks to be executed based on the task execution duration and task expiration time of each of the tasks to be executed, combined with the target push time, the task screening unit is specifically configured to:

[0014] sorting the tasks to be executed based on their respective task expiration times to obtain a sorting result;

[0015] Based on the ranking result, in combination with the target push time and the task execution duration of each of the tasks to be executed, at least one target task that meets the set recommended execution conditions is sequentially screened out from the tasks to be executed.

[0016] As a possible implementation, based on the sorting result, in combination with the target push time and the task execution time of each of the tasks to be executed, when sequentially screening out at least one target task that meets the set recommended execution condition from the tasks to be executed, the task screening unit is specifically configured to:

[0017] Based on the sorting results, for each task to be executed, perform the following operations in sequence:

[0018] For the current task to be executed, the current accumulated duration is obtained, and based on the accumulated duration, combined with the target push time and the task execution duration of the current task to be executed, the estimated completion time of the current task to be executed is obtained;

[0019] If the estimated completion time does not exceed the task expiration time of the current task to be executed, the current task to be executed is taken as a target task, and the accumulated duration is updated based on the task execution duration of the current task to be executed.

[0020] As a possible implementation method, the task screening unit is also used to:

[0021] If the estimated completion time exceeds the task expiration time of the current task to be executed, then obtain the current target tasks;

[0022] Based on the task execution durations corresponding to the respective target tasks, selecting a target task that meets the set task replacement conditions from the target tasks;

[0023] If the task execution time of the target task is longer than the task execution time of the current task to be executed, the target task is no longer used as the target task, and the current task to be executed is used as the target task;

[0024] The accumulated duration is updated based on the respective task execution durations of the current task to be executed and the target task.

[0025] As a possible implementation, if a priority queue is used to store the target tasks, the target tasks in the priority queue are sorted according to the task execution time;

[0026] When selecting a target task that meets the set task replacement condition from the target tasks based on the task execution durations corresponding to the target tasks, the task screening unit is specifically configured to:

[0027] Selecting a target task at the head of the priority queue from the priority queue as a target task for setting a task replacement condition;

[0028] When the target task is no longer used as the target task and the current task to be executed is used as a target task, the task screening unit is specifically configured to:

[0029] The target task is removed from the priority queue, and the current task to be executed is added to the priority queue, and the queue order of the priority queue is updated according to the task execution time.

[0030] As a possible implementation, when determining to push tasks for the set of tasks to be executed, the information acquisition unit is specifically configured to:

[0031] After completing the configuration of the task set to be executed, determining to push tasks for the task set to be executed;

[0032] Determine to push tasks for the set of tasks to be executed according to the push cycle set for the set of tasks to be executed; or

[0033] When a push instruction for the to-be-executed task set is received from the management object, it is determined to push tasks for the to-be-executed task set.

[0034] As a possible implementation, when it is determined to push tasks for the set of tasks to be executed, before obtaining the task information of each task to be executed in the set of tasks to be executed, the information obtaining unit is further configured to:

[0035] When receiving a template creation instruction from a management object, creating a target task template, wherein the target task template includes template parameters and template rules, wherein the template parameters are used to configure the set of tasks to be executed, and the template rules are used to configure the task push mode;

[0036] When receiving a template parameter configuration request from a management object, obtaining and storing parameter configuration information of the template parameters carried in the template parameter configuration request, wherein the parameter configuration information includes the task identifiers of the respective tasks to be executed;

[0037] When a template rule configuration request is received from a management object, the rule configuration information of the template rule carried in the template rule configuration request is acquired and stored.

[0038] As a possible implementation, when creating the target task template, the information acquisition unit:

[0039] Obtain a list of existing templates associated with the management object;

[0040] If the number of templates included in the existing template list does not exceed the set template number threshold, a new template identifier is generated as the template identifier of the target task template, and initial configuration information of the target task template is generated based on the creation information;

[0041] In the storage space, the initial configuration information and the target template identifier are stored in association.

[0042] As a possible implementation manner, when storing the rule configuration information of the template rule carried in the template rule configuration request, the information acquisition unit:

[0043] Based on the target template identifier, obtaining the initial configuration information from the storage space;

[0044] Based on the rule configuration information, the initial configuration information is updated to obtain target configuration information, and the target configuration information is stored in the storage space.

[0045] As a possible implementation, the set of tasks to be performed is a set of courses to be learned. When acquiring task information of each task to be performed in the set of tasks to be performed, the information acquiring unit:

[0046] Obtaining the course duration corresponding to each of the to-be-learned courses in the to-be-learned course set, and using the course duration corresponding to each of the to-be-learned courses as the corresponding task execution duration;

[0047] The closing time corresponding to each course to be learned in the set of courses to be learned is obtained, and the closing time corresponding to each course to be learned is used as the corresponding task expiration time.

[0048] In a third aspect, an embodiment of the present application provides an electronic device, comprising a processor and a memory, wherein the memory stores a computer program, and when the computer program is executed by the processor, the processor executes the steps of the above method.

[0049] In a fourth aspect, an embodiment of the present application provides a computer-readable storage medium, which includes a computer program. When the computer program is run on an electronic device, the computer program is used to enable the electronic device to perform the steps of any of the above methods.

[0050] In a fifth aspect, an embodiment of the present application provides a computer program product, which includes a computer program, and the computer program is stored in a computer-readable storage medium. The processor of an electronic device reads and executes the computer program from the computer-readable storage medium, so that the electronic device performs the steps of any of the above methods.

[0051] The beneficial effects of the technical solutions provided in the embodiments of the present application include at least:

[0052] When pushing tasks for a set of pending tasks, the target tasks to be recommended are screened and pushed based on the task execution time and task expiration time of each pending task in the set. In this way, not only can reminders be given for pending tasks that are about to expire to prevent the push objects from missing the execution of tasks, but also targeted recommended task combinations can be given to the push objects, thereby assisting the recommended objects to complete as many tasks as possible before the tasks expire, thereby improving the overall completion rate of the pending tasks.

[0053] In addition, in addition to pushing pending tasks to the push object to remind it to complete the task, the filtered target tasks are also pushed to the push object. The push object does not need to select one or more pending tasks from several pending tasks, thereby improving the recommendation effect of pending tasks.

[0054] Other features and advantages of the present application will be described in the following description, and in part will become apparent from the description, or will be understood by practicing the present application. The purposes and other advantages of the present application can be realized and obtained by the structures particularly pointed out in the written description, claims, and drawings. BRIEF DESCRIPTION OF THE DRAWINGS

[0055] The drawings described herein are used to provide a further understanding of the present application and constitute a part of the present application. The illustrative embodiments of the present application and their descriptions are used to explain the present application and do not constitute an improper limitation on the present application. In the drawings:

[0056] Figure 1 A schematic diagram of an application scenario provided in an embodiment of the present application;

[0057] Figure 2 A flowchart of a task pushing method provided in an embodiment of the present application;

[0058] Figure 3 A schematic diagram of a course to be learned provided in an embodiment of the present application;

[0059] Figure 4 A schematic diagram of an array provided in an embodiment of the present application;

[0060] Figure 5 This is a schematic diagram of a processing process when traversing to Course A provided in an embodiment of the present application;

[0061] Figure 6 This is a schematic diagram of a processing process when traversing to course F provided in an embodiment of the present application;

[0062] Figure 7 This is a schematic diagram of a processing process when traversing to course E provided in an embodiment of the present application;

[0063] Figure 8 This is a schematic diagram of a processing process when traversing to course D provided in an embodiment of the present application;

[0064] Figure 9 This is a schematic diagram of a processing process when traversing to course C provided in an embodiment of the present application;

[0065] Figure 10 This is a schematic diagram of a processing process when traversing to course B provided in an embodiment of the present application;

[0066] Figure 11 This is a schematic diagram of a processing process when traversing to course G provided in an embodiment of the present application;

[0067] Figure 12 A flowchart of a method for configuring a set of tasks to be executed provided in an embodiment of the present application;

[0068] Figure 13 A schematic diagram of a template adding interface provided in an embodiment of the present application;

[0069] Figure 14 A schematic diagram of a template parameter configuration interface provided in an embodiment of the present application;

[0070] Figure 15 A schematic diagram of a course to be learned provided in an embodiment of the present application;

[0071] Figure 16 A schematic diagram of interaction between a client and a server provided in an embodiment of the present application;

[0072] Figure 17 This is a structural diagram of a task pushing device provided in an embodiment of the present application;

[0073] Figure 18 This is a schematic diagram of the structure of an electronic device provided in an embodiment of the present application. DETAILED DESCRIPTION

[0074] To make the purpose, technical solutions, and advantages of the embodiments of this application more clear, the technical solutions of this application will be clearly and completely described below in conjunction with the drawings in the embodiments of this application. Obviously, the described embodiments are part of the embodiments of the technical solutions of this application, but not all of them. Based on the embodiments described in this application document, all other embodiments obtained by ordinary technicians in this field without making creative efforts shall fall within the scope of protection of the technical solutions of this application.

[0075] In the embodiments of the present application, the term "module" or "unit" refers to a computer program or a part of a computer program that has a predetermined function and works together with other related parts to achieve a predetermined goal, and can be implemented in whole or in part by using software, hardware (such as processing circuits or memories) or a combination thereof. Similarly, a processor (or multiple processors or memories) can be used to implement one or more modules or units. In addition, each module or unit can be part of an overall module or unit that includes the function of the module or unit.

[0076] It is understandable that in the specific implementation of this application, related data such as parameter configuration information and rule configuration information are involved. When the above embodiments of this application are applied to specific products or technologies, user permission or consent is required, and the collection, use and processing of relevant data need to comply with relevant laws, regulations and standards of relevant countries and regions.

[0077] In related technologies, for tasks with time limits, task reminders are usually pushed to the executor after the task is published. For example, in a home-school application, after a course is published, learning reminders are pushed to teachers and students to facilitate their use.

[0078] However, since this type of task is time-sensitive, a task expiration time is usually set. After the task is released, if the execution object misses the execution of the task within the task expiration time, the task will become invalid and can no longer be executed, thereby affecting the completion of the task.

[0079] In an embodiment of the present application, when it is determined to push tasks for a set of tasks to be executed, the task information of each task to be executed in the set of tasks to be executed is obtained, and each task information includes the task execution duration and the task expiration time; based on the task execution duration and the task expiration time, combined with the target push time, the target tasks that meet the set recommended execution conditions are screened out from the tasks to be executed; based on the target tasks, task push is performed on each push object associated with the set of tasks to be executed.

[0080] In this way, when tasks need to be pushed, not only can you be reminded of which pending tasks are about to expire, but you can also humanely give recommended tasks to be completed before the task expires, thereby preventing the push recipient from missing the execution of the task and improving task completion.

[0081] See Figure 1 , which is a schematic diagram of an application scenario provided in an embodiment of the present application. The application scenario includes a terminal device 110 and a server 120. The number of terminal devices 110 can be one or more. The number of servers 120 can also be one or more. This application does not specifically limit the number of terminal devices 110 and servers 120.

[0082] In the embodiments of the present application, the terminal device 110 may be, but is not limited to, a smartphone, tablet computer, laptop computer, desktop computer, smart speaker, smartwatch, IoT device, intelligent voice interaction device, smart home appliance, vehicle-mounted terminal, aircraft, etc. The terminal device 110 may have a client installed therein for pushing tasks. The client may be in the form of, but is not limited to, an application, mini-program, or webpage.

[0083] Server 120 is the backend server corresponding to the client. Server 120 can be an independent physical server, a server cluster or distributed system composed of multiple physical servers, or a cloud server that provides basic cloud computing services such as cloud services, cloud databases, cloud computing, cloud functions, cloud storage, network services, cloud communications, middleware services, domain name services, security services, content delivery networks (CDNs), and big data and artificial intelligence platforms.

[0084] The terminal device 110 and the server 120 may be connected directly or indirectly via wired or wireless communication, which is not limited in this application.

[0085] In some embodiments, when the server 120 determines to push a task for a set of tasks to be executed, it obtains the task information of each task to be executed in the set of tasks to be executed, and each task information includes at least: the task execution duration and task expiration time of the corresponding task to be executed; based on the task execution duration and task expiration time of each task to be executed, combined with the target push time, at least one target task that meets the set recommended execution conditions is screened out from each task to be executed; based on at least one target task, at least one target task is sent to the terminal device of each push object associated with the set of tasks to be executed, so that the terminal device displays the pushed target task to the push object.

[0086] It should be noted that the task push method mentioned in the embodiments of the present application can be executed by a server or a terminal device, or by a server and a terminal device jointly, without limitation. This article only uses a server as an example for illustration.

[0087] See Figure 2 As shown, it is a flow chart of a task push method provided in an embodiment of the present application. The method can be applied to a terminal device or a server. The following description will only be given by taking the application to the server as an example. The specific process is as follows:

[0088] S201: When it is determined to push tasks for a set of pending tasks, task information of each pending task in the set of pending tasks is obtained, where each task information includes at least the task execution duration and task expiration time of the corresponding pending task.

[0089] A pending task can be any type of time-sensitive task. For example, in a home-schooling scenario or other course learning scenario, a pending task might be a course to be studied; in an office scenario, a pending task might be a process or business to be handled. The following explanation will only use the home-schooling scenario as an example.

[0090] The set of tasks to be executed may contain one or more tasks to be executed. The set of tasks to be executed is also associated with a template identifier, which is used to uniquely identify the set of tasks to be executed. The template identifier can be represented by, but not limited to, information such as a template serial number (ID) and a template name. The following description will only use the template ID as an example. As a possible implementation method, a template ID is associated with one or more tasks to be executed. When it is determined to push a task for the set of tasks to be executed, the server obtains the task information of each task to be executed associated with the template ID based on the template ID of the set of tasks to be executed.

[0091] In the embodiment of the present application, the triggering of the task push of the pending task set includes but is not limited to the following possible ways:

[0092] The first possible approach is to push tasks to the pending task set after completing the configuration of the pending task set. The configuration process for the pending task set is detailed below.

[0093] A second possible manner: when a push instruction for the to-be-executed task set is received from the management object, it is determined to push tasks for the to-be-executed task set.

[0094] In other words, the task push for the pending task set can be actively triggered by the management object. Among them, the management object refers to the object with management permissions, which include but are not limited to: pending task set configuration permission, push cycle configuration permission, task push trigger permission, etc.

[0095] A third possible approach is to determine to push tasks for the set of tasks to be executed according to a push cycle set for the set of tasks to be executed.

[0096] The push cycle is pre-set by the management object for the set of tasks to be executed. For example, the push cycle may be daily, every five days, weekly, monthly, etc., but is not limited thereto.

[0097] A pending task can also be associated with a task identifier, which uniquely identifies the pending task. The task identifier can be represented by, but is not limited to, a task ID or task name. The following description uses the task ID as an example. For example, the task information for a pending task includes: the pending task ID, the task execution duration, and the task deadline.

[0098] As a possible implementation manner, the task information of the task to be executed may be stored in a storage layer of a database (DB).

[0099] As a possible implementation method, during the storage process, time-type data (duration and deadline) are stored using Unix timestamps.

[0100] It should be noted that in the home-school application scenario, the task to be executed can also be called the course to be learned, the task information of the task to be executed can also be called the course information, and the task ID of the course to be learned can also be called the course ID.

[0101] Exemplarily, the course duration corresponding to each course to be learned in the set of courses to be learned is obtained, and the course duration corresponding to each course to be learned is used as the corresponding task execution duration; the closing time corresponding to each course to be learned in the set of courses to be learned is obtained, and the closing time corresponding to each course to be learned is used as the corresponding task expiration time.

[0102] That is to say, the execution time of the course to be learned can also be called the course time, and the task expiration time of the course to be learned can also be called the course closing time.

[0103] For ease of understanding, duration and deadline are simplified (actually stored as Unix timestamps). The target push time is used as the start time and is set to 0. There are no restrictions on the time unit of course duration, which can be, but is not limited to, seconds, milliseconds, minutes, etc. The following description only uses data without time units.

[0104] For example, see Figure 3 As shown in the figure, assume that the pending task set contains seven courses to be learned: Course A, Course B, Course C, Course D, Course E, Course F, and Course G. When deciding to push a task for the pending task set, the task information for each of the seven courses to be learned is obtained. Of the seven courses to be learned, Course A has a course duration of 150 minutes and a closing time of 200 minutes; Course B has a course duration of 500 minutes and a closing time of 1000 minutes; Course C has a course duration of 250 minutes and a closing time of 850 minutes; Course D has a course duration of 200 minutes and a closing time of 700 minutes; Course E has a course duration of 300 minutes and a closing time of 500 minutes; Course F has a course duration of 110 minutes and a closing time of 250 minutes; and Course G has a course duration of 700 minutes and a closing time of 1200 minutes.

[0105] S202: Based on the task execution duration and task expiration time of each to-be-executed task and in combination with the target push time, at least one target task that meets the set recommended execution condition is screened out from the to-be-executed tasks.

[0106] Since tasks are time-sensitive, tasks of a corresponding duration need to be completed before the task expires. In the embodiment of the present application, the recommended execution conditions include at least conditions 1 and 2. However, in order to ensure the quality of task completion, the recommended execution conditions may also include condition 3, which limits the completion of one task to be executed within the same time. In addition, in order to improve the recommendation effect and task execution efficiency, among the optional task combinations, the number of tasks in the push combination is the largest. Specifically, conditions 1 to 4 are as follows:

[0107] Condition 1: For a pending task, the time specified by the duration of the pending task must be completed.

[0108] Taking Course A as an example, the time required to complete Course A is the course duration (150).

[0109] Condition 2: For a pending task, the task completion time must be no later than the pending task's deadline.

[0110] Taking Course A as an example, the task completion time of Course A should not be later than the deadline of Course A (200).

[0111] Condition 3: Complete one pending task at the same time.

[0112] Taking Course A and Course B as an example, you can complete Course A or Course B at the same time.

[0113] Condition 4: The number of tasks to be executed is the largest.

[0114] Taking the above 7 courses to be learned as an example, assume that combination 1 (Course A, Course B, Course C) and combination 2 (Course A, Course B, Course D, Course F) both meet the above conditions 1-3. Since the number of tasks to be performed in combination 2 is the largest, then each learning course in combination 2 will be used as the target task.

[0115] In some implementations, considering that it is always optimal to execute the pending tasks that expired earlier first and then the pending tasks that expired later, when screening target tasks, the pending tasks can be sorted according to the task expiration time, and then the target tasks can be selected from the pending tasks in turn based on the sorting results.

[0116] Specifically, when executing S202, the following methods may be used but are not limited to:

[0117] Sort the tasks to be executed based on their respective expiration times to obtain a sorting result;

[0118] Based on the sorting result, combined with the target push time and the execution time of each task to be executed, at least one target task that meets the set recommended execution conditions is sequentially screened out from each task to be executed.

[0119] The sorting can be in ascending or descending order. Regardless of whether it is ascending or descending, the target tasks are selected based on the principle of first selecting the tasks with the earliest expiration time. In this article, only ascending order is used as an example, that is, the tasks with the earliest expiration time are placed first, and the tasks with the latest expiration time are placed last.

[0120] As a possible implementation, the sorting results may be stored in an array, but are not limited thereto.

[0121] For example, see Figure 4 As shown, based on the closing time of each of the 7 courses to be studied, the 7 courses to be studied are sorted in ascending order to obtain an array storing the sorting results of the 7 courses to be studied. In the array, according to the closing time, the following are stored in order: Course A, Course F, Course E, Course D, Course C, Course B, and Course G.

[0122] The following explains why it is always optimal to execute pending tasks that expired earlier first and then pending tasks that expired later.

[0123] For example, consider two courses, S1 and S2. S1 can be represented as (t1, d1), where t1 is the duration of S1 and d1 is the end time of S1. S2 can be represented as (t2, d2), where t2 is the duration of S2 and d2 is the end time of S2. If S2 ends later, i.e., d1 ≤ d2, then learning S1 first and then S2 is always optimal for the following reasons:

[0124] (1) If S1 is learned first and then S2, the following formulas 1 and 2 must be satisfied:

[0125] x+t1≤d1 Formula 1

[0126] x+t1+t2≤d2 Formula 2

[0127] (2) If S2 is learned first and then S1, the following formulas 3 and 4 must be satisfied:

[0128] x+t2≤d2 Formula 3

[0129] x+t2+t1≤d1 Formula 4

[0130] Here, x represents the time point when learning starts.

[0131] If Formula 4 holds true, that is, x+t2+t1≤d1, and since d1≤d2, then Formula 1 (x+t1≤d1) and Formula 2 (x+t1+t2≤d2) also hold true. This means that if you can "learn S2 first, then S1," then you can definitely "learn S1 first, then S2."

[0132] Conversely, if Formula 1 holds true (i.e., x+t1+t2≤d2), then Formula 4 (x+t2+t1≤d1) cannot be deduced. For example, when x=0, (t1, d1)=(2, 3), and (t2, d2)=(5, 100), while "learning S1 first, then S2" is possible, "learning S2 first, then S1" is not.

[0133] Therefore, all the courses to be studied can be sorted in ascending order according to the closing time, and then the courses to be studied (ie, target tasks) to be pushed can be selected in sequence, so that the push objects can study the courses in order.

[0134] In the process of screening target tasks, considering that the set of tasks to be executed may contain one or more tasks to be executed, as a possible implementation method, when the set of tasks to be executed contains one task to be executed, the target push time is combined with the task execution duration of the task to be executed to determine whether the task to be executed can be completed before the task expiration time of the task to be executed, that is, whether the task to be executed is the target task, and the task is pushed according to the judgment result; and when the set of tasks to be executed contains multiple tasks to be executed, the target task set that can be recommended for completion is screened out from the multiple tasks to be executed according to the target push time and the task execution duration of the multiple tasks to be executed, and then the task is pushed according to the target task set.

[0135] In some implementations, when screening target tasks, based on the sorting results, the following operations are performed in sequence for each task to be executed:

[0136] For the current pending task, obtain the current cumulative duration, and based on the cumulative duration, combine the target push time and the current pending task execution time to obtain the estimated completion time of the current pending task;

[0137] If the estimated completion time does not exceed the task expiration time of the current task to be executed, the current task to be executed is taken as a target task, and the accumulated duration is updated based on the task execution duration of the current task to be executed.

[0138] As a possible implementation, the selected target tasks can be stored in a priority queue. The target tasks in the priority queue are sorted by their execution time. The cumulative duration (total) is used to record the total execution time of each target task. For example, the initial value of the cumulative duration is 0.

[0139] Furthermore, as a possible situation, if the expected completion time exceeds the task expiration time of the current task to be executed, then the current target tasks are obtained;

[0140] Based on the task execution time corresponding to each target task, a target task that meets the set task replacement conditions is selected from each target task;

[0141] If the task execution time of a selected target task is longer than the task execution time of the current task to be executed, the selected target task will no longer be used as the target task, and the current task to be executed will be used as the target task;

[0142] Based on the execution time of the current task to be executed and the selected target task, the cumulative execution time is updated.

[0143] The task replacement condition may be, but is not limited to, the longest execution time of the task.

[0144] As a possible implementation method, if a priority queue is used to store each target task, in the priority queue, each target task is sorted according to the task execution time; then based on the task execution time corresponding to each target task, a target task that meets the set task replacement conditions is selected from each target task, and then when the task execution time of the selected target task is greater than the task execution time of the current task to be executed, the selected target task is removed from the priority queue, and the current task to be executed is added to the priority queue, and the queue order of the priority queue is updated according to the task execution time.

[0145] As a possible implementation, a data structure is needed to support retrieving the target task with the largest duration. Therefore, a priority queue can be used to store the target tasks. For example, the underlying implementation of the priority queue is a large root heap, in which the target task at the head of the queue has the longest execution time.

[0146] In summary, according to the sorting results, traverse each task to be executed in turn, with (t i , d i ) as an example, (t i , d i ) is any one of the tasks to be executed. When traversing to (t i , d i ), there are two situations:

[0147] Case 1: If the cumulative duration of each target task in the current priority queue is equal to t i The sum is less than or equal to d i , then put t i Add to the priority queue, and t i As a target task.

[0148] Case 2: If the cumulative duration of each target task in the current priority queue is equal to t i The sum is greater than d i , then, get the target task at the head of the priority queue, and the execution time of the target task at the head of the queue is recorded as t xj , if t xj >t i , then, remove the target task at the head of the queue from the priority queue, and (t i , d i ) is added to the priority queue.

[0149] After the traversal is completed, the tasks contained in the priority queue are the recommended target tasks.

[0150] For example, see Figure 5 As shown, the target push time is 0, and the process traverses to Course A. The current task to be executed is Course A, and the current total value is 0. Based on the cumulative duration and the course duration of Course A (150), the estimated completion time of Course A is obtained. The estimated completion time of Course A = 0 + 150 = 150. Then, it is determined whether the estimated completion time of Course A exceeds the closing time of Course A (200), that is, whether total + duration is less than or equal to deadline, where duration is the duration of Course A and deadline is the deadline of Course A. Obviously, 150 <= 200, indicating that according to the total of the target task in the current priority queue, after studying Course A, it does not exceed the closing time of Course A. At this time, the cumulative duration is updated according to the duration of Course A. The updated total = 0 + duration = 150, and Course A is added to the priority queue.

[0151] See Figure 6 As shown, traverse to course F, the current task to be executed is course F, the current total = 150, based on the cumulative duration and the course duration of course F (110), obtain the expected completion time of course F, the expected completion time of course F = 150 + 110 = 260. Then, determine whether the expected completion time of course F exceeds the closing time of course F (250), that is, determine whether total + duration is less than or equal to deadline, where duration is the duration of course F and deadline is the deadline of course F. Obviously, 260>250, indicating that according to the total of the target task in the current priority queue, after studying course F, it exceeds the closing time of course F. Therefore, further determine whether the duration of the first course in the priority queue (that is, the target task at the head of the queue) is greater than the duration of the current course (that is, the current task to be executed). Since the first course in the queue is Course A, and Course A's duration (150) is greater than Course F's duration (110), Course A is removed from the priority queue and added to Course F. At the same time, the accumulated duration is updated to total = 150 - (150 - 110) = 110. Since the first course in the queue is the one that takes the most time, if the first course takes longer to learn than the current course, it can be replaced with a course that takes less time, thereby recommending more courses to be learned.

[0152] See Figure 7As shown, traverse to course E, the current task to be executed is course E, the current total = 110, based on the cumulative duration and the course duration of course E (300), obtain the estimated completion time of course E, the estimated completion time of course E = 110 + 300 = 410, then judge whether the estimated completion time of course E exceeds the closing time of course E (500), that is, judge whether total + duration is less than or equal to deadline, where duration is the duration of course E, and deadline is the deadline of course E. Obviously, 410 < = 500, indicating that according to the total of the target task in the current priority queue, after studying course E, it does not exceed the closing time of course E. At this time, according to the duration of course E, the cumulative duration is updated, and the updated total = 110 + 300 = 410, and course E is added to the priority queue.

[0153] See Figure 8 As shown, traverse to course D. The current task to be executed is course D. The current total = 410. Based on the cumulative duration and the course duration of course D (200), the estimated completion time of course D is obtained. The estimated completion time of course D = 410 + 200 = 610. Then, it is determined whether the estimated completion time of course D exceeds the closing time of course D (700), that is, whether total + duration is less than or equal to deadline, where duration is the duration of course D and deadline is the deadline of course D. Obviously, 610 <= 700, indicating that according to the total of the target task in the current priority queue, after learning course D, it does not exceed the closing time of course D. At this time, according to the duration of course D, the cumulative duration is updated. The updated total = 410 + 200 = 610, and course D is added to the priority queue. After course D is added to the queue, the priority queue automatically adjusts the heap according to the underlying principle of the big top heap.

[0154] See Figure 9As shown, traversing to course C, the current task to be executed is course C, and the current total = 610. Based on the cumulative duration and the course duration of course C (250), the estimated completion time of course C is obtained, and the estimated completion time of course C = 610 + 250 = 860. Then, it is determined whether the estimated completion time of course C exceeds the closing time of course C (850), that is, whether total + duration is less than or equal to deadline, where duration is the duration of course C and deadline is the deadline of course C. Obviously, 860>850, indicating that according to the total of the target task in the current priority queue, after studying course C, it exceeds the closing time of course C. Therefore, it is further determined whether the duration of the first course in the priority queue (that is, the target task at the head of the queue) is greater than the duration of the current course (that is, the current task to be executed). Since the first course in the queue is Course E, and Course E's duration (300) is greater than Course C's duration (250), Course E is removed from the priority queue and added to Course C. At the same time, the accumulated duration is updated to total = 610 - (300 - 250) = 560. Since the first course in the queue is the course with the longest duration, if the first course takes longer to learn than the current course, it can be replaced with a course that takes less time, thereby recommending more courses to be learned. After Course C is added to the queue, the priority queue automatically adjusts the heap according to the underlying principle of the max-heap.

[0155] See Figure 10 As shown, traversing to Course B, the current task to be executed is Course B, and the current total = 560. Based on the accumulated duration and the course duration of Course B (500), the estimated completion time of Course B is obtained: 560 + 500 = 1060. Then, determine whether the estimated completion time of Course B exceeds the closing time of Course B (1000), that is, determine whether total + duration is less than or equal to deadline, where duration is the duration of Course B and deadline is the deadline of Course B. Obviously, 1050 > 1000, indicating that according to the total of the target task in the current priority queue, after studying Course B, it will exceed the closing time of Course B. Therefore, further determine whether the duration of the first course in the priority queue (that is, the target task at the head of the queue) is greater than the duration of the current course (that is, the current task to be executed). Since the first course in the queue is Course C, and the duration of Course C (250) is less than the duration of Course B (500), it means that Course B cannot be completed before the closing time. Therefore, Course B is skipped.

[0156] See Figure 11 As shown, when traversing to course G, the current total value is 560. Since total+G_duration (i.e., the duration of course G)>G_deadline (i.e., the deadline of course G), it means that the total time total in the current queue will exceed the closing time of course G after studying course G. At this time, it is further determined whether the duration of the first course in the priority queue is greater than the duration of course G. Since the first course in the queue is course C, the duration of course C is less than the duration of course G, which means that course G cannot be completed before the deadline. Therefore, course G is skipped.

[0157] Traverse to course G. The current task to be executed is course G, and the current total = 560. Based on the cumulative duration and the course duration of course G (700), the estimated completion time of course G is obtained: estimated completion time of course G = 560 + 700 = 1260. Then, determine whether the estimated completion time of course G exceeds the closing time of course G (1200). That is, determine whether total + duration is less than or equal to deadline, where duration is the duration of course G and deadline is the deadline of course G. Obviously, 1250 > 1200, indicating that according to the total of the target task in the current priority queue, after studying course G, it will exceed the closing time of course G. Therefore, further determine whether the duration of the first course in the priority queue (that is, the target task at the head of the queue) is greater than the duration of the current course (that is, the current task to be executed). Since the first course in the queue is Course C, and the duration of Course C (250) is less than the duration of Course G (700), it means that Course G cannot be completed before the closing time. Therefore, Course G is skipped.

[0158] In summary, the target tasks include: Course C, Course F, and Course D.

[0159] Next, the principle of the above-mentioned screening method is explained.

[0160] Assume that there are N courses to be learned. During the traversal process, the current traversal reaches the i-th course (t i , d i ), where t i represents the duration of the i-th course, d i Indicates the closing time of the i-th course, and among the first i-1 courses, k courses have been selected (t x1 , d x1 ), (tx2 , d x2 ),…,(t xk , d xk ), that is, there are currently k target tasks, among which t x1 , t x2 ,…,t xk They represent the duration of k courses, d x1 d x2 ,…,d xk They represent the closing time of k courses respectively. If x1<x2<···<xk, then:

[0161] t x1 ≤d x1 ;

[0162] t x1 +t x2 ≤d x2 ;

[0163] …;

[0164] t x1 +t x2 +…+t xk ≤d xk .

[0165] If the above combination is the "optimal solution" for the first i-1 courses: that is, there is no other combination that can select k+1 courses, nor is there any other combination that can select k courses and have a shorter total course duration (less than t x1 +t x2 +…+t xk ), then, based on the combination scheme and the i-th course (t i , d i ), construct the optimal solution for the first i courses:

[0166] If t x1 +t x2 +…+t xk +t i ≤d i , then the i-th course (t i , d i ) is directly used as the target task, and k+1 courses are selected as the target task.

[0167] The "optimality" here can be proved by contradiction. If there is a better combination, then the other combination must include the i-th course (t i , d i ), if it is not included, then it means that there is a better combination of the first i-1 courses, which contradicts the hypothesis. When the optimal solution includes the i-th course (ti , d i ), according to the previous proof, it is always optimal to learn S1 first and then S2, so we can put the i-th course (t i , d i ) as the last course in the scheme. Since this scheme is better than the scheme with x1, x2, …, xk, i, even after removing the last course i, this scheme is still better than the scheme with x1, x2, …, xk. This also shows that there is a better scheme for the first i-1 courses, which contradicts the hypothesis.

[0168] If t x1 +t x2 +…+t xk +t i >d i , then it is impossible to transfer the i-th course (t i , d i ) is directly added to the plan. Using a similar proof by contradiction, we can prove that there is no better solution than choosing k+1 courses for the first i courses. Therefore, we still choose k courses, but minimize their total course duration to free up more time for subsequent courses.

[0169] If t x1 , t x2 ,…,t xk Are less than or equal to t i , then it is obvious that there is no way to make the total course duration shorter by taking the i-th course. But if the course duration of the longest course among the k courses (denoted as t xj ) satisfies t xj >t i , then you can try to change the xth j Courses are replaced by the i-th course. This replacement will reduce the total course time by t xj —t i , thereby minimizing the course duration.

[0170] The xth j After the courses are replaced by the i-th course, these courses are arranged in the order of x1, x2, ..., x j-1 , x j+1 ,…,x k , i are learned in the order:

[0171] For x1, x2, …, x j-1 , the inequalities they need to satisfy are consistent with those before, so they still meet the requirements;

[0172] For x j+1 ,…,x k , the left side of the original inequality that needs to be satisfied is missing txj This item still meets the requirement because the left side ≤ the right side;

[0173] For i, due to t x1 +t x2 +…+t xk ≤d xk Established, and t xj >t i , so: x1 +t x2 +…+t xj-1 +tx j+1 ···+t xk +t i ≤d xk Meet the requirements.

[0174] This means that the xth j The first course is replaced by the i-th course. In this way, after traversing all N courses, the final recommended target course can be obtained.

[0175] S203: Push tasks to each push object associated with the to-be-executed task set based on at least one target task.

[0176] The push object refers to the object that performs the task. Each push object associated with a set of tasks to be executed can be pre-set by the management object or configured by the system by default, without limitation.

[0177] For example, based on Course C, Course F, and Course D, tasks are pushed to each push object associated with the set of tasks to be executed.

[0178] The following describes the configuration process of the task set to be executed.

[0179] In the embodiment of the present application, a template configuration method is adopted to implement the configuration of the task set to be executed.

[0180] In some implementations, in order to improve the robustness of the business system and reduce the coupling between interfaces, the configuration process is divided into three steps: creating a custom template or reusing a system template, setting template parameters, and setting template rules.

[0181] For details, see Figure 12 As shown, it is a flow chart of a process for configuring a set of tasks to be executed provided in an embodiment of the present application. The process is applied to the server, and the specific process is as follows:

[0182] S1201. When receiving a template creation instruction from a management object, the server creates a target task template. The target task template includes template parameters and template rules. The template parameters are used to configure a set of tasks to be executed, and the template rules are used to configure a task push method.

[0183] As a possible implementation manner, the client sends a template creation instruction to the server in response to the template adding operation triggered by the management object, so that the server creates the target task template according to the template creation instruction.

[0184] The target task template can be a custom template, meaning that a new template is created. The new template does not inherit the system's default template controls, but requires all settings to be set by the management object. The target task template can also be reused from an existing template. In other words, the management object can add the target task template from the recommended template or copy an existing template. In this way, the template parameters of the target task template will be directly obtained.

[0185] For example, the client presents a template adding interface to the management object, wherein the adding trigger interface includes a template adding component. When the management object triggers the template adding component, the client determines that the management object triggers the template adding operation. The component can be triggered by, but is not limited to, click, touch, voice, and other methods.

[0186] Template Add Trigger Components can be further divided into Custom Template Add Components and Existing Template Reuse Components. Custom Template Add Components are used to create a new template, while Existing Template Reuse Components are used to copy an existing template.

[0187] For example, the add trigger interface includes: "+Add Template" button, "+Add Template" button. When the management object clicks the "+Add Template" button, the template adding interface is presented.

[0188] See Figure 13As shown, the template adding interface contains two parts, the upper part is used to create custom templates, and the lower part is used to reuse existing templates. Specifically, the upper part contains the "+Custom Template" button, and the "+Custom Template" button is equivalent to the custom template adding component. When the management object clicks the "+Custom Template" button, a new template is created as the target task template; the lower part contains the "Copy from Existing Template" button, and the "Copy from Existing Template" button is equivalent to the existing template reusing component. When the management object clicks the "Copy from Existing Template" button, the existing templates are presented in the template adding interface. The existing templates can be arranged in order by type, for example, leave, overtime, business trip, and outing under the leave and attendance type; conference room reservation, item collection, item maintenance, seal use, car use, document approval, etc. under the administrative type; reimbursement, expenses, payment, etc. under the financial type. Of course, the existing templates can also be directly presented in the template adding interface, and there is no limitation on this.

[0189] The template adding interface also displays the visible scope of the target task template, the administrator of the target task template (i.e., the management object), as well as the setting components for configuring the application person in charge, the setting components for configuring the template creation permissions, the setting components for configuring the approver's permissions, the setting components for holiday management, etc. Among them, the setting component for configuring the application person in charge is used to configure enterprise members as application persons in charge. The application person in charge can create and manage approval templates in the approval application; the setting component for configuring template creation permissions can be a check component. When the option to allow members to create approval templates is checked, members can create appropriate approval templates for their own teams; in the setting component for configuring the approver's permissions, when the approver is "specified label", the approval scope of members within the label can be set separately; the setting component for holiday management is used to set the holiday type and view the holiday balance. After an employee takes leave, the leave will be automatically deducted according to the approval form.

[0190] As one possible implementation, after a management object triggers a template addition operation, the client sends a template creation request to the server, carrying the object identifier (e.g., object ID) of the management object. Upon receiving the template creation request, the server can also match the object identifier carried in the template creation request with the pre-set object identifier of the management object to perform an operation permission check on the management object to determine whether the operator is an administrator, enterprise super administrator, enterprise sub-administrator, application administrator, template administrator, or other person with management permissions.

[0191] As a possible implementation method, the target task template can be created in the following ways, but not limited to:

[0192] First, the server obtains a list of existing templates associated with the management object;

[0193] Secondly, if the number of templates included in the existing template list does not exceed the set template number threshold, a new template identifier is generated as the template identifier of the target task template, and initial configuration information of the target task template is generated based on the creation information;

[0194] Next, the initial configuration information and the target template identifier are stored in association in the storage space.

[0195] The existing template list may be stored in a storage space. The storage space includes, but is not limited to, a database storage layer. The existing template list may include all existing templates of the enterprise to which the management object belongs. For example, the template quantity threshold is set to 3000.

[0196] As a possible implementation, if the number of existing templates in the existing template list does not exceed a set template quantity threshold, a new template identifier is generated using a template identifier generation algorithm to serve as the template identifier for the target task template. For example, the template identifier is represented by a template ID. The template ID generation algorithm can be: based on a 64-bit number, a random number is concatenated to serve as the template ID. Of the 64-bit number, the high-order 32 bits are the Unix timestamp, and the low-order 32 bits are the low-order 32 bits of the enterprise ID.

[0197] Creation information includes but is not limited to one or more of the following basic parameters: creation time, update time, affiliated company, creator, etc.

[0198] The server writes the initial configuration information, template identification and other data into the storage space, which ensures that subsequent operations in the background can obtain the initial configuration information, template identification and other data from the storage space, and there will be no situation where there is no data in the storage space.

[0199] S1202: When receiving a template parameter configuration request from a management object, the server obtains and stores parameter configuration information of the template parameters carried in the template parameter configuration request, where the parameter configuration information includes the task identifiers of the tasks to be executed.

[0200] As a possible implementation, the client sends a template parameter configuration request to the server in response to a parameter configuration operation triggered by the management object in the template parameter configuration interface. The template parameter configuration request carries parameter configuration information of the template parameters.

[0201] Template parameters include but are not limited to: template name, template icon, template group, control, control parameters. Control parameters include but are not limited to control name, control description, whether required, etc., but are not limited to these.

[0202] In the embodiment of the present application, in order to ensure template diversity, the target task template can support various types of controls.

[0203] See Figure 14 As shown, it is a schematic diagram of a template parameter configuration interface provided in an embodiment of the present application. The template parameter configuration interface supports multiple control types, such as text, buttons, check boxes, etc. The management object clicks the "+ Add Control" button in the template parameter configuration interface to add a text control in the target task template. The management object clicks the text control and sets the control parameters in the control setting area on the right. The control parameters include the control name, control description, whether it is required, whether it participates in printing, etc. In the right area of ​​the template parameter configuration interface, you can also set template parameters such as the template name, template image, template grouping, etc. of the target task template.

[0204] In addition, the management object can also add courses to be studied through the template parameter configuration interface. The addition of courses to be studied can be achieved by triggering the "+ Add Control" button. After adding, you can click to view the courses to be studied. For example, see Figure 15 As shown, the target task template includes courses 01 and 02 waiting to be studied. The template name of the target task template is How to Efficiently Manage Leave and Attendance. The set of courses to be studied associated with the target task template includes various courses in the course catalog, such as Course 01 "Punching in: How does a company punch in?" and Course 02 "Punching in: How to set rules for leaving and coming in at fixed times?" Each course has a corresponding duration and closing time. For example, the duration of Course 01 is two minutes and ten seconds, and the duration of Course 02 is three minutes. The closing time of Course 01 is March 5th, and the closing time of Course 02 is March 6th. In addition, the target task template can also set components such as the "Learn" button. After the target task template is configured, the administrator can click the "Learn" button to study the course or remind other users to study the course.

[0205] When the management object clicks the "Next" button in the template parameter configuration interface, the client responds to the parameter configuration operation triggered by the management object in the template parameter configuration interface, sends a template parameter configuration request to the server, and presents the template rule configuration interface to the management object.

[0206] As a possible implementation method, although the server also pulled the initial configuration information from the storage layer in the previous step, the initial configuration information only filled in basic parameters such as creation time, update time, affiliated company, and creator. Therefore, after obtaining the parameter configuration information, the server pulls the initial configuration information of the storage layer and fills in the parameter configuration information. Then, the initial configuration information after filling in the parameter configuration information is written back to the storage layer for updating.

[0207] It should be noted that, in the embodiment of the present application, initial configuration information, parameter configuration information, and rule configuration information can all be referred to as template details of the target task template.

[0208] S1203: When receiving a template rule configuration request from a management object, the server obtains and stores rule configuration information of the template rule carried in the template rule configuration request.

[0209] As a possible implementation, the client sends a template rule configuration request to the server in response to a rule configuration operation triggered by the management object in the template rule configuration interface. The template rule configuration request carries rule configuration information of the template rule.

[0210] For example, the template rule configuration interface is used to configure the following template rules: visibility range; whether to notify members; approval process; exception handling method, when a member resigns or the approval node is empty, automatically approve or transfer it to a designated person for processing; automatic approval method, when the same approver repeatedly approves the same document, only the first node needs to be approved, and the rest are automatically approved, only automatic approval is required for consecutive approvals, or each node requires approval; whether submission on behalf of others is allowed; whether only administrators, applicants, approvers, and CCs can view the approval process; whether employees cannot modify fixed approvers when submitting an application; whether employees cannot modify fixed CCs when submitting an application; whether revocation is allowed after approval; whether temporary approvers can be added to the approval form; and whether a signature is required when the approver agrees.

[0211] After the rule configuration is completed, the server receives the rule configuration information passed in by the client and performs subsequent logical processing.

[0212] In some implementations, the rule configuration information passed in by the client can be optimized and designed. The basic options in the target task template, such as whether to allow revocation after passing, can be stored in a 32-bit unsigned number in a bitwise AND manner. In this way, when judging whether the option is checked, it is only necessary to check whether the target bit is 0 or 1. For example, 0 means allowing revocation after passing, and 1 means not allowing revocation after passing.

[0213] In some implementations, when the server stores the rule configuration information of the template rule carried in the template rule configuration request, it can be implemented in the following manner:

[0214] Based on the target template identifier, initial configuration information is obtained from the storage space;

[0215] Based on the rule configuration information, the initial configuration information is updated to obtain the target configuration information, and the target configuration information is stored in the storage space.

[0216] That is, the server obtains the initial configuration information of the target task template from the storage space and updates the initial configuration information according to the rule configuration information.

[0217] Exemplarily, the server may also obtain an existing template list from the storage space, and add the template identifier of the target task template to the existing template list.

[0218] As a possible implementation method, the server first writes the target configuration information in the storage space, and then writes the existing template list back to the storage space. In this way, if the data of the existing template list is written first, the target task template can be seen immediately in the client, but the target configuration information of the target task template has not been transferred back to the storage space, and a data confusion error will occur; at the same time, if the concurrency is too large, resulting in the failure of the initial target configuration information to write back to the database operation, even if the existing template list is not subsequently written back to the storage space, it will not affect the data displayed in the client. This design can ensure the stability of the program to a certain extent. If the management object is set to remind members within the visible range that a new approval template is available after the template is published, then when the management object clicks the "Save" button, the push function can be triggered immediately.

[0219] In some implementations, the target task may be pushed via, but is not limited to, a card message.

[0220] See Figure 16 As shown in FIG, it is a schematic diagram of the interaction process between a client and a server provided in an embodiment of the present application. Among them, the server side is composed of an approval application service (Svr), an approval application logic (Logic), a DB, a card push service, an algorithm service, and a timer task service. The approval application service (Svr), the approval application logic (Logic), the card push service, the algorithm service, and the timer task service can be provided by one or more servers.

[0221] S1601: In response to a template adding operation triggered by an administrator, the client sends a template creation instruction to the approval application Svr.

[0222] S1602: Approval application Svr verifies operation permissions.

[0223] S1603. The approval application Svr sends a template ID generation request to the approval application Logic.

[0224] S1604: The approval application Logic sends a request to the DB for obtaining the existing template list.

[0225] S1605. The DB returns a list of existing templates associated with the management object.

[0226] S1606: The approval application logic determines whether the number of templates in the existing template list exceeds the set template number threshold.

[0227] S1607: If the number of templates does not exceed the set template number threshold, the approval application Logic generates a new template identifier through a template identifier generation algorithm, which serves as the template identifier of the target task template.

[0228] S1608. The approval application Logic returns the template identifier to the approval application Svr.

[0229] For details of S1601 to S1608, please refer to S1201 above.

[0230] S1609: In response to the parameter configuration operation triggered by the administrator, the client sends a template parameter configuration request to the approval application Svr. The template parameter configuration request carries parameter configuration information.

[0231] After the management object completes the template parameter setting, the client transmits the parameter configuration information to the approval application Svr.

[0232] S1610 . The approval application Svr sends a template details save request to the approval application Logic.

[0233] The svr side calls the Logic layer to pull the template details stored in the DB and fill in the parameter configuration information. The parameter configuration information includes: template name, template icon, template group, control and control-specific parameters, whether it is required, etc.; although the template details were also pulled from the DB in the previous step, only some basic parameters were filled in the template details: such as creation time, update time, company to which it belongs, creator, etc.

[0234] S1611: The approval application logic sends a request to the database for template details. The logic layer writes the data back to the storage layer for update.

[0235] S1612. DB returns template details.

[0236] S1613. The approval application logic writes the updated template details based on the parameter configuration information back to the DB.

[0237] For details of S1609 to S1613, please refer to S1202 above.

[0238] S1614: In response to the rule configuration operation triggered by the administrator, the client sends a template rule configuration request to the approval application Svr. The template rule configuration request includes rule configuration information.

[0239] S1615. The approval application Svr sends a template list save request to the approval application Logic.

[0240] S1616. The approval application Logic sends a request to the DB for obtaining template details.

[0241] S1617. DB returns template details.

[0242] S1618. The approval application Logic writes back the updated template details based on the rule configuration information to the DB.

[0243] S1619: The approval application Logic inserts the updated existing template list into the DB.

[0244] S1620 , the approval application Logic notifies the client of the successful save through the approval application Logic.

[0245] In other words, the SVR receives the parameters passed in by the client and calls the Logic layer again for logical processing. The Logic layer reads the template details and template list from the database, then transparently passes the rule configuration information to the template details and inserts the template identifier of the target task template into the template list. The approval application's Logic then writes the template details to the database and then writes the template list back to the database.

[0246] For details of S1614 to S1620, please refer to S1203 above.

[0247] S1621. After successfully saving, the approval application Svr sends a task push request to the card push Svr.

[0248] S1622. The card push Svr sends a task push request to the algorithm Svr.

[0249] S1623, algorithm Svr utilization Figure 2 The task push method shown determines the target task set.

[0250] S1624. The algorithm Svr returns the target task set to the card push Svr.

[0251] S1625. The card push Svr returns the target task set to the approval application Svr.

[0252] S1626. The approval application Svr pushes a message card to the client, where the message card includes a target task set.

[0253] S1627: The approval application Svr sets a scheduled task for the scheduled task Svr and pushes the target task regularly. It should be noted that the target task pushed regularly can be a combination of new target tasks determined according to the new template push time.

[0254] S1628: The scheduled task Svr returns the target task set to the approval application Svr. The approval application Svr pushes a card message containing the target task set to the client.

[0255] In this embodiment of the application, effective reminders can be provided to recommended subjects such as students and teachers. Not only can they be reminded of upcoming course closings, but the system also humanely calculates the maximum number of courses that can be completed before closing time and returns recommended courses. Furthermore, after the template is successfully created, reminder cards can be automatically pushed via scheduled tasks, effectively reminding students and teachers to take their courses.

[0256] Based on the same inventive concept, the embodiment of the present application provides a task pushing device. Figure 17 As shown, it is a schematic diagram of the structure of the task pushing device 1700, which may include:

[0257] The information acquisition unit 1701 is configured to acquire task information of each task in the set of tasks to be executed when it is determined to push the task to be executed, wherein each task information includes at least the task execution time and the task expiration time of the corresponding task to be executed;

[0258] The task screening unit 1702 is configured to screen at least one target task that meets a set recommended execution condition from the tasks to be executed based on the task execution duration and task expiration time of each of the tasks to be executed and in combination with the target push time;

[0259] The task pushing unit 1703 is configured to push tasks to each push object associated with the set of tasks to be executed based on the at least one target task.

[0260] As a possible implementation, when screening at least one target task that meets the set recommended execution conditions from the tasks to be executed based on the task execution duration and task expiration time of each of the tasks to be executed, combined with the target push time, the task screening unit 1702 is specifically configured to:

[0261] sorting the tasks to be executed based on their respective task expiration times to obtain a sorting result;

[0262] Based on the ranking result, in combination with the target push time and the task execution duration of each of the tasks to be executed, at least one target task that meets the set recommended execution conditions is sequentially screened out from the tasks to be executed.

[0263] As a possible implementation, when, based on the sorting result, combining the target push time and the task execution duration of each of the to-be-executed tasks, sequentially screening out at least one target task that meets the set recommended execution condition from the to-be-executed tasks, the task screening unit 1702 is specifically configured to:

[0264] Based on the sorting results, for each task to be executed, perform the following operations in sequence:

[0265] For the current task to be executed, the current accumulated duration is obtained, and based on the accumulated duration, combined with the target push time and the task execution duration of the current task to be executed, the estimated completion time of the current task to be executed is obtained;

[0266] If the estimated completion time does not exceed the task expiration time of the current task to be executed, the current task to be executed is taken as a target task, and the accumulated duration is updated based on the task execution duration of the current task to be executed.

[0267] As a possible implementation manner, the task screening unit 1702 is further configured to:

[0268] If the estimated completion time exceeds the task expiration time of the current task to be executed, then obtain the current target tasks;

[0269] Based on the task execution durations corresponding to the respective target tasks, selecting a target task that meets the set task replacement conditions from the target tasks;

[0270] If the task execution time of the target task is longer than the task execution time of the current task to be executed, the target task is no longer used as the target task, and the current task to be executed is used as the target task;

[0271] The accumulated duration is updated based on the respective task execution durations of the current task to be executed and the target task.

[0272] As a possible implementation, if a priority queue is used to store the target tasks, the target tasks in the priority queue are sorted according to the task execution time;

[0273] When selecting a target task that meets the set task replacement condition from the target tasks based on the task execution durations corresponding to the target tasks, the task screening unit 1702 is specifically configured to:

[0274] Selecting a target task at the head of the priority queue from the priority queue as a target task for setting a task replacement condition;

[0275] When the target task is no longer used as the target task and the current task to be executed is used as a target task, the task screening unit 1702 is specifically configured to:

[0276] The target task is removed from the priority queue, and the current task to be executed is added to the priority queue, and the queue order of the priority queue is updated according to the task execution time.

[0277] As a possible implementation, when determining to push a task for the to-be-executed task set, the information acquisition unit 1701 is specifically configured to:

[0278] After completing the configuration of the task set to be executed, determining to push tasks for the task set to be executed;

[0279] Determine to push tasks for the set of tasks to be executed according to the push cycle set for the set of tasks to be executed; or

[0280] When a push instruction for the to-be-executed task set is received from the management object, it is determined to push tasks for the to-be-executed task set.

[0281] As a possible implementation, when it is determined to push tasks for the set of tasks to be executed, before obtaining the task information of each task to be executed in the set of tasks to be executed, the information obtaining unit 1701 is further configured to:

[0282] When receiving a template creation instruction from a management object, creating a target task template, wherein the target task template includes template parameters and template rules, wherein the template parameters are used to configure the set of tasks to be executed, and the template rules are used to configure the task push mode;

[0283] When receiving a template parameter configuration request from a management object, obtaining and storing parameter configuration information of the template parameters carried in the template parameter configuration request, wherein the parameter configuration information includes the task identifiers of the respective tasks to be executed;

[0284] When a template rule configuration request is received from a management object, the rule configuration information of the template rule carried in the template rule configuration request is acquired and stored.

[0285] As a possible implementation, when creating the target task template, the information acquisition unit 1701:

[0286] Obtain a list of existing templates associated with the management object;

[0287] If the number of templates included in the existing template list does not exceed the set template number threshold, a new template identifier is generated as the template identifier of the target task template, and initial configuration information of the target task template is generated based on the creation information;

[0288] In the storage space, the initial configuration information and the target template identifier are stored in association.

[0289] As a possible implementation manner, when storing the rule configuration information of the template rule carried in the template rule configuration request, the information acquisition unit 1701:

[0290] Based on the target template identifier, obtaining the initial configuration information from the storage space;

[0291] Based on the rule configuration information, the initial configuration information is updated to obtain target configuration information, and the target configuration information is stored in the storage space.

[0292] As a possible implementation, the set of tasks to be performed is a set of courses to be learned. When acquiring task information of each task to be performed in the set of tasks to be performed, the information acquiring unit 1701:

[0293] Obtaining the course duration corresponding to each of the to-be-learned courses in the to-be-learned course set, and using the course duration corresponding to each of the to-be-learned courses as the corresponding task execution duration;

[0294] The closing time corresponding to each course to be learned in the set of courses to be learned is obtained, and the closing time corresponding to each course to be learned is used as the corresponding task expiration time.

[0295] For the convenience of description, the above parts are divided into modules (or units) according to their functions and described separately. Of course, when implementing this application, the functions of each module (or unit) can be implemented in the same or multiple software or hardware.

[0296] Regarding the apparatus in the above embodiment, the specific manner in which each unit executes the request has been described in detail in the embodiment of the method, and will not be elaborated on here.

[0297] Those skilled in the art will appreciate that various aspects of the present application can be implemented as systems, methods, or program products. Therefore, various aspects of the present application can be specifically implemented in the following forms: a complete hardware implementation, a complete software implementation (including firmware, microcode, etc.), or an implementation that combines hardware and software aspects, which may be collectively referred to herein as a "circuit," "module," or "system."

[0298] Based on the same inventive concept, an embodiment of the present application further provides an electronic device. In one embodiment, the electronic device may be a server or a terminal device. Figure 18 , which is a schematic structural diagram of a possible electronic device provided in an embodiment of the present application, Figure 18 In the embodiment, the electronic device 1800 includes: a processor 1810 and a memory 1820.

[0299] The memory 1820 stores a computer program that can be executed by the processor 1810 . The processor 1810 can execute the steps of the above-mentioned task pushing method by executing the instructions stored in the memory 1820 .

[0300] Memory 1820 may be a volatile memory, such as random-access memory (RAM); a non-volatile memory, such as read-only memory (ROM), flash memory, a hard disk drive (HDD), or a solid-state drive (SSD); or any other medium capable of carrying or storing desired program code in the form of instructions or data structures and accessible by a computer, but is not limited thereto. Memory 1820 may also be a combination of the aforementioned memories.

[0301] The processor 1810 may include one or more central processing units (CPUs) or digital processing units, etc. The processor 1810 is configured to implement the above-mentioned task pushing method when executing the computer program stored in the memory 1820 .

[0302] In some embodiments, the processor 1810 and the memory 1820 may be implemented on the same chip. In some embodiments, they may also be implemented on separate chips.

[0303] In the embodiment of the present application, the specific connection medium between the processor 1810 and the memory 1820 is not limited. In the embodiment of the present application, the processor 1810 and the memory 1820 are connected via a bus as an example. Figure 18 The connections between the other components are shown in bold lines for illustration only and are not intended to be limiting. The bus can be divided into an address bus, a data bus, a control bus, etc. For ease of description, Figure 18 The diagram shows a single thick line, but this does not indicate that there is only one bus or one type of bus.

[0304] Based on the same inventive concept, an embodiment of the present application provides a computer-readable storage medium, which includes a computer program. When the computer program is run on an electronic device, the computer program is used to enable the electronic device to perform the steps of the above-mentioned task push method. In some possible implementations, various aspects of the task push method provided by the present application can also be implemented in the form of a program product, which includes a computer program. When the program product is run on an electronic device, the computer program is used to enable the electronic device to perform the steps in the above-mentioned task push method. For example, the electronic device can perform the following steps: Figure 2 Follow the steps shown in .

[0305] The program product may employ any combination of one or more readable media. The readable medium may be a readable signal medium or a readable storage medium. The readable storage medium may be, for example, but not limited to, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, device, or component, or any combination thereof. More specific examples (a non-exhaustive list) of readable storage media include: an electrical connection having one or more wires, a portable disk, a hard disk, RAM, ROM, an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disk read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination thereof.

[0306] The program product of the embodiments of the present application may be a CD-ROM and include a computer program, and may be run on an electronic device. However, the program product of the present application is not limited thereto. In this document, a readable storage medium may be any tangible medium that contains or stores a computer program that can be used by or in conjunction with a command execution system, apparatus, or device.

[0307] A readable signal medium may include a data signal propagated in baseband or as part of a carrier wave, which carries a readable computer program. Such a propagated data signal may take a variety of forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination thereof. A readable signal medium may also be any readable medium other than a readable storage medium that can transmit, propagate, or transfer a computer program for use by or in conjunction with a command execution system, apparatus, or device.

[0308] Although the preferred embodiments of the present application have been described, those skilled in the art may make additional changes and modifications to these embodiments once they have learned the basic creative concept. Therefore, the appended claims are intended to be interpreted as including the preferred embodiments and all changes and modifications that fall within the scope of the present application.

[0309] Obviously, those skilled in the art may make various changes and modifications to this application without departing from the spirit and scope of this application. Thus, if these modifications and variations of this application fall within the scope of the claims of this application and their equivalents, this application is intended to include these modifications and variations.

Claims

1. A task pushing method, characterized in that: include: When it is determined to push tasks for the set of tasks to be executed, task information of each task to be executed in the set of tasks to be executed is obtained, where each task information includes at least: the task execution time and the task expiration time of the corresponding task to be executed; Based on the task execution time and task expiration time of each of the tasks to be executed, combined with the target push time, at least one target task that meets the set recommended execution conditions is screened out from the tasks to be executed; Based on the at least one target task, tasks are pushed to each push object associated with the set of tasks to be executed.

2. The method according to claim 1, wherein The step of selecting at least one target task that meets a set recommended execution condition from the tasks to be executed based on the task execution duration and task expiration time of each of the tasks to be executed and in combination with the target push time includes: sorting the tasks to be executed based on their respective task expiration times to obtain a sorting result; Based on the ranking result, in combination with the target push time and the task execution duration of each of the tasks to be executed, at least one target task that meets the set recommended execution conditions is sequentially screened out from the tasks to be executed.

3. The method according to claim 2, wherein The step of sequentially selecting at least one target task that meets a set recommended execution condition from the tasks to be executed based on the sorting result and in combination with the target push time and the execution time of each task to be executed includes: Based on the sorting results, for each task to be executed, perform the following operations in sequence: For the current task to be executed, the current accumulated duration is obtained, and based on the accumulated duration, combined with the target push time and the task execution duration of the current task to be executed, the estimated completion time of the current task to be executed is obtained; If the estimated completion time does not exceed the task expiration time of the current task to be executed, the current task to be executed is taken as a target task, and the accumulated duration is updated based on the task execution duration of the current task to be executed.

4. The method according to claim 3, wherein Also includes: If the estimated completion time exceeds the task expiration time of the current task to be executed, then obtain the current target tasks; Based on the task execution durations corresponding to the respective target tasks, selecting a target task that meets the set task replacement conditions from the target tasks; If the task execution time of the target task is longer than the task execution time of the current task to be executed, the target task is no longer used as the target task, and the current task to be executed is used as the target task; The accumulated duration is updated based on the respective task execution durations of the current task to be executed and the target task.

5. The method according to claim 4, wherein If a priority queue is used to store the target tasks, the target tasks in the priority queue are sorted according to the task execution time; Then, based on the task execution durations corresponding to the respective target tasks, a target task that meets the set task replacement conditions is selected from the target tasks, including: Selecting a target task at the head of the priority queue from the priority queue as a target task for setting a task replacement condition; The step of no longer taking the target task as the target task and taking the current task to be executed as the target task includes: The target task is removed from the priority queue, and the current task to be executed is added to the priority queue, and the queue order of the priority queue is updated according to the task execution time.

6. The method according to any one of claims 1 to 5, wherein The determining to push tasks for the set of tasks to be executed includes: After completing the configuration of the task set to be executed, determining to push tasks for the task set to be executed; Determine to push tasks for the set of tasks to be executed according to the push cycle set for the set of tasks to be executed; or When a push instruction for the to-be-executed task set is received from the management object, it is determined to push tasks for the to-be-executed task set.

7. The method according to any one of claims 1 to 5, wherein When it is determined to push tasks for the set of tasks to be executed, before obtaining the task information of each task to be executed in the set of tasks to be executed, the method further includes: When receiving a template creation instruction from a management object, creating a target task template, wherein the target task template includes template parameters and template rules, wherein the template parameters are used to configure the set of tasks to be executed, and the template rules are used to configure the task push mode; When receiving a template parameter configuration request from a management object, obtaining and storing parameter configuration information of the template parameters carried in the template parameter configuration request, wherein the parameter configuration information includes the task identifiers of the respective tasks to be executed; When a template rule configuration request is received from a management object, the rule configuration information of the template rule carried in the template rule configuration request is acquired and stored.

8. The method according to claim 7, wherein The creation of the target task template includes: Obtain a list of existing templates associated with the management object; If the number of templates included in the existing template list does not exceed the set template number threshold, a new template identifier is generated as the template identifier of the target task template, and initial configuration information of the target task template is generated based on the creation information; In the storage space, the initial configuration information and the target template identifier are stored in association.

9. The method according to claim 8, wherein The storing the rule configuration information of the template rule carried in the template rule configuration request includes: Based on the target template identifier, obtaining the initial configuration information from the storage space; Based on the rule configuration information, the initial configuration information is updated to obtain target configuration information, and the target configuration information is stored in the storage space.

10. The method according to any one of claims 1 to 5, wherein The set of tasks to be performed is a set of courses to be learned, and task information of each task to be performed in the set of tasks to be performed is obtained, including: Obtaining the course duration corresponding to each of the to-be-learned courses in the to-be-learned course set, and using the course duration corresponding to each of the to-be-learned courses as the corresponding task execution duration; The closing time corresponding to each course to be learned in the set of courses to be learned is obtained, and the closing time corresponding to each course to be learned is used as the corresponding task expiration time.

11. A task pushing device, characterized in that: include: An information acquisition unit is configured to, when determining to push a task for a set of tasks to be executed, acquire task information of each task to be executed in the set of tasks to be executed, wherein each task information includes at least: a task execution time and a task expiration time of the corresponding task to be executed; a task screening unit, configured to screen out at least one target task that meets a set recommended execution condition from the tasks to be executed based on the task execution duration and task expiration time of each of the tasks to be executed, in combination with the target push time; The task pushing unit is configured to push tasks to each push object associated with the set of tasks to be executed based on the at least one target task.

12. An electronic device, characterized in that: The method comprises a processor and a memory, wherein the memory stores a computer program, and when the computer program is executed by the processor, the processor is enabled to perform the steps of any one of the methods of claims 1 to 10.

13. A computer-readable storage medium, characterized in that The method comprises a computer program. When the computer program is run on an electronic device, the computer program is used to enable the electronic device to execute the steps of any one of the methods according to claims 1 to 10.

14. A computer program product, characterized in that The method comprises a computer program stored in a computer-readable storage medium. A processor of an electronic device reads and executes the computer program from the computer-readable storage medium, so that the electronic device executes the steps of any one of the methods of claims 1 to 10.

Images