Data interaction system and method for directly triggering Jira workflow based on flying book card message

Abstract

The invention provides a data interaction system and method for directly triggering a Jira workflow based on a flying book card message, and the method comprises the steps: monitoring a specific event through a webhook configured on a Jira platform, and transmitting event data to a local server when the specific event is monitored, and carrying out the analysis and conversion of the event data to generate flying book card information; and the local server sends the flying book card information to the created flying book application, and the flying book application forwards the received flying book card information to a specified user in a configuration permission range, so that the corresponding user enters a Jira platform through the flying book card information to perform corresponding operation. According to the method, the Jira workflow is directly triggered by the flying book card message, the information island problem existing in an existing integration scheme is solved, and the automation level and the response speed of the whole workflow are improved.

Description

Technical Field

[0001] The present invention relates to the field of computer technology, and particularly to a data interaction system and method for directly triggering a Jira workflow based on Feishu card messages. Background Art

[0002] The integration of project management and team collaboration tools has become increasingly important. Especially in the field of software development, agile development and DevOps practices have emphasized the value of rapid iteration and continuous delivery. To achieve these goals, efficient information flow and automated workflows are essential.

[0003] In actual work scenarios, project management tools such as Jira and the instant messaging platform Feishu often operate independently. This separated state has given rise to serious information silo problems, making it difficult to effectively share data between different systems and greatly hindering the improvement of team collaboration efficiency. For example, when a tester submits a bug in Jira, developers cannot promptly detect and handle it, which undoubtedly delays the best time to solve the problem and slows down the overall project progress. <L

[0004] With the continuous increase in business complexity, enterprises' demand for automation is also growing. Enterprises urgently expect to reduce human intervention, improve work efficiency, and at the same time ensure that all relevant personnel can obtain the latest project progress in real time. However, existing solutions often fall short in meeting this demand, especially when it comes to cross-platform operations, the problem is more prominent. Moreover, traditional notification methods are mostly limited to simple text forms and lack interactivity, making it difficult to meet the current needs of efficient team collaboration. Summary of the Invention

[0005] In view of the above-mentioned shortcomings of the prior art, the purpose of the present invention is to provide a data interaction system and method for directly triggering a Jira workflow based on Feishu card messages, which is used to solve the technical problems in the prior art that Jira and Feishu work independently, resulting in the inability to timely feedback project data and progress, making it impossible for staff to discover and handle in a timely manner, thereby reducing work efficiency.

[0006] To achieve the above and other related objectives, the present invention provides a data interaction system for directly triggering a Jira workflow based on Feishu card messages. The system includes: a created Feishu application configured with corresponding permissions; a Jira platform configured with a webhook for listening to specific events; and a locally built server for receiving event data from the Jira platform, converting it into a message format suitable for Feishu card display, and generating Feishu card information. Among them, specific events are listened to through the webhook, and when a specific event is detected, the event data is sent to the local server for parsing and conversion to generate Feishu card information. The local server then sends the Feishu card information to the created Feishu application, and the Feishu application forwards the received Feishu card information to designated users within the configured permission scope, enabling the corresponding users to enter the Jira platform through the Feishu card information for corresponding operations.

[0007] In an embodiment of the present invention, a Feishu application is created on the Feishu open platform, and the user ID acquisition permission and the Feishu card information sending and receiving permission of the Feishu application are configured, and an API interface is provided for the local server to call. Among them, the user ID acquisition permission includes: single user ID permission and group ID permission.

[0008] In an embodiment of the present invention, a webhook is configured on the Jira platform for a specific event, and the trigger condition of the specific event and the URL address of the local server are set. Among them, when the webhook monitors that the corresponding specific event is triggered, the event data is sent to the URL address through an HTTP request.

[0009] In an embodiment of the present invention, a webhook is configured on the Jira platform for a specific work order status change event, and the status switch between different processing stages of the corresponding work order status is used as the trigger condition, so that when the webhook monitors the status switch of the work order status in the processing stage, the current work order data is sent to the local server.

[0010] In an embodiment of the present invention, a local server is built using Python in combination with the Flask framework.

[0011] In an embodiment of the present invention, the local server parses the work order information from the work order data received from the webhook, and maps the parsed work order information to each field in the corresponding Feishu card template based on a preset data mapping rule to generate Feishu card information.

[0012] In an embodiment of the present invention, corresponding Feishu card templates are constructed according to different work order statuses. Among them, the Feishu card template includes the basic information of the work order and an operation button for users to click to enter the Jira platform.

[0013] In an embodiment of the present invention, the local server sends an authentication request to the API interface of the Feishu application based on the identity credentials provided by the Feishu application, and sends Feishu card information to the API interface after the authentication is passed.

[0014] In an embodiment of the present invention, the local server encrypts the Feishu card information containing sensitive information with SSL / TLS and then transmits it to the API interface of the Feishu application, so that the Feishu application can forward the corresponding Feishu card information to the specified users within the configured permission range after decryption.

[0015] To achieve the above and other related purposes, the present invention provides a data interaction method for directly triggering the Jira workflow based on Feishu card messages. The method includes: listening for specific events through a webhook configured on the Jira platform, and sending event data to the local server when the specific events are listened; receiving event data from the Jira platform through the local server, converting it into a message format suitable for Feishu card display to generate Feishu card information, and sending the Feishu card information to the created Feishu application; forwarding the received Feishu card information by the Feishu application to the specified users within the configured permission range, so that the corresponding users can enter the Jira platform through the Feishu card information for corresponding operations.

[0016] As described above, the present invention is a data interaction system and method for directly triggering the Jira workflow based on Feishu card messages, and has the following beneficial effects: The present invention listens for specific events through a webhook configured on the Jira platform, and sends event data to the local server for parsing and conversion to generate Feishu card information when the specific events are listened, and the local server sends the Feishu card information to the created Feishu application, and the Feishu application forwards the received Feishu card information to the specified users within the configured permission range, so that the corresponding users can enter the Jira platform through the Feishu card information for corresponding operations. The present invention realizes that the Feishu card message directly triggers the Jira workflow, not only solves the information island problem existing in the existing integration solutions, but also improves the automation level and response speed of the entire workflow. Description of the Drawings

[0017] Figure 1 It shows a schematic structural diagram of a data interaction system for directly triggering the Jira workflow based on Feishu card messages in an embodiment of the present invention.

[0018] Figure 2 It shows a schematic diagram of the bug task processing flow of a work order in an embodiment of the present invention.

[0019] Figure 3It is a schematic flowchart showing a data interaction method for directly triggering a Jira workflow based on Feishu card messages in an embodiment of the present invention. Detailed implementation manners

[0020] The following uses specific specific examples to illustrate the implementation manners of the present invention. Those skilled in the art can easily understand other advantages and effects of the present invention from the content disclosed in this specification. The present invention can also be implemented or applied through other different specific implementation manners. Various details in this specification can also be modified or changed based on different viewpoints and applications without departing from the spirit of the present invention. It should be noted that, without conflict, the following embodiments and the features in the embodiments can be combined with each other.

[0021] It should be noted that in the following description, reference is made to the accompanying drawings, which describe several embodiments of the present invention. It should be understood that other embodiments can also be used, and mechanical compositions, structures, electricals, and operations can be changed without departing from the spirit and scope of the present invention. The following detailed description should not be considered restrictive, and the scope of the embodiments of the present invention is only defined by the claims of the published patent. The terms used here are only for describing specific embodiments and are not intended to limit the present invention. Spatially related terms, such as "upper", "lower", "left", "right", "below", "beneath", "lower part", "above", "upper part", etc., can be used in the text to facilitate the description of the relationship between one element or feature shown in the figure and another element or feature.

[0022] Throughout the specification, when it is said that a certain part is "connected" to another part, this includes not only the case of "direct connection", but also the case of "indirect connection" with other elements placed in between. In addition, when it is said that a certain part "includes" a certain constituent element, unless there is a particularly contrary record, it does not mean excluding other constituent elements, but means that other constituent elements can also be included.

[0023] The first, second, and third, etc. terms mentioned therein are used to illustrate various parts, components, regions, layers, and / or segments, but are not limited thereto. These terms are only used to distinguish a certain part, component, region, layer, or segment from other parts, components, regions, layers, or segments. Therefore, the first part, component, region, layer, or segment described below can refer to the second part, component, region, layer, or segment without exceeding the scope of the present invention.

[0024] Furthermore, as used herein, the singular forms "a", "an", and "the" are intended to also include the plural forms unless the context clearly dictates otherwise. It should be further understood that the terms "comprises" and "comprising" specify the presence of the stated features, operations, elements, components, items, kinds, and / or groups, but do not preclude the presence, occurrence, or addition of one or more other features, operations, elements, components, items, kinds, and / or groups. The terms "or" and "and / or" as used herein are to be construed as inclusive or meaning any one or any combination. Thus, "A, B, or C" or "A, B, and / or C" means "any of the following: A; B; C; A and B; A and C; B and C; A, B, and C". Exceptions to this definition occur only when the combination of elements, functions, or operations are inherently mutually exclusive in some manner.

[0025] The present invention provides a data interaction system for directly triggering a Jira workflow based on Feishu card messages. By configuring a webhook on the Jira platform to listen for specific events, and when a specific event is detected, sending the event data to a local server for parsing and converting it into Feishu card information, and then the local server sends the Feishu card information to the created Feishu application, and the Feishu application forwards the received Feishu card information to a specified user within the configured permission range, so that the corresponding user can enter the Jira platform through the Feishu card information for corresponding operations. The present invention realizes directly triggering the Jira workflow with Feishu card messages, not only solving the information silo problem existing in the existing integration solutions, but also improving the automation level and response speed of the entire workflow.

[0026] The following will be described in detail with reference to the accompanying drawings for the embodiments of the present invention so that those skilled in the technical field of the present invention can easily implement it. The present invention can be embodied in many different forms and is not limited to the embodiments described herein.

[0027] As Figure 1 Shows a schematic flowchart of a data interaction system for directly triggering a Jira workflow based on Feishu card messages in an embodiment of the present invention.

[0028] The system includes:

[0029] The created Feishu application 1, configured with corresponding permissions;

[0030] The Jira platform 2, configured with a webhook for listening for specific events, and the specific event can be a change in any project data in Jira.

[0031] The built local server 3, which is used to receive event data from the Jira platform 2 and convert it into a message format suitable for Feishu card display to generate Feishu card information;

[0032] Among them, a specific event is monitored through a webhook, and when the specific event is monitored, the event data is sent to the local server 3 for parsing and conversion to generate Feishu card information. The local server 3 sends the Feishu card information to the created Feishu application 1, and the Feishu application 1 forwards the received Feishu card information to the specified users within the configured permission range, so that the corresponding users can enter the Jira platform 2 through the Feishu card information for corresponding operations.

[0033] The system realizes real-time monitoring of changes in project data in Jira by configuring a webhook in the Jira platform 2, and at the same time synchronizes these changes to Feishu through the built local server 3. Based on the powerful message push ability of Feishu, the key project progress information in Jira is accurately pushed to specific users. It is not a simple text push, but has an interactive function. The recipient can directly perform simple operations in the Feishu message to enter the Jira platform 2. This enables real-time data sharing between the Jira platform and Feishu, breaks the information barrier between the two, changes the situation where it is difficult to interoperate data between different platforms in the past, and allows developers, testers, etc. to obtain bug-related information in a timely manner. In the traditional method, a series of operations need to be manually performed in Jira to start the Jira workflow. In this system, the Feishu card message can trigger the Jira workflow with one key, reduce the manual operation steps, make the process run automatically, and greatly improve the task execution efficiency.

[0034] In one embodiment, the creation method of the Feishu application 1 includes:

[0035] Log in to the Feishu Open Platform, create the Feishu application 1 according to the guidance of the Feishu official documentation, and fill in the detailed information of the application according to actual needs, including the application name, application description, etc. For example, the application name is "Work Order Status Notification App", and the application description is "This application is used to receive Feishu card information of Jira work order status and send it to specified users or groups".

[0036] Configure the user ID acquisition permission and message sending and receiving permission of the Feishu application 1; the user ID acquisition permission includes: the permission to acquire a single user ID or a group ID; for example, in the application configuration interface, find the section related to permission management. In the permission list, check the permission to acquire a single user ID or a group ID. The permission to acquire a single user ID can be used to accurately send messages to specific users; the permission to acquire a group ID can be used to send messages to all members within the group. The message sending and receiving permission includes: the permission to receive Feishu card information from the local server 3 and the permission to send Feishu card information to users or groups within the permission scope. For example, also in the permission management section, configure the permission to receive Feishu card information from the local server 3. This means that the local server 3 can send the pre-designed Feishu card information to this application 1. Configure the permission to send Feishu card information to users or groups within the permission scope. In this way, the application can push the received card information to the specified users or groups.

[0037] Moreover, the Feishu application 1 provides API interfaces for the local server 3 to call, and it is necessary to set the specific information of the API interfaces, including the interface address, request method, request parameters, return values, etc. Ensure that the local server 3 can access these API interfaces through the network so that they can be called when needed to implement functions such as user ID acquisition and message sending and receiving.

[0038] In one embodiment, the method for configuring the webhook in the Jira platform 2 includes:

[0039] Enter the settings page of the Jira platform 2, configure the webhook for a specific event, and fill in the basic information of this webhook, including: name and description; for example, the name is "Work order status change notification", and the brief description is "When the stage status of the work order status changes, send a notification to the local server 3". And set the trigger condition of this specific event. Jira provides multiple event types for selection, and the common ones are work order creation, work order update, work order status change, etc. For example, if you are concerned about the work order status change event, select the corresponding "Work order status change" option and set the trigger condition. Also set the URL address of the local server 3, which is the URL address for the local server 3 to receive Webhook data.

[0040] Among them, when the webhook monitors that the corresponding specific event is triggered, it sends the event data to the preset URL address through an HTTP request.

[0041] In one embodiment, in Jira, there are multiple ticket statuses, such as the Bug status. When the ticket status changes, a "status change event" is generated. In the present invention, a webhook is configured on the Jira platform 2 for specific ticket status change events, and the status switch between different processing stages of the corresponding ticket status is used as the trigger condition. The webhook continuously monitors the stage changes of all ticket statuses. Whenever there is a stage change in a ticket status, Jira checks whether this status change meets the trigger condition we set. If it does, it means that the condition for triggering the Webhook is met, and the webhook will organize the relevant data of the current ticket status (such as ticket number, title, description, current status, etc.) into a suitable format (usually JSON format), and then send it to the URL of our designated local server 3 through an HTTP request. This allows the local server 3 to obtain the ticket status change information in a timely manner for subsequent processing, such as notifying relevant personnel and updating other system data.

[0042] For example, for the Bug status, common stage statuses include "submitted", "processed pending verification", "verified", and "resolved". Each time a Bug ticket changes from one status to another, a status change event is generated. When the status of a Bug ticket changes from "submitted" to "processed pending verification", it means that the developer has processed the submitted Bug and is waiting for the tester to verify it. At this time, the Webhook sends the current ticket data to the local server 3, enabling the local server 3 to communicate with the Feishu application 1 to push the "pending verification" information (including the key content of the Bug ticket) to the tester responsible for verification. When the Bug ticket changes from "processed pending verification" to "verified", it indicates that the tester has verified the fixed Bug and confirmed that it has been repaired. At this time, the Webhook sends the current ticket data to the local server 3, enabling the local server 3 to communicate with the Feishu application 1 to send the "verified" information to relevant personnel (such as project managers, developers, etc.), informing them that the Bug has passed the verification and can enter the resolution process. When the Bug ticket changes from "verified" to "resolved", it means that this Bug has completed the entire processing process. At this time, the Webhook sends the current ticket data to the local server 3, enabling the local server 3 to communicate with the Feishu application 1 to send the "resolved" information to all users who are concerned about this Bug, notifying them that this Bug has been completely resolved.

[0043] In one embodiment, a local server 3 is set up using Python in combination with the Flask framework. Python has a concise syntax and strong readability, and the core of Flask is lightweight and has no complex configuration. The combination of the two greatly improves the development efficiency, allowing developers to quickly get started and accelerate development with the help of rich extension libraries. Its highly customizable and flexible integration features enable the server to freely integrate third-party libraries according to actual needs to customize functions and architectures. The lightweight Flask has low resource consumption and high performance, and its error handling and debugging mechanisms ensure stability. The clear code structure, combined with rich documentation and community resources, greatly improves maintainability. Moreover, it supports a distributed architecture, facilitating function expansion according to business development and calmly coping with high concurrency and changing business requirements.

[0044] In one embodiment, according to different work order statuses, corresponding Feishu card templates are designed. The templates need to cover the basic information of the work order and operation buttons.

[0045] The basic information of the work order includes:

[0046] Work order title: Clearly display the brief name of the work order at the title position, such as "JIRA bug daily reminder".

[0047] Work order description: Describe the specific content of the work order in detail to provide users with more in-depth information so that they can understand the details and background of the work order.

[0048] Responsible person: Display the name of the person responsible for handling this work order.

[0049] The operation buttons include:

[0050] View details button: Clicking this button allows users to enter the detailed work order page on the Jira platform. This enables users to view the complete processing record and the latest progress of the work order and obtain more comprehensive information.

[0051] Mark as completed button: When the handler believes that the work order has been processed, they can click this button to submit a completion confirmation. This operation will be monitored by the Jira platform, thereby updating the stage status of the work order and entering a new processing stage, reflecting the dynamics and interactivity of the entire process.

[0052] In one embodiment, the local server 3 processes the parsed work order information based on preset data mapping rules. These preset rules are defined in advance and specify how each part of the work order information corresponds to each field of the Feishu card template. For example, the work order summary may be mapped to the work order title of the Feishu card, and the work order description is also mapped to the work order description of the Feishu card. Through this mapping operation, the local server 3 can fill the work order information into the Feishu card template to generate Feishu card information.

[0053] In one embodiment, the local server 3 is in a listening state, waiting to receive work order status change data sent by the Webhook from the Jira platform 2. After receiving the data, the primary task of the local server 3 is to parse this data. Since the data sent by the Webhook may be encapsulated in a specific format (such as JSON, XML, etc.), the server needs to disassemble the data according to the rules of the corresponding format to identify the key work order information from it. This work order information may include the work order number, title, description, current status, responsible person, etc., which is the basis for subsequent processing. After successfully parsing the work order information, the local server 3 calls the corresponding Feishu card template according to the identified work order status. Once the corresponding Feishu card template is determined, the local server 3 will perform the next step in combination with the preset data mapping rules. These mapping rules detail how each field in the work order information should correspond to each position in the Feishu card template. Through this precise data mapping, the local server 3 accurately fills the parsed work order information into each field of the Feishu card template, thereby generating complete Feishu card information.

[0054] In one embodiment, before starting to interact with the Feishu application 1, the local server 3 needs to first obtain the identity credentials provided by the Feishu application 1. This identity credential is usually generated and assigned to the application by the Feishu Open Platform when creating the Feishu application 1, such as the Client ID and Client Secret, etc. Based on the obtained identity credentials and the selected authentication method, the local server 3 sends an authentication request to the API interface of the Feishu application 1. In this request, relevant identity credential information will be included; after receiving this request, the API interface of the Feishu application 1 will verify the identity credentials in it, checking whether these credentials are correct, valid, and comply with the corresponding security policies. After processing the authentication request, the API interface of the Feishu application 1 will return an authentication result. If the identity credentials are correct and meet all verification conditions, the authentication passes, and the API interface will return corresponding success indicators and possible authorization tokens and other information. After receiving the successful verification result, the local server 3 obtains the permission to legally access the API interface of the Feishu application 1. If the authentication fails, for example, the identity credentials are incorrect or do not meet the security policies, the API interface will return an error message, and the local server 3 needs to perform corresponding processing according to the error prompt, such as checking whether the identity credentials are correct and re-obtaining the identity credentials, etc. When the authentication of the local server 3 passes, it can send the Feishu card information to the API interface of the Feishu application 1.

[0055] Preferably, the local server 3 adopts the OAuth2.0 protocol to ensure the security of API calls. OAuth2.0 is a widely used authorization framework that allows the local server 3 to obtain the permission to access the Feishu application API without directly transmitting sensitive information such as the user's password.

[0056] In one embodiment, after generating the Feishu card information, the local server 3 first needs to determine whether the card information contains sensitive information. Sensitive information may include, but is not limited to, the user's personal identity information (such as name, contact information, etc.), business-critical data (such as financial data, trade secrets, etc.), and privacy-related work order content, etc. Once it is confirmed that the Feishu card information contains sensitive information, the local server 3 will prepare for SSL / TLS encryption. This includes obtaining or configuring a suitable SSL / TLS certificate. The SSL / TLS certificate is issued by a trusted certificate authority (CA) and contains the server's identity information and public key. The local server 3 needs to ensure that the certificate used is valid, not expired, and matches the server's domain name or IP address. The local server 3 uses the obtained SSL / TLS certificate and the corresponding encryption algorithm to encrypt the Feishu card information containing sensitive information. During the SSL / TLS encryption process, the server uses the public key to encrypt the data, converting the original plaintext Feishu card information into ciphertext. Even if this ciphertext is intercepted during network transmission, without the corresponding private key, the interceptor cannot interpret its content, thus ensuring the confidentiality of the data. After the encryption is completed, the local server 3 transmits the encrypted Feishu card information to the API interface of the Feishu application 1 through the network. After receiving the encrypted Feishu card information, the API interface of the Feishu application 1 will use the corresponding private key to decrypt the ciphertext. After successfully decrypting the Feishu card information, the Feishu application 1 will forward the corresponding Feishu card information to the designated user according to the pre-configured permission scope.

[0057] In one embodiment, the system conducts unit tests, integration tests, performance tests, and exception handling tests.

[0058] Unit tests mainly focus on the individual independent modules of the system. For this system, the modules may include Feishu Application 1, the Webhook module configured on the Jira platform 2, and the local server 3. After building Feishu Application 1, verify whether the identity credentials provided by Feishu Application 1 can be used normally, test whether Feishu Application 1 can correctly receive Feishu card information from the local server 3, and whether it can forward the Feishu card information to users, etc. The tests for the Webhook module configured on the Jira platform 2 include: ensuring that the Webhook can be accurately triggered according to the conditions configured on the Jira platform 2. After the Webhook is triggered, check whether it can send the correct work order data to the local server 3. The tests for the local server 3 include: simulating the sending of work order data in different formats and contents from the Webhook of the Jira platform, and checking whether the local server 3 can correctly receive and parse this data. After the local server 3 parses the data, it needs to map the work order information to the corresponding Feishu card template fields according to the preset data mapping rules. For Feishu card information containing sensitive information, test whether the local server 3 can correctly perform SSL / TLS encryption and securely transmit the encrypted data to the API interface of Feishu Application 1.

[0059] Integration tests simulate the real environment and combine various modules for testing, focusing on whether the overall process of the system is smooth. Starting from the Jira platform 2, simulate the triggering of a work order status change event. The Webhook listens for the event trigger and sends data. Then, the local server 3 receives the data and processes it to generate Feishu card information. Next, the local server 3 performs identity verification based on the identity credentials of Feishu Application 1. After passing the verification, it sends the Feishu card information to the API interface of Feishu Application 1. Finally, Feishu Application 1 receives the information and forwards it to the specified users within the configured permission range. During this process, check whether the connection between each link is normal and whether the data can be accurately transmitted between various components, ensuring that there are no problems such as data loss and error handling in the entire message transfer process from Jira to Feishu.

[0060] Performance tests mainly evaluate the performance of the system under high concurrency. In actual applications, a large number of work order status change events may occur simultaneously, causing the Webhook to be triggered frequently and a large amount of data to flood into the local server 3. Through specialized test tools or methods, simulate a large number of events occurring simultaneously, observe the running state of the system under high concurrency, and check whether the local server 3 can process a large amount of data in a timely manner without jamming, crashing, etc.

[0061] Exception handling tests test various possible abnormal situations, such as network interruption, timeout, etc., to verify the robustness and fault tolerance of the system.

[0062] In a specific embodiment, in the usage scenario of the present system, relying on the loop trigger mechanism, a complete work order processing task is realized. For example, Figure 2 , testers discover bugs on the Jira platform 2 and submit tasks. At this time, the Webhook monitors the status changes of the Jira platform 2 in real time. Once it captures the change of task submission, it quickly sends the work order data containing the bug information to the local server 3. After receiving the work order data, the local server 3 generates Feishu card information according to the preset rules and sends it to the Feishu application 1. The Feishu application 1 then pushes messages to relevant groups. Developers obtain the bug situation through the Feishu card information and confirm whether the problem is a real bug on the Jira platform. If it is determined not to be a bug, the bug is directly closed; if it is a bug, the developer enters the Jira platform from the Feishu card information to handle the bug. When the status of the work order changes after the developer completes the bug handling, the Webhook senses the change again and sends the updated work order data to the local server 3. The local server 3 generates Feishu card information again and passes it to the Feishu application 1, and the Feishu application 1 sends a message to the group again to inform the progress of bug handling. The tester learns that the developer has handled the bug through the Feishu card information and enters the Jira platform to verify whether the bug is fixed. If it is confirmed that it has been fixed, the bug is closed and the process ends; if it is found that it has not been fixed, the tester resubmits the task. After the Webhook monitors the change of task resubmission, it sends the work order data to the local server 3 again, starting a new round of loop of "the local server 3 generates Feishu card information - the Feishu application 1 sends a message - the developer processes - the tester verifies" until the bug is successfully fixed and closed. In addition to the message trigger mechanism in the above process, newly created and closed bugs will trigger a scheduled task every day. Under the scheduled task, the Webhook sends the work order data to the local server 3, the local server 3 generates Feishu card information, and the Feishu application 1 sends relevant messages to the group regularly every day to ensure that team members can timely understand the dynamics of new creation and closure of bugs.

[0063] Similar to the principle of the above embodiment, the present invention provides a data interaction method for directly triggering the Jira workflow based on Feishu card messages.

[0064] The following provides specific embodiments in conjunction with the accompanying drawings:

[0065] For example, Figure 3 shows a flowchart of a data interaction method for directly triggering the Jira workflow based on Feishu card messages in an embodiment of the present invention.

[0066] The method includes:

[0067] Step S1: Listen for specific events through the webhook configured on the Jira platform, and send the event data to the local server when a specific event is detected;

[0068] Step S2: Receive the event data from the Jira platform through the local server, convert it into a message format suitable for display on the Feishu card to generate Feishu card information, and send the Feishu card information to the created Feishu application;

[0069] Step S3: The Feishu application forwards the received Feishu card information to the specified users within the configured permission scope, so that the corresponding users can enter the Jira platform through the Feishu card information for corresponding operations.

[0070] Since the implementation principle of the data interaction method for directly triggering the Jira workflow based on the Feishu card message has been described in the foregoing embodiments, it will not be repeated here.

[0071] Compared with the prior art, the advantages of the present invention are as follows:

[0072] 1. Automated process triggering, improving test efficiency

[0073] The Feishu card message of the present invention can directly trigger the Jira workflow, reducing manual operation steps and enabling the test process to run automatically. In the past, a series of operations needed to be manually performed in Jira to start the workflow. Now, it can be triggered with one click through the Feishu card message, saving time and effort and greatly improving the execution speed of test tasks.

[0074] 2. Cross-platform collaboration and real-time information sharing, enhancing communication and collaboration

[0075] Feishu and Jira are different platforms. By directly triggering the Jira workflow through the Feishu card message, seamless docking and collaborative work between the two platforms are achieved. Team members can operate in the familiar Feishu environment while leveraging the powerful project management and workflow functions of Jira, breaking down the barriers between platforms and improving the efficiency and effectiveness of team collaboration. Moreover, the Feishu card message can carry rich information, and key information in the test process, such as problem descriptions, test data, relevant attachments, etc., is timely and accurately transmitted to relevant personnel in the Jira workflow. Developers, testers, and other team members can view and communicate this information in real time in the Feishu message card, avoiding delays and errors in information transmission and promoting collaboration between teams.

[0076] 3. Standardized test process, improving test accuracy

[0077] The Jira workflow triggered by Feishu card messages can define standardized test steps and rules to ensure that each test is carried out according to unified standards. This helps to reduce the interference of human factors and improve the accuracy and reliability of test results.

[0078] 4. Data Traceability and Analysis

[0079] After the combination of Feishu card messages and the Jira workflow, various data during the test process can be easily recorded, including the occurrence of problems, the handling process, results, etc. These data can be used for subsequent traceability and analysis to help the team discover problems and bottlenecks in the test process, optimize the test process, and improve the test quality.

[0080] 6. Cost Reduction

[0081] Feishu is a widely used and relatively easy-to-operate tool, and team members are familiar with its operations. By triggering the Jira workflow through Feishu card messages, team members do not need to spend a lot of time learning the complex operation interface and process of Jira, reducing the training cost. The efficient test process and good communication and collaboration can avoid waste of resources and improve the utilization rate of resources.

[0082] In summary, for the data interaction system and method based on directly triggering the Jira workflow by Feishu card messages of the present invention, a webhook configured on the Jira platform listens for specific events, and when a specific event is detected, the event data is sent to the local server for parsing and conversion to generate Feishu card information. The local server sends the Feishu card information to the created Feishu application, and the Feishu application forwards the received Feishu card information to the specified users within the configured permission range for the corresponding users to enter the Jira platform through the Feishu card information for corresponding operations. The present invention realizes directly triggering the Jira workflow by Feishu card messages, not only solves the information island problem existing in the existing integration solutions, but also improves the automation level and response speed of the entire workflow. Therefore, the present invention effectively overcomes various disadvantages in the prior art and has high industrial utilization value.

[0083] The above embodiments are only used to exemplarily illustrate the principles and effects of the present invention, rather than to limit the present invention. Any person familiar with this technology can modify or change the above embodiments without departing from the spirit and scope of the present invention. Therefore, all equivalent modifications or changes completed by those with ordinary knowledge in the technical field without departing from the spirit and technical ideas disclosed by the present invention should still be covered by the claims of the present invention.

Claims

1. A data interaction system that directly triggers a Jira workflow based on Feishu card messages, characterized in that The system includes: A created Feishu application configured with corresponding permissions; The Jira platform configured with a webhook for listening to specific events; A built local server for receiving event data from the Jira platform, converting it into a message format suitable for Feishu card display, and generating Feishu card information; Among them, a specific event is listened to through the webhook, and when the specific event is listened to, the event data is sent to the local server for parsing and conversion to generate Feishu card information, and the local server sends the Feishu card information to the created Feishu application, and the Feishu application forwards the received Feishu card information to the specified users within the configured permission range for the corresponding users to enter the Jira platform through the Feishu card information for corresponding operations.

2. The data interaction system for directly triggering a Jira workflow based on Feishu card messages according to claim 1, wherein Create a Feishu application on the Feishu Open Platform, configure the user ID acquisition permission and the Feishu card information sending and receiving permission of the Feishu application, and provide an API interface for the local server to call; among them, the user ID acquisition permission includes: single user ID permission and group ID permission.

3. The data interaction system for directly triggering a Jira workflow based on Feishu card messages according to claim 2, wherein Configure a webhook on the Jira platform for a specific event, and set the trigger condition of the specific event and the URL address of the local server; among them, when the webhook monitors that the corresponding specific event is triggered, the event data is sent to the URL address through an HTTP request.

4. The data interaction system for directly triggering a Jira workflow based on Feishu card messages according to claim 3, wherein Configure a webhook on the Jira platform for the specific work order status change event, and use the status switch between different processing stages of the corresponding work order status as the trigger condition, so that when the webhook listens to the status switch of the work order status in the processing stage, the current work order data is sent to the local server.

5. The data interaction system for directly triggering a Jira workflow based on Feishu card messages according to claim 1, wherein Build a local server using Python combined with the Flask framework.

6. The data interaction system for directly triggering a Jira workflow based on Feishu card messages according to claim 5, wherein The local server parses the work order information from the work order data received from the webhook, and maps the parsed work order information to each field in the corresponding Feishu card template based on the preset data mapping rules to generate Feishu card information.

7. The data interaction system for directly triggering the Jira workflow based on the Feishu card message according to claim 6, wherein Construct corresponding Feishu card templates according to different work order statuses; among them, the Feishu card template includes the basic information of the work order and an operation button for the user to click to enter the Jira platform.

8. The data interaction system for directly triggering a Jira workflow based on Feishu card messages according to claim 2, characterized in that The local server sends an authentication request to the API interface of the Feishu application based on the identity credential provided by the Feishu application, and sends the Feishu card information to the API interface after the authentication is passed.

9. The data interaction system for directly triggering a Jira workflow based on Feishu card messages according to claim 2, wherein The local server encrypts the Feishu card information containing sensitive information with SSL / TLS and then transmits it to the API interface of the Feishu application for the Feishu application to forward the corresponding Feishu card information to the specified users within the configured permission range after decryption.

10. A data interaction method for directly triggering a Jira workflow based on Feishu card messages, characterized in that, The method includes: Listening to specific events through the webhook configured on the Jira platform, and sending the event data to the local server when the specific events are listened to; Receiving event data from the Jira platform through the local server, converting it into a message format suitable for Feishu card display to generate Feishu card information, and sending the Feishu card information to the created Feishu application; The Feishu application forwards the received Feishu card information to the specified users within the configured permission scope, so that the corresponding users can enter the Jira platform through the Feishu card information for corresponding operations.

Images