Operation result processing method, electronic device, and computer readable storage medium

Abstract

The present invention relates to the fields of computer technology and cloud computing technology. Disclosed are an operation result processing method, an electronic device, and a computer readable storage medium. The method comprises: in response to an initialization configuration operation of a client, generating target event service information and target message service information, wherein the target event service information is used for determining a rule for subscribing to an asynchronous open application programming interface operation result by means of an event driving mode; acquiring a target configuration parameter on the basis of the target event service information and the target message service information, wherein the target configuration parameter is a configuration parameter for subscribing to the asynchronous open application programming interface operation result by means of the event driving mode; and returning the target configuration parameter to the client, so that the client subscribes to the asynchronous open application programming interface operation result by means of the event driving mode. The present invention solves the technical problems in the related art of cumbersome operations and low processing efficiency caused by acquiring an operation result by means of event subscription.

Description

[0001] Operation Result Processing Method, Electronic Device, and Computer-Readable Storage Medium TECHNICAL FIELD The present disclosure relates to the fields of computer technology and cloud computing technology, and more specifically, to an operation result processing method, electronic device, and computer-readable storage medium. BACKGROUND The Elastic Compute Service (ECS) is an elastic computing service that helps users quickly deploy and manage cloud server instances, allowing users to flexibly adjust computing resource configurations based on demand. ECS provides many Open Application Programming Interfaces (OpenAPIs), allowing users to operate ECS resources through them. OpenAPIs include synchronous and asynchronous OpenAPIs. Synchronous OpenAPIs return results immediately, while asynchronous OpenAPIs take some time to return results. For asynchronous OpenAPIs, asynchronous operation results are typically obtained by polling query-type OpenAPIs. However, polling cannot provide timely results, and frequent polling leads to a large number of query-type OpenAPI calls, frequently triggering throttling. This poor user experience also places significant pressure on the ECS system, negatively impacting system performance. Currently proposed cloud servers provide a method for creating events, allowing users to obtain operation results by subscribing to them. For example, a disk creation event is provided. After a disk is created, the disk creation event is delivered to EventBridge, where users can subscribe to the event. However, this solution is cumbersome and results in low processing efficiency. Currently, no effective solution has been proposed to address the aforementioned issues. The present disclosure provides an operation result processing method, an electronic device, and a computer-readable storage medium to at least address the technical problem in related technologies of obtaining operation results through event subscription, which results in cumbersome operations and low processing efficiency.According to one aspect of an embodiment of the present disclosure, a method for processing operation results is provided, comprising: generating target event service information and target message service information in response to an initialization configuration operation by a client, wherein the initialization configuration operation is used to initialize the configuration of a software development kit for an asynchronous open application program interface (API), the target event service information is used to determine a rule for subscribing to asynchronous open application program interface operation results in an event-driven manner, and the target message service information is used to deliver the asynchronous open application program interface operation results; obtaining target configuration parameters based on the target event service information and the target message service information, wherein the target configuration parameters are configuration parameters for subscribing to asynchronous open application program interface operation results in an event-driven manner; and returning the target configuration parameters to the client, so that the client subscribes to the asynchronous open application program interface operation results in an event-driven manner. According to another aspect of an embodiment of the present disclosure, a method for processing operation results is provided, comprising: performing an initialization configuration operation on a server, wherein the initialization configuration operation is used to initialize the configuration of a software development kit for an asynchronous open application program interface (API); receiving target configuration parameters returned by the server, wherein the target configuration parameters are obtained based on target event service information and target message service information, the target configuration parameters being configuration parameters for subscribing to asynchronous open application program interface operation results in an event-driven manner, the target event service information being used to determine rules for subscribing to asynchronous open application program interface operation results in an event-driven manner, and the target message service information being used to deliver the asynchronous open application program interface operation results; and subscribing to the asynchronous open application program interface operation results in an event-driven manner based on the target configuration parameters. According to another aspect of an embodiment of the present disclosure, an operation result processing method is also provided, including: obtaining an operation result processing request through a first application programming interface, wherein the operation result processing request includes: target configuration parameters, the target configuration parameters are configuration parameters for subscribing to asynchronous open application program interface operation results in an event-driven manner, the target configuration parameters are obtained based on target event service information and target message service information, the target event service information is used to determine rules for subscribing to asynchronous open application program interface operation results in an event-driven manner, and the target message service information is used to deliver the asynchronous open application program interface operation results; returning an operation result processing response through a second application programming interface, wherein the operation result processing response includes: the asynchronous open application program interface operation result.According to another aspect of an embodiment of the present disclosure, an operation result processing method is provided, comprising: obtaining a currently input operation result processing dialog request, wherein the operation result processing dialog request includes target configuration parameters, which are configuration parameters for subscribing to asynchronous open API operation results in an event-driven manner. The target configuration parameters are obtained based on target event service information and target message service information. The target event service information is used to determine rules for subscribing to asynchronous open API operation results in an event-driven manner. The target message service information is used to transmit the asynchronous open API operation results. In response to the operation result processing dialog request, an operation result processing dialog reply is returned, wherein the operation result processing dialog reply includes the asynchronous open API operation result. The asynchronous open API operation result is displayed in a graphical user interface. According to another aspect of an embodiment of the present disclosure, an electronic device is provided, comprising: a memory storing an executable program; and a processor for executing the program. When the program executes, any one of the above-described operation result processing methods is executed. According to another aspect of an embodiment of the present disclosure, a computer-readable storage medium is provided. The computer-readable storage medium includes a stored executable program. When the executable program is executed, the device containing the computer-readable storage medium is controlled to execute any one of the aforementioned operation result processing methods. According to another aspect of an embodiment of the present disclosure, a computer program product is provided. The computer program includes a computer program. When executed by a processor, the computer program implements any one of the aforementioned operation result processing methods.In the disclosed embodiment, after receiving an initial configuration operation from a client, that is, receiving an operation to initialize the configuration of the asynchronous OpenAPI SDK, the initial configuration is completed, and target event service information for determining a rule for subscribing to asynchronous OpenAPI operation results in an event-driven manner and target message service information for delivering asynchronous OpenAPI operation results are generated. In other words, EventBridge subscription rules and Message Service (MNS) queues are created. Then, based on the EventBridge subscription rules and the Message Service (MNS) queue, target configuration parameters corresponding to subscribing to asynchronous OpenAPI operation results in an event-driven manner are obtained. Finally, the target configuration parameters are returned to the client, enabling the client to subscribe to asynchronous OpenAPI operation results in an event-driven manner. This achieves the purpose of subscribing to asynchronous OpenAPI operation results in an event-driven manner through simple operations and real-time perception of task operation results. This reduces the number of query OpenAPI calls, reduces ECS system pressure, improves ECS system processing efficiency, allows real-time perception of task operation results, and improves user experience. Furthermore, the technical problem in related technologies of obtaining operation results by subscribing to events, which results in cumbersome operations and low processing efficiency, is solved. It should be noted that the general description above and the detailed description that follows are merely examples and explanations of the present disclosure and do not constitute limitations on the present disclosure. BRIEF DESCRIPTION OF THE DRAWINGS The drawings described herein are intended to provide a further understanding of the present disclosure and constitute a part of the present disclosure. The illustrative embodiments of the present disclosure and their descriptions are intended to explain the present disclosure and do not constitute undue limitations on the present disclosure.In the accompanying drawings: Figure 1 is a hardware structure block diagram of a computer terminal (or mobile device) for implementing an operation result processing method according to Example 1 of the present disclosure; Figure 2 is a flowchart of an operation result processing method according to Example 1 of the present disclosure; Figure 3 is a flowchart of a method of publishing OpenAPI according to Example 1 of the present disclosure; Figure 4 is a flowchart of an event-driven subscription to asynchronous 0 penAPI operation results according to Example 1 of the present disclosure; Figure 5 is a flowchart of an operation result processing method according to Example 2 of the present disclosure; Figure 6 is a flowchart of an operation result processing method according to Example 3 of the present disclosure; Figure 7 is a flowchart of an operation result processing method according to Example 4 of the present disclosure; Figure 8 is a structural schematic diagram of an operation result processing device according to Example 5 of the present disclosure; Figure 9 is a structural schematic diagram of another operation result processing device according to Example 5 of the present disclosure; Figure 10 is a structural schematic diagram of another operation result processing device according to Example 5 of the present disclosure; Figure 11 is a structural schematic diagram of another operation result processing device according to Example 5 of the present disclosure; Figure 12 is a structural block diagram of a computer terminal according to an embodiment of the present disclosure. DETAILED DESCRIPTION To help those skilled in the art better understand the present disclosure, the following will provide a clear and complete description of the technical solutions in the embodiments of the present disclosure, in conjunction with the accompanying drawings. It should be noted that the described embodiments represent only a portion of the present disclosure, and are not exhaustive. All other embodiments derived by persons of ordinary skill in the art based on the embodiments of the present disclosure without inventive effort should fall within the scope of protection of the present disclosure. It should be noted that the terms "first," "second," and so on, in the specification and claims of the present disclosure, and in the accompanying drawings, are used to distinguish similar objects and are not necessarily used to describe a specific order or precedence. It should be understood that such terms are interchangeable where appropriate, so that the embodiments of the present disclosure described herein can be implemented in an order other than that illustrated or described herein. Furthermore, the terms "including," "having," and any variations thereof, are intended to cover non-exclusive inclusions. For example, a process, method, system, product, or apparatus comprising a series of steps or units is not necessarily limited to the steps or units expressly listed, but may include other steps or units not expressly listed or inherent to such process, method, product, or apparatus.First, some nouns or terms that appear in the description of the embodiments of this disclosure are subject to the following explanations: Elastic Compute Service (ECS): This is a flexible, secure, stable, and high-performance cloud computing service that allows users to rent virtual machine instances in the cloud, including central processing units (CPUs), memory, storage, and network resources, to meet various computing needs. Users can purchase, release, and manage these virtual machine instances at any time based on their needs, achieving flexible computing resource allocation. ECS also provides a variety of instance types and configuration options, as well as support for multiple operating systems and application environments to meet the needs of different workloads. Open Application Programming Interface (OpenAPI): In the internet age, encapsulating website services into a series of computer-readable data interfaces and making them available to third-party developers is called an open website application programming interface (API). oCorrespondingly, the open API is called the OpenAPI. EventBridge: An event hub located in the cloud, it provides a unified event center, using standardized protocols to manage events generated within cloud products, Software as a Service (SaaS) products, and user management tasks. In the disclosed embodiments, users can use events to build a loosely coupled, distributed event-driven architecture. Events: ECS events, used to record and notify cloud resource information, such as the execution status of maintenance tasks, resource anomalies, and resource status changes. Event-Driven Architecture (EDA): A modern architectural pattern built from small, decoupled services that publish, consume, or route events. Events represent changes or updates to state, such as items added to a shopping cart, files uploaded to a storage system, or orders ready for shipment. Events can carry state (such as the item name, price, or quantity in an order) or simply contain identifiers needed to find relevant information (for example, "Order #8942 has shipped"). Unlike traditional request-driven models, EDA promotes loose coupling between producer and consumer services, making it easier to expand, update, and independently deploy individual components of the system. A Platform of Platforms (POP) is a platform that integrates multiple API services, helping developers manage and use multiple APIs on the same platform. Related technologies, which create events and allow users to subscribe to them to obtain operation results, have the following drawbacks: Defect 1: The entire solution consists of documentation, making the operation process cumbersome. Defect 2: It covers relatively few OpenAPIs and is not specifically targeted at asynchronous OpenAPIs, failing to cover all asynchronous OpenAPIs. Defect 3: The API page lacks information about events, and event-driven development is not integrated into the API SDK, resulting in a relatively fragmented process. Prior to the present disclosure, no effective solutions to the above drawbacks had been proposed. Example 1: According to an embodiment of the present disclosure, a method for processing operation results is provided. It should be noted that the steps shown in the flowcharts of the accompanying figures can be executed in a computer system, such as a set of computer-executable instructions. Furthermore, while the flowcharts illustrate a logical order, in some cases, the steps shown or described may be executed in a different order. The method embodiment provided in the first embodiment of the present disclosure may be executed in a mobile terminal, a computer terminal, or a similar computing device.FIG1 is a block diagram of the hardware structure of a computer terminal (or mobile device) for implementing an operation result processing method according to Embodiment 1 of the present disclosure. As shown in FIG1 , the computer terminal 10 (or mobile device) may include one or more processors 102 (illustrated as 102a, 102b, 102c, and 102n) (processor 102 may include, but is not limited to, a processing device such as a microcontroller unit (MCU) or a programmable logic device (FPGA)), a memory 104 for storing data, and a transmission device 106 for communication functions. In addition, the computer terminal 100 (or mobile device) may include: a display, an input / output (I / O) interface, a universal serial bus (USB) port (which may be included as one of the ports of a BUS), a network interface, a power supply, and / or a camera. Those skilled in the art will appreciate that the structure shown in FIG1 is merely illustrative and does not limit the structure of the electronic device described above. For example, the computer terminal 10 may include more or fewer components than shown in FIG. 1 , or have a configuration different from that shown in FIG. It should be noted that the one or more processors 102 and / or other data processing circuits described above may generally be referred to herein as "data processing circuitry." This data processing circuitry may be embodied in whole or in part as software, hardware, firmware, or any other combination thereof. Furthermore, the data processing circuitry may be a single, independent processing module, or may be fully or partially integrated into any of the other components of the computer terminal 10 (or mobile device). As described in the embodiments of the present disclosure, the data processing circuitry functions as a processor control (e.g., selecting a variable resistor terminal path connected to an interface). The memory 104 may be used to store software programs and modules of application software, such as the program instructions / data storage device corresponding to the operation result processing method in the embodiments of the present disclosure. The processor 102 executes the software programs and modules stored in the memory 104 to execute various functional applications and data processing, thereby implementing the aforementioned operation result processing method. The memory 104 may include high-speed random access memory (RAM) or non-volatile memory, such as one or more magnetic storage devices, flash memory, or other non-volatile solid-state memory. In some examples, the memory 104 may further include memories remotely located relative to the processor 102 , and these remote memories may be connected to the computer terminal 10 via a network.Examples of the aforementioned networks include, but are not limited to, the Internet, corporate intranets, local area networks, mobile communication networks, and combinations thereof. Transmission device 106 is used to receive or send data via a network. Specific examples of the aforementioned networks may include a wireless network provided by the communications provider of computer terminal 10. In one example, transmission device 106 includes a network interface controller (NIC), which can be connected to other network devices via a base station to enable communication with the Internet. In one example, transmission device 106 can be a radio frequency (RF) module for wireless communication with the Internet. The display can be, for example, a touchscreen liquid crystal display (LCD), which enables a user to interact with the user interface of computer terminal 10 (or mobile device). In the aforementioned operating environment, the present disclosure provides an operation result processing method as shown in FIG2 . FIG2 is a flow chart of an operation result processing method according to Example 1 of the present disclosure. As shown in Figure 2, the method may include the following steps: Step S21: In response to an initial configuration operation by a client, generating target event service information and target message service information, wherein the initial configuration operation is used to initialize the configuration of the asynchronous open API software development kit, the target event service information is used to determine rules for subscribing to asynchronous open API operation results in an event-driven manner, and the target message service information is used to transmit the asynchronous open API operation results; Step S22: Retrieving target configuration parameters based on the target event service information and the target message service information, wherein the target configuration parameters are configuration parameters for subscribing to asynchronous open API operation results in an event-driven manner; Step S23: Returning the target configuration parameters to the client, so that the client subscribes to the asynchronous open API operation results in an event-driven manner. The client is a user, which can be understood as a device used by the user, such as a personal computer, smartphone, tablet computer, etc., without limitation herein. The client can connect to the server via a network and send requests to the server to obtain data or perform specific operations. The initialization configuration operation is used to initialize the configuration of the asynchronous Open Application Programming Interface (OpenAPI) Software Development Kit (SDK), that is, to initialize the configuration of the asynchronous OpenAPI SDK.By initializing and configuring the SDK, the SDK is equipped with the necessary authentication, networking, and behavioral capabilities for communicating with asynchronous OpenAPIs. This allows the SDK to better adapt to different usage scenarios and improve stability, performance, and maintainability. The target event service information can be understood as EventBridge subscription rules, which are used to determine the rules for subscribing to asynchronous OpenAPI operation results via an event-driven approach. In the disclosed embodiments, for asynchronous OpenAPIs, to avoid issues such as delayed results due to polling and the high volume of query-type OpenAPI calls, an event-driven subscription approach is adopted to obtain asynchronous OpenAPI operation results in a timely manner. The target event service information can be understood as the rules defined for this method. The target message service information can be understood as a message service (MNS) queue, used to deliver asynchronous OpenAPI operation results, specifically, the execution status and results of asynchronous operations executed via the asynchronous OpenAPI. Target configuration parameters are the configuration parameters for subscribing to asynchronous OpenAPI operation results in an event-driven manner. It's understood that each asynchronous OpenAPI corresponds to an event, so there are multiple types of events. For example, when calling an additional network card, an asynchronous OpenAPI generates a "Call additional network card operation completed" event after the entire operation is completed. Target configuration parameters can be understood as the configuration parameters required for event subscriptions, and different events correspond to different configuration parameters. For example, configuration parameters may include the MNS queue name, the MNS queue access address (endpoint), and user login account information, etc., without limitation here. In the embodiment of the present disclosure, after receiving the initialization configuration operation from the client, that is, receiving the operation to initialize the configuration of the asynchronous OpenAPI SDK, the server completes the initialization configuration and generates target event service information for determining the rules for subscribing to the asynchronous OpenAPI operation results in an event-driven manner, and target message service information for delivering the asynchronous OpenAPI operation results, that is, creating EventBridge subscription rules and MNS queues, and then obtaining the corresponding target configuration parameters for subscribing to the asynchronous OpenAPI operation results in an event-driven manner based on the EventBridge subscription rules and MNS queues, and finally returning the target configuration parameters to the client, so that the client can subscribe to the asynchronous OpenAPI operation results in an event-driven manner.As can be seen, this disclosure integrates event-driven functionality into the SDK, enabling users to subscribe to asynchronous OpenAPI operation results in an event-driven manner. This allows users to conveniently use event-driven services and receive real-time task operation results with only simple configuration. This reduces the number of query OpenAPI calls, alleviates system pressure on the ECS, and avoids the issue of frequent polling leading to excessive query OpenAPI calls and triggering throttling, providing users with a more efficient and convenient service experience. This achieves the goal of enabling simple operations to subscribe to asynchronous OpenAPI operation results in an event-driven manner and receive real-time task operation results. This results in the technical benefits of reducing the number of query OpenAPI calls, reducing system pressure on the ECS, improving ECS ​​system processing efficiency, providing real-time task operation results, and enhancing the user experience. The above-mentioned operation result processing method provided by the embodiments of the present disclosure can be applied to, but is not limited to, application scenarios involving operating resources through interfaces in the fields of e-commerce services, education services, legal services, medical services, conference services, social network services, financial product services, logistics services, and navigation services. For example, operating resources through interfaces in e-commerce service scenarios, operating resources through interfaces in education service scenarios, and operating resources through interfaces in legal service scenarios, etc., are not limited here. According to the disclosed embodiments, after receiving an initial configuration operation from a client, that is, receiving an operation to initialize the configuration of an asynchronous OpenAPI SDK, the initial configuration is completed, and target event service information for determining a rule for subscribing to asynchronous OpenAPI operation results in an event-driven manner and target message service information for delivering asynchronous OpenAPI operation results are generated. In other words, an EventBridge subscription rule and an MNS queue are created. Then, based on the EventBridge subscription rule and the MNS queue, target configuration parameters corresponding to subscribing to asynchronous OpenAPI operation results in an event-driven manner are obtained. Finally, the target configuration parameters are returned to the client, enabling the client to subscribe to asynchronous OpenAPI operation results in an event-driven manner. This achieves the purpose of subscribing to asynchronous OpenAPI operation results in an event-driven manner through simple operations and real-time perception of task operation results. This reduces the number of query OpenAPI calls, reduces ECS system pressure, improves ECS system processing efficiency, allows real-time perception of task operation results, and improves user experience. Furthermore, the technical problem in related technologies of obtaining operation results by subscribing to events, which results in cumbersome operations and low processing efficiency, is solved.In an optional embodiment, the operation result processing method further includes the following method steps: Step S241: Identifying the application program interface (API) to be published as an asynchronous open API, wherein the asynchronous open API is used to call cloud server resources to execute the target cloud service; Step S242: Selecting a target event corresponding to the asynchronous open API, wherein the target event is used to determine whether the target cloud service has been executed; Step S243: Publishing the asynchronous open API and an event-driven integration document, wherein the event-driven integration document provides a document description for subscribing to the results of the asynchronous open API operation in an event-driven manner. In the disclosed embodiment, OpenAPI can also be published. It is understood that publishing OpenAPI includes publishing synchronous OpenAPI and asynchronous OpenAPI. Cloud server resources are ECS resources, which can be understood as various manageable computing resources on the cloud server ECS, including virtual machine instances, storage, network configuration, security group settings, etc., without limitation herein. It is understood that users can execute different tasks by calling different asynchronous OpenAPIs, and when a task is completed, a task completion event is generated. In the disclosed embodiments, the target event is an event corresponding to an asynchronous OpenAPI, used to confirm that the target cloud service executed by calling the asynchronous OpenAPI has completed execution. It is understood that, when publishing an OpenAPI, an OpenAPI description document describing and defining the OpenAPI is also published, so that client applications can understand how to interact with the OpenAPI. In the disclosed embodiments, the event-driven integrated document can be understood as an OpenAPI description document that integrates the results of asynchronous OpenAPI operation subscriptions via an event-driven approach. Specifically, a document describing the results of asynchronous OpenAPI operation subscriptions via an event-driven approach is added to the OpenAPI description document to provide a document describing the results of asynchronous OpenAPI operation subscriptions via an event-driven approach. In the disclosed embodiments, when publishing an asynchronous OpenAPI, the application program interface to be published can be identified as an asynchronous OpenAPI, that is, the API to be published can be identified as an asynchronous OpenAPI. In the disclosed embodiments, the asynchronous OpenAPI can execute the corresponding cloud service by invoking ECS ​​resources. After the asynchronous OpenAPI is identified, a target event corresponding to the asynchronous OpenAPI may be selected, so that by generating the target event, it can be determined that the target cloud service executed by calling the asynchronous OpenAPI has been completed.The asynchronous OpenAPI is then published, along with an event-driven integration document that provides a document description for subscribing to asynchronous OpenAPI operation results in an event-driven manner. For example, the API publisher can identify the API to be published as an asynchronous OpenAPI and publish the API identified as such to the POP platform. The POP platform then selects the target event corresponding to the completion of the asynchronous OpenAPI asynchronous service execution, and then publishes the event-driven integration document to the official API documentation website. This is not a limitation. In an optional embodiment, in step S22, target configuration parameters are obtained based on the target event service information and the target message service information, including the following method steps: Step S221: Determine an event processing method for the target event based on the target event service information, where the event processing method is used to determine the event mode and event target; Step S222: Determine the content to be configured of the target message service information using the event processing method; Step S223: Generate target configuration parameters based on the content to be configured. In the disclosed embodiments, target event service information, namely EventBridge subscription rules, can be understood as rules defined in EventBridge, namely EventBridge event rules, which are used to capture specific types of events and route them to designated event targets. EventBridge event rules can filter and match based on conditions such as event patterns, event sources, and event targets, thereby enabling monitoring and processing of specific events. For example, an event pattern can be understood as a pattern or regularity in event occurrence, which can be regularities in time, location, characteristics, and so on. An event source can be understood as the initiator or generator of an event, which can be a system, a device, a user, etc. An event target refers to the matching object or processing object of an event rule, which can be an alarm, a notification, an action, etc., without limitation. In the disclosed embodiments, the event bus EventBridge filters events based on event patterns and routes them to event targets. The event processing method is used to determine the event pattern and event target of the target event. The content to be configured may include the MNS queue name, the access address (endpoint) of the MNS queue, the user login account information, etc., which are not limited here.In the disclosed embodiment, when acquiring target configuration parameters based on target event service information and target message service information, the event handling method for the target event can be determined based on the target event service information. Specifically, the event pattern and event target of the target event are determined using EventBridge event rules. The event pattern and event target are then used to determine the content to be configured in the target message service information. The corresponding target configuration parameters are then generated based on the content to be configured. In an optional embodiment, in step S221, determining the event handling method for the target event based on the target event service information includes the following method steps: Step S2211: Acquiring the event source, event type, service type, queue identifier, and message body type corresponding to the target event based on the target event service information; Step S2212: Determining the event pattern using the event source and event type, and determining the event target using the service type, queue identifier, and message body type. The event pattern is used to filter the target event, and the event target is used to determine the delivery recipient of the target event. In the disclosed embodiments, in event rules, the event source represents the initiator of the event or the service that generates the event. This refers to the source of the event, which can be an ECS service, a third-party service, a custom application, and so on, without limitation. Specifying the event source helps event rules filter and process only events from a specific source. The event type corresponds to the asynchronous OpenAPI event type, indicating the type or category of the event. Different event types may correspond to different operations or behaviors. By specifying the event type, event rules can process only events of a specific type, thereby achieving more precise event processing. The service type indicates the service to which the event belongs. For example, if the Message Service (MNS) protocol is selected, different services will generate different events. By specifying the service type, event rules can process only events of a specific service type. The queue ID refers to the queue identifier associated with the event, such as the ID of a created Message Service (MNS) queue. The queue ID can be used to specify the queue to which the message should be sent. The message body type indicates the type of data carried by the event. Events typically carry some relevant data. Specifying the message body type helps event rules accurately parse and process the event data. For example, the data carried by the event can be filtered to extract only certain fields. The message body type can be a complete event, a partial event, a fixed value, a template, etc., and is not limited here.In the disclosed embodiment, when determining the event handling method for a target event based on the target event service information, the event source, event type, service type, queue identifier, and message body type corresponding to the target event can be obtained based on the target event service information. The event source and event type are then used to determine the event mode, and the service type, queue identifier, and message body type are used to determine the event target. In an optional embodiment, the operation result processing method further includes the following method steps: Step S251, generating a software development kit based on event-driven code, wherein the event-driven code is code for subscribing to asynchronous Open API operation results in an event-driven manner; and Step S252, publishing the software development kit. In the disclosed embodiment, when integrating event-driven functionality into an SDK, the SDK can be generated based on the event-driven code, i.e., the generated SDK includes code for subscribing to asynchronous Open API operation results in an event-driven manner. The SDK is then published, allowing users to complete event subscriptions with only configuration. For example, the API publisher can publish the API SDK to the POP platform, and the POP platform can then integrate the code for event-driven subscription to asynchronous OpenAPI operation results into the SDK, thereby implementing the OpenAPI SDK release. This is not a limitation here. In an optional embodiment, the operation result processing method further includes the following method steps: Step S261: Receiving a code configuration request from a client, wherein the code configuration request includes target configuration parameters; Step S262: Configuring the target configuration parameters into the event-driven code of the software development kit. In the disclosed embodiment, the server may also receive a code configuration request from the client, wherein the code configuration request includes target configuration parameters, such as the MNS queue name, the MNS queue access address (endpoint), and user login account information. After receiving the code configuration request from the client, the server configures the target configuration parameters into the event-driven code of the SDK, thereby enabling event-driven subscription to asynchronous OpenAPI operation results.In an optional embodiment, the operation result processing method further includes the following method steps: Step S271: In response to a document review request from a client, presenting an event-driven integrated document to the client; Step S272: In response to an activation authorization message initiated by the client based on the event-driven integrated document, activating authorized event services and message services. The event service is used to subscribe to target events through the client and deliver the target events to a message queue corresponding to the message service using a transmission protocol corresponding to the message service. The message service is used to subscribe to target events through the client and deliver the target events to the client. The event service can be an EventBridge service, which is used to subscribe to target events through the client and deliver the target events to a message queue corresponding to the message service using a transmission protocol corresponding to the message service (i.e., the Messaging Service). In the disclosed embodiment, the ECS delivers events to EventBridge, which then delivers the events to the user according to the configured protocol. Activating EventBridge service authorization enables users to select an appropriate protocol (e.g., Messaging Service) to subscribe to events through EventBridge. The message service can be an MNS service, which is used to subscribe to target events through clients and deliver them to the clients. It is understood that MNS is an efficient, reliable, secure, convenient, and scalable distributed messaging service that helps developers freely transfer data and notification messages between distributed components of an application, thereby building loosely coupled systems. In the disclosed embodiment, activating MNS service authorization allows users to select the MNS protocol after an event arrives at EventBridge. EventBridge then reaches the user through the MNS messaging service, allowing the user to subscribe to events through MNS in their code. In the disclosed embodiment, the server may also receive a document review request and an authorization message from the client. If the server receives the document review request from the client, it can display the event-driven integration documentation to the client, allowing the user to review the event-driven integration documentation and access events based on the documentation. It is understood that if the user is familiar with the documentation, they may not need to review the documentation. However, if the user is using the service for the first time, they will need to review the documentation. If the server receives the activation authorization message initiated by the client based on the event-driven integration document, it can activate the authorization event service and message service accordingly, that is, activate the EventBridge service and MNS service.In an optional embodiment, generating target event service information and target message service information in step S21 includes the following method steps: Step S211: Using a software development kit, calling an event service to generate target event service information, and calling a message service to generate target message service information. In this disclosed embodiment, when generating the target event service information and target message service information, the software development kit can call the event service to generate the target event service information, and the message service to generate the target message service information. Specifically, an SDK integrated with event-driven code can be used to call the EventBridge service to generate EventBridge subscription rules, and to call the MNS service to generate an MNS queue. In an optional embodiment, the operation result processing method further includes the following method steps: Step S281: In response to a client's subscription rule query request, querying and maintaining the target event subscription rules through the event service. In an embodiment of the present disclosure, the server may also receive a request from the client to query subscription rules. After receiving the request, the server may query and maintain the target event subscription rules through the event service, allowing users to view and maintain the created EventBridge subscription rules on EventBridge. In an optional embodiment, the operation result processing method further includes the following method steps: Step S291: In response to the client's message queue query request, query and maintain the target event message queue through the message service. In an embodiment of the present disclosure, the server may also receive a request from the client to query message queue. After receiving the client's message queue query request, the server may query and maintain the target event message queue through the message service, allowing users to view and maintain the created MNS queue on the MNS. Figure 3 is a flowchart of publishing an OpenAPI according to Example 1 of the present disclosure. As shown in Figure 3, the API publisher identifies the API to be published as an asynchronous OpenAPI and publishes the API identified as asynchronous OpenAPI to the POP platform. The POP platform selects the target event corresponding to the completion of the asynchronous OpenAPI asynchronous service execution. The POP platform then publishes the event-driven integration document to the official website's API documentation to complete the API publication. In addition, the API publisher can publish the API SDK to the POP platform, and then the POP platform will integrate the code for event-driven subscription to asynchronous OpenAPI operation results into the SDK and publish the OpenAPI SDK to complete the SDK release.FIG4 is a flow chart of an event-driven subscription to asynchronous 0 penAPI operation results according to Embodiment 1 of the present disclosure. As shown in FIG4 , API users can view the API documentation of the official website generated when the API is released, and thereby access events according to the documentation.

[0002] API users can also initiate authorization messages to activate the EventBridge service and initiate authorization messages to activate the Message Queue (MNS) service, so that the server will activate the EventBridge service and MNS service accordingly.

[0003] API users can also specify the target event to be executed, initialize the published OpenAPISDK, and create MNS queues and EventBridge subscription rules through OpenAPISDK. OpenAPISDK receives the MNS queue information returned by MSN and returns the configuration parameters required for subscription events to API users, such as the MNS queue name and MNS queue access address.

[0004] After obtaining the configuration parameters, API users can also configure the parameters and subscribe to events through OpenAPISDK.

[0005] API users can also initiate subscription rule query requests to view and maintain the created EventBridge subscription rules in EventBridge.

[0006] API users can also initiate message queue query requests and view and maintain the created MNS queues in MNS. It can be seen that users can authorize products according to the OpenAPI event-driven document, and then through simple configuration in the SDK, they can complete the subscription of asynchronous OpenAPI operation results in an event-driven manner, avoiding the problem of poor polling experience, thereby achieving a better user experience. In addition, it can also reduce the number of calls to query OpenAPI and reduce the pressure on the ECS system. It is easy to understand that the beneficial effects of the operation result processing method provided by the present disclosure include the following points. Beneficial effect (1): The present disclosure integrates the event-driven code into the OpenAPI SDK. Users only need to make simple configurations to subscribe to asynchronous OpenAPI operation results in an event-driven manner, thereby simplifying the operation process. Beneficial effect (2): Each API in the present disclosure only needs to select the corresponding event-driven event name in the API publishing platform to automatically publish the OpenAPI document. At the same time, the OpenAPI SDK provided by the present disclosure can easily cover each asynchronous OpenAPI and can cover more OpenAPIs. Beneficial effect (3): This disclosure deeply integrates event-driven and asynchronous OpenAPI. The entire process from OpenAPI configuration, OpenAPI document publishing, and OpenAPI SDK is integrated with event-driven and introduced in the API description document so that the client application can understand how to interact with the OpenAPI. Beneficial effect (4): This disclosure is based on the ECS event-driven architecture SDK and MNS transmission protocol, which can avoid polling, reduce the pressure on the ECS system, perceive the business operation results in real time, and bring users a more efficient and convenient service experience. It should be noted that the user information (including but not limited to user device information, user personal information, etc.) and data (including but not limited to data used for analysis, stored data, displayed data, etc.) involved in this disclosure are all information and data authorized by the user or fully authorized by all parties, and the collection, use and processing of relevant data must comply with the relevant laws, regulations and standards of relevant countries and regions, and provide corresponding operation entrances for users to choose to authorize or refuse. In addition, it should be noted that, for the sake of simplicity, the aforementioned method embodiments are all expressed as a series of action combinations. However, those skilled in the art should be aware that the present disclosure is not limited to the order of the actions described, because according to the present disclosure, certain steps can be performed in other orders or simultaneously.Secondly, those skilled in the art should also be aware that the embodiments described in this specification are preferred embodiments, and the actions and modules involved are not necessarily required by this disclosure. Through the above description of the embodiments, those skilled in the art will clearly understand that the methods according to the above embodiments can be implemented using software and a necessary general-purpose hardware platform, or alternatively, hardware. Based on this understanding, the technical solution of this disclosure, or the portion that contributes to the prior art, can be embodied in the form of a software product. This computer software product is stored in a storage medium (e.g., ROM / RAM, a magnetic disk, or an optical disk) and includes instructions for enabling a terminal device (which can be a mobile phone, a computer, a server, or a network device, etc.) to execute the methods described in various embodiments of this disclosure. Example 2: In the operating environment of Example 1, the present disclosure provides an operation result processing method as shown in FIG5. FIG5 is a flowchart of an operation result processing method according to Example 2 of the present disclosure. As shown in FIG5, the method includes: Step S51: performing an initialization configuration operation on the server, wherein the initialization configuration operation is used to initialize the configuration of the asynchronous open API software development kit; Step S52: receiving target configuration parameters returned by the server, wherein the target configuration parameters are obtained based on target event service information and target message service information. The target configuration parameters are configuration parameters for subscribing to asynchronous open API operation results in an event-driven manner. The target event service information is used to determine the rules for subscribing to asynchronous open API operation results in an event-driven manner, and the target message service information is used to transmit the asynchronous open API operation results; Step S53: subscribing to the asynchronous open API operation results in an event-driven manner based on the target configuration parameters. The server is a service instance, typically a server dedicated to processing requests, capable of receiving requests from clients, processing these requests, and returning corresponding data to the clients or performing corresponding operations. The initialization configuration operation is used to initialize the configuration of the asynchronous Open Application Programming Interface (OpenAPI) Software Development Kit (SDK), that is, to initialize the configuration of the asynchronous OpenAPI SDK.By initializing and configuring the SDK, the SDK is equipped with the necessary authentication, networking, and behavioral capabilities for communicating with the asynchronous OpenAPI. This allows the SDK to better adapt to different usage scenarios and improve stability, performance, and maintainability. The target event service information can be understood as EventBridge subscription rules, which are used to determine the rules for subscribing to asynchronous OpenAPI operation results via an event-driven approach. In the disclosed embodiments, for asynchronous OpenAPI, to avoid issues such as delayed results due to polling and the high volume of query-type OpenAPI calls, an event-driven subscription method is adopted to obtain asynchronous OpenAPI operation results in a timely manner. The target event service information can be understood as the rules defined for this method. The target message service information can be understood as a message service (MNS) queue, which is used to transmit asynchronous OpenAPI operation results, specifically, the execution status and results of asynchronous operations executed via the asynchronous OpenAPI. Target configuration parameters are used to subscribe to asynchronous OpenAPI operation results in an event-driven manner. It's understood that each asynchronous OpenAPI corresponds to an event, so there are multiple types of events. For example, when calling an additional network card, an asynchronous OpenAPI generates a "Call additional network card operation completed" event after the entire operation is completed. Target configuration parameters can be understood as the configuration parameters required to subscribe to an event. Different events correspond to different configuration parameters. For example, configuration parameters may include the MNS queue name, the MNS queue access address (endpoint), and user login account information, but these are not limited here. In the disclosed embodiment, the client can perform an initial configuration operation on the server, that is, initialize the configuration of the asynchronous OpenAPI SDK to generate target event service information and target message service information on the server, that is, create EventBridge subscription rules and MNS queues. The client then receives target configuration parameters returned by the server based on the EventBridge subscription rules and MNS queues, where the target configuration parameters are obtained based on the target event service information and target message service information. Finally, based on the target configuration parameters, the client subscribes to the asynchronous open application program interface operation results in an event-driven manner.As can be seen, this disclosure integrates event-driven functionality into the SDK, enabling users to subscribe to asynchronous OpenAPI operation results in an event-driven manner. This allows users to conveniently use event-driven services and perceive task operation results in real time with only simple configuration. This reduces the number of query OpenAPI calls, alleviates pressure on the ECS system, and avoids the issue of frequent polling leading to a large number of query OpenAPI calls, which can trigger throttling. This provides users with a more efficient and convenient service experience. This achieves the goal of enabling asynchronous OpenAPI operation results subscription in an event-driven manner and real-time perception of task operation results through simple operations. This results in the technical benefits of reducing the number of query OpenAPI calls, reducing pressure on the ECS system, improving ECS ​​system processing efficiency, providing real-time perception of task operation results, and enhancing the user experience. The above-mentioned operation result processing method provided by the embodiments of the present disclosure can be applied to, but is not limited to, application scenarios involving operating resources through interfaces in the fields of e-commerce services, education services, legal services, medical services, conference services, social network services, financial product services, logistics services, and navigation services. For example, operating resources through interfaces in e-commerce service scenarios, operating resources through interfaces in education service scenarios, and operating resources through interfaces in legal service scenarios, etc., are not limited here. In the disclosed embodiment, initial configuration is performed on the server, namely, initial configuration of the asynchronous OpenAPI SDK is performed to generate target event service information and target message service information on the server, i.e., to create EventBridge subscription rules and an MNS queue. The server then receives target configuration parameters returned from the server, obtained based on the EventBridge subscription rules and the MNS queue. The target configuration parameters are obtained based on the target event service information and the target message service information. Finally, based on the target configuration parameters, an event-driven subscription is performed to the asynchronous OpenAPI operation results. This achieves the goal of subscribing to asynchronous OpenAPI operation results in an event-driven manner and real-time perception of task operation results through simple operations. This reduces the number of query OpenAPI calls, reduces ECS system pressure, improves ECS system processing efficiency, allows real-time perception of task operation results, and enhances user experience. This further addresses the technical problem in related technologies of obtaining operation results through event subscriptions, which results in cumbersome operations and low processing efficiency. It should be noted that the preferred implementation of this embodiment can be found in the relevant description of Example 1 and will not be repeated here.Example 3: In the operating environment of Example 1, the present disclosure provides an operation result processing method as shown in Figure 6. Figure 6 is a flowchart of an operation result processing method according to Example 3 of the present disclosure. As shown in Figure 6, the method includes: Step S61: Obtaining an operation result processing request through a first application programming interface, wherein the operation result processing request includes target configuration parameters, which are configuration parameters for subscribing to asynchronous open application programming interface operation results in an event-driven manner. The target configuration parameters are obtained based on target event service information and target message service information. The target event service information is used to determine the rules for subscribing to asynchronous open application programming interface operation results in an event-driven manner, and the target message service information is used to transmit the asynchronous open application programming interface operation results. Step S62: Returning an operation result processing response through a second application programming interface, wherein the operation result processing response includes the asynchronous open application programming interface operation result. The initialization configuration operation is used to initialize the configuration of the asynchronous open application programming interface (OpenAPI) software development kit (SDK), that is, to initialize the configuration of the asynchronous OpenAPI SDK. By initializing and configuring the SDK, the SDK is equipped with the necessary authentication, networking, and behavioral capabilities for communicating with the asynchronous OpenAPI. This allows the SDK to better adapt to different usage scenarios and improve stability, performance, and maintainability. The target event service information can be understood as EventBridge subscription rules, which are used to determine the rules for subscribing to asynchronous OpenAPI operation results via an event-driven approach. In the disclosed embodiments, for asynchronous OpenAPI, to avoid issues such as delayed results due to polling and the high volume of query-type OpenAPI calls, an event-driven subscription method is adopted to obtain asynchronous OpenAPI operation results in a timely manner. The target event service information can be understood as the rules defined for this method. The target message service information can be understood as a message service (MNS) queue, which is used to transmit asynchronous OpenAPI operation results, specifically, the execution status and results of asynchronous operations executed via the asynchronous OpenAPI.Target configuration parameters are used to subscribe to asynchronous OpenAPI operation results in an event-driven manner. It's understood that each asynchronous OpenAPI corresponds to an event, so there are multiple types of events. For example, when calling an additional network card, an asynchronous OpenAPI generates a "Call additional network card operation completed" event after the entire operation is completed. Target configuration parameters can be understood as the configuration parameters required to subscribe to an event. Different events correspond to different configuration parameters. For example, configuration parameters may include the MNS queue name, the MNS queue access address (endpoint), and user login account information, but these are not limited here. In an embodiment of the present disclosure, an operation result processing request is obtained through a first application programming interface (API). The operation result processing request includes target configuration parameters, which are configuration parameters for subscribing to asynchronous open API operation results in an event-driven manner. The target configuration parameters are obtained based on target event service information and target message service information. The target event service information is used to determine the rules for subscribing to asynchronous open API operation results in an event-driven manner. The target message service information is used to transmit the asynchronous open API operation results. An operation result processing response is then returned through a second application programming interface (API). The operation result processing response includes the asynchronous open API operation result. As can be seen, by integrating event-driven functionality into the SDK and subscribing to asynchronous OpenAPI operation results in an event-driven manner, the present disclosure allows users to conveniently use event-driven services and perceive task operation results in real time with only simple configuration. This reduces the number of query OpenAPI calls, reduces pressure on the ECS system, and avoids the problem of frequent polling in the ECS system leading to a large number of query OpenAPI calls, which triggers rate limiting. This provides users with a more efficient and convenient service experience. This achieves the goal of subscribing to asynchronous OpenAPI operation results in an event-driven manner through simple operations and real-time perception of task operation results. This reduces the number of query OpenAPI calls, reduces ECS system pressure, improves ECS system processing efficiency, and provides real-time perception of task operation results, thereby improving the user experience.The above-mentioned operation result processing method provided by the embodiments of the present disclosure can be applied to, but is not limited to, application scenarios involving operating resources through interfaces in the fields of e-commerce services, education services, legal services, medical services, conference services, social network services, financial product services, logistics services, and navigation services. For example, operating resources through interfaces in e-commerce service scenarios, operating resources through interfaces in education service scenarios, and operating resources through interfaces in legal service scenarios, etc., are not limited here. According to an embodiment of the present disclosure, an operation result processing request is obtained through a first application programming interface (API). The operation result processing request includes target configuration parameters, which are configuration parameters for subscribing to asynchronous open API operation results in an event-driven manner. The target configuration parameters are obtained based on target event service information and target message service information. The target event service information is used to determine rules for subscribing to asynchronous open API operation results in an event-driven manner. The target message service information is used to transmit the asynchronous open API operation results. An operation result processing response is then returned through a second application programming interface (API). The operation result processing response includes the asynchronous open API operation result. This achieves the purpose of subscribing to asynchronous open API operation results in an event-driven manner through simple operations and real-time perception of task operation results. This reduces the number of query OpenAPI calls, reduces ECS system pressure, improves ECS system processing efficiency, enables real-time perception of task operation results, and improves user experience. Furthermore, this solves the technical problem in related technologies of obtaining operation results through event subscription, which results in cumbersome operations and low processing efficiency. It should be noted that the preferred implementation of this embodiment can refer to the relevant description in Example 1 and will not be repeated here. Example 4 In the operating environment as in Example 1, the present disclosure provides an operation result processing method as shown in FIG7.FIG7 is a flowchart of an operation result processing method according to Embodiment 4 of the present disclosure. As shown in FIG7 , the method includes: Step S71: Retrieve a currently input operation result processing dialog request, wherein the operation result processing dialog request includes target configuration parameters, which are configuration parameters for subscribing to asynchronous open API operation results in an event-driven manner. The target configuration parameters are obtained based on target event service information and target message service information. The target event service information is used to determine rules for subscribing to asynchronous open API operation results in an event-driven manner, and the target message service information is used to transmit asynchronous open API operation results. Step S72: Return an operation result processing dialog reply in response to the operation result processing dialog request, wherein the operation result processing dialog reply includes the asynchronous open API operation result. Step S73: Display the asynchronous open API operation result in a graphical user interface. The operation result processing dialog request can be understood as a dialog request between a user and an intelligent machine device. The operation result processing dialog reply can be understood as a response from the intelligent machine device to the operation result processing dialog request initiated by the user. The initialization configuration operation is used to initialize the configuration of the asynchronous Open Application Programming Interface (OpenAPI) Software Development Kit (SDK), specifically the asynchronous OpenAPI SDK. Initializing the SDK configuration helps the SDK acquire the necessary authentication, networking, and behavioral capabilities for communicating with the asynchronous OpenAPI, enabling it to better adapt to different usage scenarios and offering improved stability, performance, and maintainability. The target event service information can be understood as EventBridge subscription rules, which determine the rules for subscribing to asynchronous OpenAPI operation results via an event-driven approach. In the disclosed embodiments of the asynchronous OpenAPI, to avoid the issues of polling leading to inability to timely perceive results and the high volume of query-type OpenAPI calls, an event-driven subscription method for asynchronous OpenAPI operation results is employed to obtain them in a timely manner. The target event service information can be understood as the rules defined for this method.The target message service information can be understood as a message service (MNS) queue, used to deliver asynchronous OpenAPI operation results, specifically, the execution status and results of asynchronous operations executed via the asynchronous OpenAPI. The target configuration parameters are configuration parameters for subscribing to asynchronous OpenAPI operation results in an event-driven manner. It is understood that each asynchronous OpenAPI corresponds to an event, and therefore there are multiple types of events. For example, when the asynchronous OpenAPI calls an additional network card, a "Call additional network card operation completed" event is generated after the entire operation is completed. The target configuration parameters can be understood as the configuration parameters required for event subscriptions, with different events corresponding to different configuration parameters. For example, configuration parameters may include the MNS queue name, the MNS queue access address (endpoint), user login account information, and other information, which are not limited here. In an embodiment of the present disclosure, a dialog request for processing a currently input operation result is obtained, wherein the operation result processing dialog request includes target configuration parameters, which are configuration parameters for subscribing to asynchronous open API operation results in an event-driven manner. The target configuration parameters are obtained based on target event service information and target message service information. The target event service information is used to determine rules for subscribing to asynchronous open API operation results in an event-driven manner. The target message service information is used to transmit the asynchronous open API operation results. Then, in response to the operation result processing dialog request, an operation result processing dialog reply is returned, wherein the operation result processing dialog reply includes the asynchronous open API operation result. Finally, after the asynchronous open API operation result is obtained, the asynchronous open API operation result is displayed in a graphical user interface to provide feedback to the user. As can be seen, this disclosure integrates event-driven functionality into the SDK and subscribes to asynchronous OpenAPI operation results in an event-driven manner. This allows users to conveniently use event-driven services and perceive task operation results in real time with only simple configuration. This reduces the number of query OpenAPI calls, reduces the pressure on the ECS system, and avoids the problem of frequent polling in the ECS system leading to a large number of query OpenAPI calls and triggering rate limiting, thus providing users with a more efficient and convenient service experience.Thus, the purpose of subscribing to asynchronous OpenAPI operation results in an event-driven manner through simple operations and real-time perception of task operation results is achieved, thereby achieving the technical effects of reducing the number of query-type OpenAPI calls, reducing ECS ​​system pressure, improving ECS ​​system processing efficiency, and real-time perception of task operation results, thereby improving user experience. The above-mentioned operation result processing method provided by the embodiments of the present disclosure can be applied to, but is not limited to, application scenarios involving interface resource manipulation in e-commerce services, education services, legal services, medical services, conference services, social network services, financial product services, logistics services, and navigation services. For example, resource manipulation through interfaces in e-commerce service scenarios, resource manipulation through interfaces in education service scenarios, and resource manipulation through interfaces in legal service scenarios, etc., are not limited here. According to an embodiment of the present disclosure, a currently input operation result processing dialog request is obtained. The operation result processing dialog request includes target configuration parameters, which are configuration parameters for subscribing to asynchronous open API operation results in an event-driven manner. The target configuration parameters are obtained based on target event service information and target message service information. The target event service information is used to determine the rules for subscribing to asynchronous open API operation results in an event-driven manner. The target message service information is used to transmit the asynchronous open API operation results. Then, in response to the operation result processing dialog request, an operation result processing dialog reply is returned. The operation result processing dialog reply includes the asynchronous open API operation result. Finally, after the asynchronous open API operation result is obtained, the asynchronous open API operation result is displayed in a graphical user interface to provide feedback to the user. This achieves the purpose of subscribing to asynchronous Open API operation results in an event-driven manner through simple operations and real-time perception of task operation results, thereby reducing the number of query-type OpenAPI calls, reducing ECS ​​system pressure, improving ECS ​​system processing efficiency, and providing real-time perception of task operation results. This improves the user experience. This solves the technical problem in related technologies of obtaining operation results through event subscription, which results in cumbersome operations and low processing efficiency. It should be noted that the preferred implementation of this embodiment can be found in the relevant description of Example 1 and will not be repeated here. Example 5 According to an embodiment of the present disclosure, an embodiment of a device for implementing the above-mentioned operation result processing method is also provided.8 is a schematic structural diagram of an operation result processing apparatus according to Embodiment 5 of the present disclosure. As shown in FIG8 , the apparatus includes: a first generating module 801, configured to generate target event service information and target message service information in response to an initialization configuration operation of a client, wherein the initialization configuration operation is used to initialize the configuration of a software development kit of an asynchronous open application program interface (API), the target event service information is used to determine rules for subscribing to asynchronous open application program interface (API) operation results in an event-driven manner, and the target message service information is used to deliver the asynchronous open application program interface (API) operation results; a first acquiring module 802, configured to acquire target configuration parameters based on the target event service information and the target message service information, wherein the target configuration parameters are configuration parameters for subscribing to asynchronous open application program interface (API) operation results in an event-driven manner; and a first returning module 803, configured to return the target configuration parameters to the client, so that the client subscribes to the asynchronous open application program interface (API) operation results in an event-driven manner. Optionally, the system further includes: a first publishing module configured to identify the application programming interface (API) to be published as an asynchronous open API, wherein the asynchronous open API is used to invoke cloud server resources to execute a target cloud service; select a target event corresponding to the asynchronous open API, wherein the target event is used to determine that the target cloud service has been completed; and publish an asynchronous open API and event-driven integration document, wherein the event-driven integration document provides a document describing the results of subscribing to the asynchronous open API operation via an event-driven approach. Optionally, the first acquisition module 701 is further configured to: determine an event processing method for the target event based on the target event service information, wherein the event processing method is used to determine the event mode and event target; determine the target message service information's content to be configured using the event processing method; and generate target configuration parameters based on the content to be configured. Optionally, the first acquisition module 701 is further configured to: acquire the event source, event type, service type, queue identifier, and message body type corresponding to the target event based on the target event service information; determine an event pattern using the event source and event type, and determine an event target using the service type, queue identifier, and message body type, wherein the event pattern is used to filter the target events, and the event target is used to determine the delivery recipient of the target events. Optionally, the system further includes: a second publishing module configured to generate a software development kit based on the event-driven code, wherein the event-driven code is code that subscribes to asynchronous open application program interface operation results in an event-driven manner; and publish the software development kit.Optionally, the system further includes: a configuration module configured to receive a code configuration request from a client, wherein the code configuration request includes target configuration parameters; and configure the target configuration parameters into the event-driven code of the software development kit. Optionally, the system further includes: an activation module configured to, in response to a document review request from a client, present an event-driven integration document to the client; and, in response to an activation authorization message initiated by the client based on the event-driven integration document, activate an authorized event service and a message service. The event service is configured to allow the client to subscribe to a target event and deliver the target event to a message queue corresponding to the message service using a transmission protocol corresponding to the message service. The message service is configured to allow the client to subscribe to the target event and deliver the target event to the client. Optionally, the first generation module 801 is further configured to, through the software development kit, call the event service to generate target event service information, and call the message service to generate target message service information. Optionally, the system further includes: a first maintenance module configured to, in response to a subscription rule review request from the client, review and maintain target event subscription rules through the event service. Optionally, the system further includes: a second maintenance module configured to respond to a message queue query request from a client, query and maintain a target event message queue through a message service. According to the disclosed embodiments, after receiving an initial configuration operation from a client, that is, receiving an operation to initialize the configuration of an asynchronous OpenAPI SDK, the initial configuration is completed, and target event service information for determining a rule for subscribing to asynchronous OpenAPI operation results in an event-driven manner and target message service information for delivering asynchronous OpenAPI operation results are generated. In other words, an EventBridge subscription rule and an MNS queue are created. Then, based on the EventBridge subscription rule and the MNS queue, target configuration parameters corresponding to subscribing to asynchronous OpenAPI operation results in an event-driven manner are obtained. Finally, the target configuration parameters are returned to the client, enabling the client to subscribe to asynchronous OpenAPI operation results in an event-driven manner. This achieves the purpose of subscribing to asynchronous OpenAPI operation results in an event-driven manner through simple operations and real-time perception of task operation results. This reduces the number of query OpenAPI calls, reduces ECS system pressure, improves ECS system processing efficiency, allows real-time perception of task operation results, and improves user experience. Furthermore, the technical problem in related technologies of obtaining operation results by subscribing to events, which results in cumbersome operations and low processing efficiency, is solved.It should be noted that the first generation module 801, the first acquisition module 802, and the first return module 803 described above correspond to steps S21 to S23 in Example 1. The examples and application scenarios implemented by these three modules and the corresponding steps are the same, but are not limited to the content disclosed in Example 1. It should be noted that the above modules or units may be hardware components or software components stored in a memory (e.g., memory 104) and processed by one or more processors (e.g., processors 102a, 102b, 102n). The above modules may also be part of an apparatus and run in the computer terminal 10 provided in Example 1. According to an embodiment of the present disclosure, another apparatus embodiment for implementing the above-described operation result processing method is also provided. FIG9 is a schematic structural diagram of another operation result processing apparatus according to Embodiment 5 of the present disclosure. As shown in FIG9 , the apparatus includes: a second generation module 901, configured to perform an initialization configuration operation on a server, wherein the initialization configuration operation is used to initialize the configuration of a software development kit of an asynchronous open application program interface; a second return module 902, configured to receive target configuration parameters returned by the server, wherein the target configuration parameters are obtained based on target event service information and target message service information, the target configuration parameters are configuration parameters for subscribing to asynchronous open application program interface operation results in an event-driven manner, the target event service information is used to determine rules for subscribing to asynchronous open application program interface operation results in an event-driven manner, and the target message service information is used to deliver asynchronous open application program interface operation results; and a subscription module 903, configured to subscribe to asynchronous open application program interface operation results in an event-driven manner based on the target configuration parameters.According to the disclosed embodiments, an initial configuration operation is performed on the server, that is, the asynchronous OpenAPI SDK is initialized and configured to generate target event service information and target message service information on the server, that is, to create EventBridge subscription rules and Message Service (MNS) queues. The server then receives target configuration parameters returned from the server, which are obtained based on the EventBridge subscription rules and the Message Service (MNS) queue. The target configuration parameters are obtained based on the target event service information and the target message service information. Finally, based on the target configuration parameters, the asynchronous Open API operation results are subscribed to in an event-driven manner. This achieves the purpose of subscribing to asynchronous OpenAPI operation results in an event-driven manner through simple operations and real-time perception of task operation results. This reduces the number of query OpenAPI calls, reduces ECS system pressure, improves ECS system processing efficiency, allows real-time perception of task operation results, and improves user experience. This further solves the technical problem in related technologies of obtaining operation results through event subscriptions, which results in cumbersome operations and low processing efficiency. It should be noted that the second generation module 901, the second return module 902, and the subscription module 903 correspond to steps S51 to S53 in Example 2. The examples and application scenarios implemented by these three modules and the corresponding steps are the same, but are not limited to the content disclosed in Example 1. It should be noted that the above modules or units may be hardware components or software components stored in a memory (e.g., memory 104) and processed by one or more processors (e.g., processors 102a, 102b, 102n). The above modules may also be part of an apparatus and run in the computer terminal 10 provided in Example 1. According to an embodiment of the present disclosure, another apparatus embodiment for implementing the above-mentioned operation result processing method is also provided.Figure 10 is a structural diagram of another operation result processing device according to Example 5 of the present disclosure. As shown in Figure 10, the device includes: a second acquisition module 1001, which is configured to obtain an operation result processing request through a first application programming interface, wherein the operation result processing request includes: target configuration parameters, which are configuration parameters for subscribing to asynchronous open application program interface operation results in an event-driven manner, and the target configuration parameters are obtained based on target event service information and target message service information. The target event service information is used to determine the rules for subscribing to asynchronous open application program interface operation results in an event-driven manner, and the target message service information is used to transmit the asynchronous open application program interface operation results; a third return module 1002, which is configured to return an operation result processing response through a second application programming interface, wherein the operation result processing response includes: the asynchronous open application program interface operation result. According to an embodiment of the present disclosure, an operation result processing request is obtained through a first application programming interface (API). The operation result processing request includes target configuration parameters, which are configuration parameters for subscribing to asynchronous open API operation results in an event-driven manner. The target configuration parameters are obtained based on target event service information and target message service information. The target event service information is used to determine rules for subscribing to asynchronous open API operation results in an event-driven manner. The target message service information is used to transmit the asynchronous open API operation results. An operation result processing response is then returned through a second application programming interface (API). The operation result processing response includes the asynchronous open API operation result. This achieves the purpose of subscribing to asynchronous open API operation results in an event-driven manner through simple operations and real-time perception of task operation results. This reduces the number of query OpenAPI calls, reduces ECS system pressure, improves ECS system processing efficiency, enables real-time perception of task operation results, and improves user experience. Furthermore, this solves the technical problem in related technologies of obtaining operation results through event subscription, which results in cumbersome operations and low processing efficiency. It should be noted that the second acquisition module 1001 and the third return module 1002 correspond to step S61 and step S62 in Example 3. The examples and application scenarios implemented by the two modules and the corresponding steps are the same, but are not limited to the contents disclosed in the above-mentioned Example 1.It should be noted that the above modules or units may be hardware components or software components stored in a memory (e.g., memory 104) and processed by one or more processors (e.g., processors 102a, 102b, 102n). The above modules may also be part of a device and run in the computer terminal 10 provided in Example 1. According to an embodiment of the present disclosure, another device embodiment for implementing the above-mentioned operation result processing method is also provided. Figure 11 is a structural diagram of another operation result processing device according to Example 5 of the present disclosure. As shown in Figure 11, the device includes: a third acquisition module 1101, configured to obtain a currently input operation result processing dialogue request, wherein the operation result processing dialogue request includes: target configuration parameters, which are configuration parameters for subscribing to asynchronous open application program interface operation results in an event-driven manner, and the target configuration parameters are obtained based on target event service information and target message service information. The target event service information is used to determine the rules for subscribing to asynchronous open application program interface operation results in an event-driven manner, and the target message service information is used to deliver the asynchronous open application program interface operation results; a fourth return module 1102, configured to respond to the operation result processing dialogue request and return an operation result processing dialogue reply, wherein the operation result processing dialogue reply includes: the asynchronous open application program interface operation result; and a display module 1103, configured to display the asynchronous open application program interface operation result in a graphical user interface.According to an embodiment of the present disclosure, a currently input operation result processing dialog request is obtained. The operation result processing dialog request includes target configuration parameters, which are configuration parameters for subscribing to asynchronous open API operation results in an event-driven manner. The target configuration parameters are obtained based on target event service information and target message service information. The target event service information is used to determine the rules for subscribing to asynchronous open API operation results in an event-driven manner. The target message service information is used to transmit the asynchronous open API operation results. Then, in response to the operation result processing dialog request, an operation result processing dialog reply is returned. The operation result processing dialog reply includes the asynchronous open API operation result. Finally, after the asynchronous open API operation result is obtained, the asynchronous open API operation result is displayed in a graphical user interface to provide feedback to the user. This achieves the purpose of subscribing to asynchronous Open API operation results in an event-driven manner through simple operations and real-time perception of task operation results, thereby reducing the number of query-type OpenAPI calls, reducing ECS ​​system pressure, improving ECS ​​system processing efficiency, and providing real-time perception of task operation results. This improves the user experience. This solves the technical problem in related technologies of obtaining operation results through event subscription, which results in cumbersome operations and low processing efficiency. It should be noted that the third acquisition module 1101, fourth return module 1102, and display module 1103 correspond to steps S71 to S73 in Example 4. The examples and application scenarios implemented by these three modules and the corresponding steps are the same, but are not limited to the content disclosed in Example 1. It should be noted that the above modules or units can be hardware components or software components stored in a memory (e.g., memory 104) and processed by one or more processors (e.g., processors 102a, 102b, 102n). The above modules can also be part of an apparatus and run in the computer terminal 10 provided in Example 1. It should be noted that the preferred implementation schemes involved in the above embodiments of the present disclosure are the same as the schemes, application scenarios, and implementation processes provided in Example 1, but are not limited to the schemes provided in Example 1. Example 6 The embodiments of the present disclosure can provide a computer terminal (i.e., an electronic device), which can be any computer terminal device in a computer terminal group. Optionally, in this embodiment, the computer terminal may be replaced by a terminal device such as a mobile terminal. Optionally, in this embodiment, the computer terminal may be located in at least one of a plurality of network devices in a computer network.In this embodiment, the computer terminal may execute the program code for the following steps in the operation result processing method: generating target event service information and target message service information in response to an initial configuration operation by a client, wherein the initial configuration operation is used to initialize the configuration of the asynchronous open API software development toolkit, the target event service information is used to determine rules for subscribing to asynchronous open API operation results via an event-driven approach, and the target message service information is used to transmit the asynchronous open API operation results; obtaining target configuration parameters based on the target event service information and the target message service information, wherein the target configuration parameters are configuration parameters for subscribing to asynchronous open API operation results via an event-driven approach; and returning the target configuration parameters to the client, so that the client subscribes to the asynchronous open API operation results via an event-driven approach. Optionally, Figure 12 is a block diagram of a computer terminal according to an embodiment of the present disclosure. As shown in Figure 12, the computer terminal A may include: one or more (only one shown) processors 1202, a memory 1204, a storage controller, and a peripheral interface, wherein the peripheral interface is connected to a radio frequency module, an audio module, and a display. The memory can be used to store software programs and modules, such as the program instructions / modules corresponding to the operation result processing method and apparatus in the embodiments of the present disclosure. The processor executes the stored software programs and modules to execute various functional applications and data processing, thereby implementing the aforementioned operation result processing method. The memory can include high-speed random access memory (RAM) and non-volatile memory, such as one or more magnetic storage devices, flash memory, or other non-volatile solid-state memory. In some examples, the memory can further include memory remotely located from the processor, and such remote memory can be connected to the computer terminal A via a network. Examples of such networks include, but are not limited to, the Internet, an intranet, a local area network, a mobile communication network, and combinations thereof.The processor can call the information and application stored in the memory through the transmission device to perform the following steps: generating target event service information and target message service information in response to the client's initialization configuration operation, wherein the initialization configuration operation is used to initialize the configuration of the software development tool kit of the asynchronous open application interface, the target event service information is used to determine the rules for subscribing to the results of the asynchronous open application interface operation in an event-driven manner, and the target message service information is used to transmit the results of the asynchronous open application interface operation; obtaining target configuration parameters based on the target event service information and the target message service information, wherein the target configuration parameters are configuration parameters for subscribing to the results of the asynchronous open application interface operation in an event-driven manner; and returning the target configuration parameters to the client so that the client subscribes to the results of the asynchronous open application interface operation in an event-driven manner. Optionally, the processor may further execute program code for the following steps: identifying the application program interface to be published as an asynchronous open application program interface (API), wherein the asynchronous open application program interface is used to call cloud server resources to execute a target cloud service; selecting a target event corresponding to the asynchronous open application program interface, wherein the target event is used to determine that the target cloud service has been completed; publishing an asynchronous open application program interface and an event-driven integration document, wherein the event-driven integration document is used to provide a document describing the results of subscribing to the asynchronous open application program interface operation via an event-driven approach. Optionally, the processor may further execute program code for the following steps: determining an event processing method for the target event based on the target event service information, wherein the event processing method is used to determine the event mode and event target; determining the content to be configured in the target message service information using the event processing method; and generating target configuration parameters based on the content to be configured. Optionally, the processor may further execute program code for the following steps: obtaining the event source, event type, service type, queue identifier, and message body type corresponding to the target event based on the target event service information; determining an event pattern using the event source and event type, and determining an event target using the service type, queue identifier, and message body type, wherein the event pattern is used to filter the target events, and the event target is used to determine the delivery recipient of the target events. Optionally, the processor may further execute program code for the following steps: generating a software development kit based on event-driven code, wherein the event-driven code is code that subscribes to asynchronous open application program interface operation results in an event-driven manner; and publishing the software development kit. Optionally, the processor may further execute program code for the following steps: receiving a code configuration request from a client, wherein the code configuration request includes target configuration parameters; and configuring the target configuration parameters into the event-driven code of the software development kit.Optionally, the processor may further execute program code for the following steps: in response to a document review request from a client, presenting an event-driven integrated document to the client; and in response to an authorization activation message initiated by the client based on the event-driven integrated document, activating an authorized event service and a message service. The event service is configured to allow the client to subscribe to a target event and deliver the target event to a message queue corresponding to the message service using a transmission protocol corresponding to the message service. The message service is configured to allow the client to subscribe to the target event and deliver the target event to the client. Optionally, the processor may further execute program code for the following steps: invoking the event service to generate target event service information and invoking the message service to generate target message service information via a software development kit. Optionally, the processor may further execute program code for the following steps: in response to a subscription rule review request from the client, querying and maintaining target event subscription rules via the event service. Optionally, the processor may further execute program code for the following steps: in response to a message queue review request from the client, querying and maintaining the target event message queue via the message service. According to the disclosed embodiments, after receiving an initial configuration operation from a client, that is, receiving an operation to initialize the configuration of an asynchronous OpenAPI SDK, the initial configuration is completed, and target event service information for determining a rule for subscribing to asynchronous OpenAPI operation results in an event-driven manner and target message service information for delivering asynchronous OpenAPI operation results are generated. In other words, an EventBridge subscription rule and an MNS queue are created. Then, based on the EventBridge subscription rule and the MNS queue, target configuration parameters corresponding to subscribing to asynchronous OpenAPI operation results in an event-driven manner are obtained. Finally, the target configuration parameters are returned to the client, enabling the client to subscribe to asynchronous OpenAPI operation results in an event-driven manner. This achieves the purpose of subscribing to asynchronous OpenAPI operation results in an event-driven manner through simple operations and real-time perception of task operation results. This reduces the number of query OpenAPI calls, reduces ECS system pressure, improves ECS system processing efficiency, allows real-time perception of task operation results, and improves user experience. Furthermore, the technical problem in related technologies of obtaining operation results by subscribing to events, which results in cumbersome operations and low processing efficiency, is solved.Those skilled in the art will appreciate that the structure shown in FIG12 is merely illustrative, and computer terminal A may also be a smartphone (such as an Android phone, an iOS phone, etc.), a tablet computer, a PDA, a mobile internet device (MID), a PAD, or other terminal device. FIG12 does not limit the structure of the aforementioned electronic devices. For example, computer terminal A may include more or fewer components (such as a network interface, a display device, etc.) than those shown in FIG12 , or may have a configuration different from that shown in FIG12 . Those skilled in the art will appreciate that all or part of the steps in the various methods of the aforementioned embodiments may be completed by a program instructing the hardware associated with the terminal device. The program may be stored in a computer-readable storage medium, which may include a flash drive, a read-only memory (ROM), a random access memory (RAM), a magnetic disk, or an optical disk. Example 7 The present disclosure also provides a computer-readable storage medium. Optionally, in this embodiment, the computer-readable storage medium may be used to store the program code executed by the operation result processing method provided in Example 1. Optionally, in this embodiment, the computer-readable storage medium may be located in any computer terminal in a computer terminal group in a computer network, or in any mobile terminal in a mobile terminal group. Optionally, in this embodiment, the computer-readable storage medium is configured to store program code for executing the following steps: generating target event service information and target message service information in response to an initial configuration operation by a client, wherein the initial configuration operation is used to initialize the configuration of a software development kit for an asynchronous open API, the target event service information is used to determine rules for subscribing to asynchronous open API operation results via an event-driven approach, and the target message service information is used to transmit asynchronous open API operation results; obtaining target configuration parameters based on the target event service information and the target message service information, wherein the target configuration parameters are configuration parameters for subscribing to asynchronous open API operation results via an event-driven approach; and returning the target configuration parameters to the client, so that the client subscribes to the asynchronous open API operation results via an event-driven approach.Optionally, in this embodiment, the computer-readable storage medium is configured to store program code for performing the following steps: identifying the application program interface to be published as an asynchronous open application program interface (API), wherein the asynchronous open application program interface is used to call cloud server resources to execute a target cloud service; selecting a target event corresponding to the asynchronous open application program interface, wherein the target event is used to determine that the target cloud service has been completed; publishing an asynchronous open application program interface and an event-driven integration document, wherein the event-driven integration document is used to provide a document describing the results of subscribing to the asynchronous open application program interface via an event-driven approach. Optionally, in this embodiment, the computer-readable storage medium is configured to store program code for performing the following steps: determining an event processing method for a target event based on target event service information, wherein the event processing method is used to determine an event mode and event target; determining content to be configured in target message service information using the event processing method; and generating target configuration parameters based on the content to be configured. Optionally, in this embodiment, the computer-readable storage medium is configured to store program code for performing the following steps: obtaining the event source, event type, service type, queue identifier, and message body type corresponding to the target event based on the target event service information; determining an event pattern using the event source and event type, and determining an event target using the service type, queue identifier, and message body type, wherein the event pattern is used to filter the target event, and the event target is used to determine the target event's delivery recipient. Optionally, in this embodiment, the computer-readable storage medium is configured to store program code for performing the following steps: generating a software development kit based on event-driven code, wherein the event-driven code is code that subscribes to asynchronous open application program interface operation results in an event-driven manner; and publishing the software development kit. Optionally, in this embodiment, the computer-readable storage medium is configured to store program code for performing the following steps: receiving a code configuration request from a client, wherein the code configuration request includes target configuration parameters; and configuring the target configuration parameters into the event-driven code of the software development kit. Optionally, in this embodiment, the computer-readable storage medium is configured to store program code for executing the following steps: in response to a document viewing request from a client, presenting an event-driven integrated document to the client; in response to an activation authorization message initiated by the client based on the event-driven integrated document, activating an authorized event service and a message service, wherein the event service is used to subscribe to a target event through the client, and deliver the target event to a message queue corresponding to the message service using a transmission protocol corresponding to the message service, and the message service is used to subscribe to a target event through the client, and deliver the target event to the client.Optionally, in this embodiment, the computer-readable storage medium is configured to store program code for executing the following steps: invoking an event service to generate target event service information and invoking a message service to generate target message service information via a software development kit. Optionally, in this embodiment, the computer-readable storage medium is configured to store program code for executing the following steps: in response to a client's request to query subscription rules, querying and maintaining target event subscription rules via the event service. Optionally, in this embodiment, the computer-readable storage medium is configured to store program code for executing the following steps: in response to a client's request to query message queues, querying and maintaining target event message queues via the message service. The present disclosure also provides a computer program product, including a computer program that, when executed by a processor, implements the method for processing operation results in any of the above-described embodiments. The serial numbers of the above-described embodiments of the present disclosure are for descriptive purposes only and do not represent the superiority or inferiority of the embodiments. In the above-described embodiments of the present disclosure, the descriptions of each embodiment are mutually exclusive. For portions not detailed in one embodiment, reference should be made to the relevant descriptions of other embodiments. In the several embodiments provided in this disclosure, it should be understood that the disclosed technical content can be implemented in other ways. The device embodiments described above are merely illustrative. For example, the division of units is merely a logical functional division. In actual implementation, other divisions may be employed. For example, multiple units or components may be combined or integrated into another system, or some features may be omitted or not implemented. Furthermore, the couplings or direct couplings or communication connections shown or discussed may be through interfaces, or indirect couplings or communication connections between units or modules, and may be electrical or other. The units described as separate components may or may not be physically separate, and the components shown as units may or may not be physical units, i.e., they may be located in one location or distributed across multiple network units. Some or all of these units may be selected to achieve the objectives of the present embodiments as needed. Furthermore, the functional units in the various embodiments of the present disclosure may be integrated into a single processing unit, each unit may exist physically separately, or two or more units may be integrated into a single unit. These integrated units may be implemented in either hardware or software functional units. If the integrated unit is implemented in the form of a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium.Based on this understanding, the technical solution of this disclosure, or the portion that contributes to the prior art, or all or part of this technical solution, can be embodied in the form of a software product. This computer software product, stored in a storage medium, includes instructions for causing a computer device (such as a personal computer, server, or network device) to execute all or part of the steps of the methods described in various embodiments of this disclosure. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, read-only memories (ROMs), random access memories (RAMs), removable hard drives, magnetic disks, or optical disks. The above description is merely a preferred embodiment of this disclosure. It should be noted that those skilled in the art can make various improvements and modifications without departing from the principles of this disclosure, and such improvements and modifications should also be considered within the scope of protection of this disclosure.

Claims

Claims 1. A method for processing an operation result, comprising: In response to an initialization configuration operation of the client, target event service information and target message service information are generated, wherein the initialization configuration operation is used to initialize the configuration of a software development kit of an asynchronous open application program interface, the target event service information is used to determine rules for subscribing to asynchronous open application program interface operation results in an event-driven manner, and the target message service information is used to deliver the asynchronous open application program interface operation results; target configuration parameters are obtained based on the target event service information and the target message service information, wherein the target configuration parameters are configuration parameters for subscribing to the asynchronous open application program interface operation results in the event-driven manner; and the target configuration parameters are returned to the client, so that the client subscribes to the asynchronous open application program interface operation results in the event-driven manner.

2. The operation result processing method according to claim 1, wherein: The operation result processing method also includes: identifying the application program interface to be published as the asynchronous open application program interface, wherein the asynchronous open application program interface is used to call cloud server resources to execute a target cloud service; selecting a target event corresponding to the asynchronous open application program interface, wherein the target event is used to determine that the target cloud service has been completed; publishing the asynchronous open application program interface and an event-driven integration document, wherein the event-driven integration document is used to provide a document description for subscribing to the operation result of the asynchronous open application program interface in the event-driven manner.

3. The operation result processing method according to claim 2, wherein: The acquiring of target configuration parameters based on the target event service information and the target message service information includes: determining an event processing method for the target event based on the target event service information, wherein the event processing method is used to determine an event mode and an event target; determining content to be configured of the target message service information using the event processing method; and generating the target configuration parameters through the content to be configured.

4. The operation result processing method according to claim 3, wherein: The determining of the event processing mode of the target event based on the target event service information includes: Based on the target event service information, an event source, event type, service type, queue identifier, and message body type corresponding to the target event are obtained; the event mode is determined using the event source and the event type, and the event target is determined using the service type, the queue identifier, and the message body type, wherein the event mode is used to filter the target event, and the event target is used to determine the delivery object of the target event.

5. The operation result processing method according to claim 1, wherein: The operation result processing method further includes: generating the software development kit based on event-driven code, wherein the event-driven code is code that subscribes to the asynchronous open application program interface operation result in the event-driven manner; and publishing the software development kit.

6. The operation result processing method according to claim 5, wherein: The operation result processing method further includes: receiving a code configuration request from the client, wherein the code configuration request includes: the target configuration parameters; and configuring the target configuration parameters into the event-driven code of the software development kit.

7. The operation result processing method according to claim 2, wherein: The operation result processing method also includes: in response to the document viewing request of the client, displaying the event-driven integrated document to the client; in response to the activation authorization message initiated by the client based on the event-driven integrated document, opening an authorization event service and a message service, wherein the event service is used to subscribe to the target event through the client, and deliver the target event to the message queue corresponding to the message service using the transmission protocol corresponding to the message service, and the message service is used to subscribe to the target event through the client and deliver the target event to the client.

8. The operation result processing method according to claim 7, wherein: The generating target event service information and target message service information includes: calling the event service to generate the target event service information, and calling the message service to generate the target message service information through the software development kit.

9. The operation result processing method according to claim 7, wherein: The operation result processing method further includes: in response to a subscription rule query request from the client, querying and maintaining target event subscription rules through the event service.

10. The operation result processing method according to claim 7, wherein: The operation result processing method further includes: responding to a message queue query request from the client, querying and maintaining a target event message queue through the message service.

11. A method for processing an operation result, comprising: Performing an initialization configuration operation on the server, wherein the initialization configuration operation is used to initialize the configuration of a software development kit of an asynchronous open application program interface; receiving target configuration parameters returned by the server, wherein the target configuration parameters are obtained based on target event service information and target message service information, the target configuration parameters are configuration parameters for subscribing to the asynchronous open application program interface operation results in the event-driven manner, the target event service information is used to determine rules for subscribing to the asynchronous open application program interface operation results in the event-driven manner, and the target message service information is used to deliver the asynchronous open application program interface operation results; based on the target configuration parameters, subscribing to the asynchronous open application program interface operation results in the event-driven manner.

12. A method for processing an operation result, comprising: An operation result processing request is obtained through a first application programming interface, wherein the operation result processing request includes: target configuration parameters, which are configuration parameters for subscribing to asynchronous open application program interface operation results in an event-driven manner, and the target configuration parameters are obtained based on target event service information and target message service information, the target event service information is used to determine rules for subscribing to asynchronous open application program interface operation results in an event-driven manner, and the target message service information is used to deliver the asynchronous open application program interface operation result; an operation result processing response is returned through a second application programming interface, wherein the operation result processing response includes: the asynchronous open application program interface operation result.

13. A method for processing an operation result, comprising: Obtain a currently input operation result processing dialogue request, wherein the operation result processing dialogue request includes: target configuration parameters, the target configuration parameters are configuration parameters for subscribing to asynchronous open application program interface operation results in an event-driven manner, the target configuration parameters are obtained based on target event service information and target message service information, the target event service information is used to determine a rule for subscribing to asynchronous open application program interface operation results in an event-driven manner, and the target message service information is used to transmit the asynchronous open application program interface operation results; in response to the operation result processing dialogue request, return an operation result processing dialogue reply, wherein the The operation result processing dialogue reply includes: the asynchronous open application program interface operation result; and displaying the asynchronous open application program interface operation result in a graphical user interface.

14. An electronic device, comprising: a memory storing an executable program; A processor is configured to run the program, wherein the program executes the operation result processing method according to any one of claims 1 to 13 when running.

15. A computer-readable storage medium, comprising a stored executable program, wherein when the executable program is executed, the device containing the computer-readable storage medium is controlled to execute the operation result processing method according to any one of claims 1 to 13.

16. A computer program product, comprising a computer program, wherein when executed by a processor, the computer program implements the operation result processing method according to any one of claims 1 to 13.

Images