Asynchronous Distributed Modular Function Calls

Abstract

A computer-readable medium, method, and system for invoking a function in a group-based communication system. The function may be initiated according to a trigger condition and is associated with arguments and a return value. To execute the function, an HTTP request is generated and sent to an HTTP server, which sends an HTTP callback to the group-based communication system server. The HTTP callback may include a return value indicating either successful completion of the function or an error.

Description

[Technical Field]

[0001] FIELD OF THE INVENTION Embodiments of the present invention relate to invoking functions, and more particularly, to invoking functions within a group-based communication system.

[0002] Typically, group-based communication systems do not provide a way for end users to store custom functions that can later be shared or invoked by others. Thus, function invocation and composition actions may be limited to advanced developer users. Furthermore, some group-based communication systems do not provide custom functions that are easily reusable or accessible by others to perform communications and actions within external applications. As a result, modularity within such group-based communication systems may be reduced.

[0003] What is needed is a function calling convention within a group-based communication system that allows both standard end users and advanced developer users to call and compose functions, allowing them to be shared and reused within the group-based communication system. Summary of the Invention

[0004] SUMMARY OF THE INVENTION Embodiments of the present invention solve the above problems by providing a function invocation convention within a group-based communication system. Specifically, embodiments of the present invention provide a computer-readable medium, method, and system for invoking a function within a group-based communication system.

[0005] A first embodiment of the present invention is directed to one or more non-transitory computer-readable media storing computer-executable instructions that, when executed by a processor, perform a method for invoking a function in a group-based communication system, the method including: receiving an instruction over an event channel in the group-based communication system in response to triggering the function; receiving one or more arguments of the function; generating an asynchronous request including an identifier of the function and one or more arguments of the function; receiving a callback including one or more return values ​​of the function; and generating a success event on the event channel in the group-based communication system in response to determining that the one or more return values ​​of the function indicate successful completion of the function.

[0006] A second embodiment of the present invention is directed to a method for invoking a function within a group-based communication system, the method including: receiving an instruction via an event channel within the group-based communication system in response to triggering the function; receiving one or more arguments of the function; generating an asynchronous request including an identifier of the function and one or more arguments of the function; receiving a callback including one or more return values ​​of the function; and generating a success event on the event channel within the group-based communication system in response to determining that the one or more return values ​​of the function indicate successful completion of the function.

[0007] A third embodiment of the present invention is directed to a function call system for a group-based communication system, comprising: a data store; and a processor programmed to execute a method for invoking a function within the group-based communication system, the method including: receiving an instruction via an event channel within the group-based communication system in response to triggering the function; receiving one or more arguments of the function; generating an asynchronous request including an identifier of the function and one or more arguments of the function; receiving a callback including one or more return values ​​of the function; and generating a success event on the event channel within the group-based communication system in response to determining that the one or more return values ​​of the function indicate successful completion of the function.

[0008] Additional embodiments of the present invention are directed to providing an end user interface that allows end users to create user-defined functions and a developer interface that allows advanced users to create user-defined functions.

[0009] Additionally, embodiments are directed to communication between a group-based communication system server, an HTTP server, and an external application.

[0010] This Summary is provided to introduce a selection of concepts in a simplified form that are further described below in the Detailed Description. This Summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used to limit the scope of the claimed subject matter. Other aspects and advantages of the present invention will become apparent from the following Detailed Description of the Embodiments and the accompanying drawings. [Brief explanation of the drawings]

[0011] Embodiments of the present invention will be described in detail below with reference to the accompanying drawings.

[0012] [Figure 1A]1 depicts an exemplary hardware platform for certain embodiments of the present invention. [Figure 1B] 1 depicts an exemplary diagram illustrating components of a system for implementing embodiments of the present invention; [Figure 2] 1 depicts a function call system according to some embodiments of the present invention. [Figure 3A] 1 depicts exemplary functions for some embodiments of the present invention. [Figure 3B] 1 depicts an exemplary function object for some embodiments of the present invention. [Figure 4] 1 depicts a series of functions for some embodiments of the present invention. [Figure 5A] 1 depicts a user interface for initiating functions according to some embodiments of the present invention. [Figure 5B] 1 depicts a user interface for initiating functions according to some embodiments of the present invention. [Figure 5C] 1 depicts triggering of functions according to some embodiments of the present invention. [Figure 6] 1 depicts a swimlane diagram illustrating component responsibility flow for invoking functions within a group-based communication system according to some embodiments of the present invention; [Figure 7A] 1 depicts exemplary screenshots illustrating end-user interfaces for some embodiments of the present invention. [Figure 7B] 1 depicts exemplary screenshots illustrating a developer interface for some embodiments of the present invention. [Figure 8] 1 depicts a method for defining a function according to some embodiments of the present invention. [Figure 9A] 10 depicts a function permission configuration user interface for some embodiments of the present invention. [Figure 9B] 10 depicts a function permission configuration user interface for some embodiments of the present invention.

[0013] The drawings do not limit the invention to the particular embodiments shown and described herein. The drawings are not necessarily to scale, emphasis instead being placed upon clearly illustrating the principles of the invention. DETAILED DESCRIPTION OF THE INVENTION

[0014] The following detailed description refers to the accompanying drawings that illustrate specific embodiments in which the invention may be practiced. These embodiments are intended to describe aspects of the invention in sufficient detail to enable those skilled in the art to practice the invention. Other embodiments may be utilized, and changes may be made, without departing from the scope of the invention. Therefore, the following detailed description is not to be taken in a limiting sense. The scope of the present invention is defined only by the appended claims, along with the full scope of equivalents to which such claims are entitled.

[0015] In this description, a reference to "one embodiment," "one embodiment," or "embodiments" means that the referenced feature or features are included in at least one embodiment of the technology. Separate references to "one embodiment," "one embodiment," or "embodiments" in this description do not necessarily refer to the same embodiment, nor are they mutually exclusive, unless so stated and / or readily apparent to one of ordinary skill in the art from the description. For example, a feature, structure, operation, etc. described in one embodiment may, but is not necessarily, included in other embodiments. Thus, the technology may include various combinations and / or integrations of the embodiments described herein.

[0016] Referring initially to FIG. 1A , an exemplary hardware platform for certain embodiments of the present invention is depicted. Computer 102 can be a desktop computer, a laptop computer, a server computer, a mobile device such as a smartphone or tablet, or any other form factor of a general-purpose or special-purpose computing device. Computer 102 shows several components for illustrative purposes. In some embodiments, certain components may be located differently or not present. Additional components may be present. Computer 102 includes a system bus 104, which allows other components of computer 102 to communicate with each other. In certain embodiments, multiple buses or components may communicate directly with each other. Connected to system bus 104 is a central processing unit (CPU) 106. Also connected to system bus 104 are one or more random access memory (RAM) modules 108. Also connected to system bus 104 is a graphics card 110. In some embodiments, graphics card 110 may not be a physically separate card, but rather may be integrated into the motherboard or CPU 106. In some embodiments, graphics card 110 has a separate graphics processing unit (GPU) 112, which can be used for graphics processing or general-purpose computing (GPGPU). Also present on graphics card 110 is GPU memory 114. A display 116 is connected (directly or indirectly) to graphics card 110 for user interaction. In some embodiments, no display is present, while in other embodiments, a display is integrated within computer 102. Similarly, peripherals such as keyboard 118 and mouse 120 are connected to system bus 104. Like display 116, these peripherals may or may not be integrated into computer 102.Also connected to the system bus 104 is local storage 122, which may be any form of computer-readable media and may be internally installed in the computer 102 or externally attached in a removable form.

[0017] Computer-readable media includes both volatile and nonvolatile media, removable and non-removable media, and contemplates media readable by a database. For example, computer-readable media includes, but is not limited to, RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, digital versatile disks (DVDs), holographic media or other optical disk storage, magnetic cassettes, magnetic tape, magnetic disk storage, and other magnetic storage devices. These technologies can store data either temporarily or permanently. However, unless otherwise specified, the term "computer-readable media" should not be interpreted to include forms of physical but transitory signal transmission, such as radio broadcasts, electrical signals over wires, or light pulses over fiber optic cables. Examples of stored information include computer-usable instructions, data structures, program modules, and other data representations.

[0018] Finally, a network interface card (NIC) 124 is also connected to the system bus 104 and enables the computer 102 to communicate over a network, such as network 126. The NIC 124 can be any form of network interface known in the art, such as Ethernet, ATM, fiber, Bluetooth, or Wi-Fi (i.e., the IEEE 802.11 family of standards). The NIC 124 connects the computer 102 to the local network 126, which may also include one or more other computers, such as computer 128, and network storage, such as data store 130. In general, a data store, such as data store 130, may be any repository that can store information and retrieve it as needed. Examples of data stores include relational or object-oriented databases, spreadsheets, file systems, flat files, directory services such as LDAP and Active Directory, email storage systems, and the like. A data store may be accessible through a complex API (e.g., a structured query language), a simple API that provides only read, write, and search operations, or any level of complexity in between. Some data stores may also provide management functions for the data sets stored therein, such as backup or versioning. A data store may be local to a single computer, such as computer 128, accessible over a local network, such as local network 126, or remotely accessible over the Internet 132. Local network 126, in turn, is connected to the Internet 132, which connects many networks, such as local network 126, remote network 134, or directly connected computers, such as computer 136. In some embodiments, computer 102 itself may be directly connected to the Internet 132.

[0019] Turning now to FIG. 1B , a system diagram illustrating elements of system 150 for implementing an embodiment of the present invention is depicted. System 150 includes any number of client devices, such as client device 152, client device 154, and client device 156. As depicted in FIG. 1B , client devices 152, 154, and 156 can be any of desktop computers, laptop computers, mobile phones, tablets, or any other device suitable for allowing users to access a group-based communication system. Users may also switch from one client device to another or may access the group-based communication system via multiple devices simultaneously. The group-based communication system may be accessible via dedicated software on the client device or via a web browser on the client device. In some embodiments, a channel administrator can access administrative functions via any client device. In other embodiments, administrative functions are accessible only from a limited subset of client devices (e.g., only via client device 152). In some examples, the group-based communication system is a channel-based messaging platform with multiple messaging channels available to select users.

[0020] System 150 further includes a group-based communication system server 158 that functions as a host for the group-based communication system. Group-based communication system server 158 may be a dedicated server, a shared server, or any other form of computing device as described above with respect to FIG. 1A . While a single group-based communication system server 158 is illustrated, embodiments having multiple such group-based communication system servers are also contemplated to provide scale, redundancy, and / or isolation between different instances of the group-based communication system. For example, a particular organization using a group-based communication system may not want its group-based communication system hosted on the same server as a competitor's group-based communication system for security reasons. Group-based communication system server 158 is communicatively coupled to client devices 152, 154, and 156 via network 160. Network 160 may be a local area network (LAN), a wide area network (WAN), a virtual private network (VPN), or the Internet. Broadly speaking, any type of network is contemplated for providing communication between the various components of system 150. The group-based communication system server 158 may provide web server functionality to facilitate web-based clients and non-web server functionality to facilitate clients using dedicated apps. Alternatively, both web-based clients and dedicated application clients may use a single web server, or the web server may be a gateway that provides web-based access to the dedicated application server. Other techniques for enabling communication between various types of client applications are also contemplated.

[0021] It should be understood that the group-based communication system referred to herein may provide a communication platform for multiple users. In some embodiments, each user of the multiple users may be associated with a particular organization. The particular organization may be a small or medium-sized business, a corporation, or the like, as well as any other user group. The group-based communication system is operable to provide communication services to any combination of users. For example, in some embodiments, communication services may be provided to multiple users from a single organization as well as multiple users from multiple organizations. In some embodiments, multiple channels exist within the group-based communication system. Users may be added to each channel, thereby allowing users in one of the channels to access messages and files posted in that channel. Furthermore, users in a channel have the ability to post messages and upload files within the channel. In some embodiments, users may be added to a particular channel by an administrator, such as an administrator within a particular organization. Alternatively, in some embodiments, users may be added by any user in the channel. Furthermore, in some embodiments, channel parameters, such as who can add users, may be set by the channel creator. For example, channels created by a particular organization may be subject to that organization's security policy, where only administrators can add users to a particular channel.

[0022] Group-based communication system data store 162 is communicatively connected to group-based communication system server 158. As shown, group-based communication system data store 162 is directly connected to group-based communication system server 158, although any form of communication connection (e.g., network-attached storage (NAS), network file system (NFS), or cloud-based storage) may be used. Generally speaking, group-based communication system data store 162 stores all of the information used by group-based communication system server 158. For example, group-based communication system data store 162 may store all messages along with their associated channels, documents and images uploaded to particular channels, channel membership information, and / or user information. As previously mentioned, multiple group-based communication system servers may be present in system 150. In such an embodiment, each group-based communication system server may have its own copy of group-based communication system data store 162. Alternatively, multiple group-based communication system servers may share a single network-connected group-based communication system data store. Alternatively or additionally, in any of these embodiments, data may be sharded across multiple group-based communication system data stores.

[0023] It should be understood that any of the client devices 152, 154, and 156, as well as the group-based communication system server 158, may comprise a processor, such as the CPU 106 described with respect to FIG. 1A. Any of the operations described herein with respect to a processor may be performed by a processor within any of the devices described herein. For example, in some embodiments, a processor within the group-based communication system server 158 may perform a first operation, and a processor within the client device performs a second operation.

[0024] Turning now to FIG. 2 , a function call system 200 according to some embodiments is depicted. The function call system 200 includes a processor 202, which may be a processor of the group-based communication system server 158 of FIG. 1B or a processor on one of the client devices 152, 154, and 156. The processor 202 communicates an HTTP request 204 to an HTTP server 206, as shown. In some embodiments, the HTTP request 204 includes an identifier for the function and one or more arguments for the function. The HTTP server 206 communicates an HTTP callback 208 to the processor 202. In some embodiments, communication between the processor 202 and the HTTP server 206 is established via an API endpoint. In some embodiments, the HTTP server 206 is a web server communicating over a network, such as the network 160.

[0025] In some embodiments, the HTTP request is an asynchronous HTTP request in which execution continues after the processor issues the request, as opposed to waiting for a response from the HTTP server 206. The terms "HTTP request," "HTTP server," and "HTTP callback" are used for specificity, but it should be understood that embodiments of the present invention contemplate any type of network protocol for communication between the group-based communication system and an external server for implementing functional logic.

[0026] In some embodiments, HTTP server 206 may communicate with external application 210. External application 210 may be a developer application or other application associated with the group-based communication system. For example, in some embodiments, external application 210 is a third-party application referenced in a function. In some embodiments, processor 202 may communicate with HTTP server 206 to execute a function solely within the third-party application. Alternatively, in some embodiments, at least a portion of a function may be executed within the group-based communication system. In some embodiments, external application 210 is implemented on an external server associated with external application 210. Thus, at least a portion of a function may be executed on external application 210. For example, information may be written to or retrieved from external application 210 through communication with HTTP server 206, and in the case of information retrieval, the retrieved information may be returned to processor 202 via HTTP callback 208.

[0027] 3A , an exemplary function 300 according to some embodiments is depicted. The function 300 receives inputs 302 and generates either an error 304 or an output 306 in response to these inputs 302. The inputs 302 may include one or more arguments of the function, the name of the function, and any other suitable information used to execute the function 300. The error 304 may be generated in response to failure of the function 300. For example, if a required argument is not provided in the input 302, the function 300 may fail and generate the error 304. The error 304 may be returned to the group-based communication system server 158 and displayed as an error message on one of the client devices 152, 154, and 156. Alternatively, the output 306 may be generated by the function 300 in response to the success of the function 300. In some embodiments, the output 306 (and / or the error 304) may generate a success event (or, in the case of an error, a failure event) on an event channel of the group-based communication system, allowing a user or automated process to obtain the result. As described below, this also allows a function to be configured by having an event on the event channel serve as a trigger condition for another function. Alternatively or additionally, in some instances, either the output 306 or the error 304 may be sent directly to a subsequent function as an input argument for the subsequent function, as described in additional detail below with reference to FIG. 4.

[0028] In some embodiments, input 302 may be received as an argument of function 300. Additionally, input 302 may be received as message information from a group-based communication system. In some embodiments, an undercurrent of data may be associated with a particular channel of the group-based communication system. The undercurrent of data may include various information associated with a group-based communication channel, such as metadata for messages posted within the channel, user information associated with users added to the channel, and channel information such as the channel name and channel parameters. Thus, any of the information from the undercurrent of data may be sent as an argument of the function. For example, the username and the time of the message may be used as arguments of a function indicating which user sent the message and the time the message was sent. Thus, a function is contemplated that identifies the last user to post a message within a channel.

[0029] In some embodiments, it may be preferable to utilize existing resources associated with a group-based communication channel for function 300. For example, channel-related information and features such as access control, data scoping, subscriptions, APIs, data loss prevention integrations, encryption key management, and international data residency integrations may be invoked by the function to provide arguments or trigger events for initiating the function. Thus, an existing group-based communication channel may be used as an event channel for the function, and an event in the channel may trigger the function, such as sending a message, adding a user, or reacting to a message. In some embodiments, any content published to the group-based communication channel may be used to trigger and provide arguments to the function.

[0030] In some embodiments, events are published as event messages within channels of a group-based communication system, with each event message including metadata describing the event. Thus, functions can be triggered based on events within a channel and when an event message is reacted to or commented upon. In some such embodiments, it may be desirable to publish event messages so that metadata associated with the event message can be used to initiate and provide information to functions. Alternatively, in some embodiments, it may not be desirable to publish all events as event messages within a channel, as this would result in users receiving too much unnecessary information. Thus, event messages may be filtered so that only certain types of events are published as event messages. Alternatively, event messages may be published to the data underlying the channel without being visible to users within the channel.

[0031] In some embodiments, function 300 is an object in the context of the group-based communication system, such as an object in an object-oriented programming environment. Accordingly, function 300 may be stored in a memory, such as group-based communication system data store 162, and associated with an identifier used to identify function 300. Furthermore, in some embodiments, function 300 may be authenticated by either processor 202, HTTP server 206, or external application 210. In some embodiments, function 300 may be authenticated in a single authentication step that satisfies the authentication requirements of each of processor 202, HTTP server 206, and external application 210. Additionally, function 300 may be authenticated along with the user who initiated the function. Accordingly, embodiments are contemplated where a user is authenticated by the group-based communication system and does not need to perform further actions to be authenticated by HTTP server 206 and external application 210. Here, information regarding user authentication may be sent as an argument to the function. Accordingly, if a user is authenticated within the group-based communication system, the user may execute a function within HTTP server 206 or external application 210.

[0032] In some embodiments, the output 306 may include defining or updating at least one variable within the group-based communication system. For example, a successful function may update a variable stored in the group-based communication system data store 162. Thus, a function is contemplated that records the number of messages sent within a particular channel by updating a counter for each user each time that user sends a message within that channel.

[0033] An advantage of embodiments of the present invention is that functions may be implemented independently of how they were originally created and may be reused and modified to suit a variety of different contexts. Therefore, the interface for defining functions is preferably relatively stable so that functions can be reused in a variety of contexts without returning errors. Furthermore, flexibility should be maintained as to how functions are implemented. For example, a function may be declared that accepts a unique user identifier as an argument and returns the display name of that user. An initial implementation of this function may accept a username for a group-based communication system and look up the display name in a user database. The function interface may be reused to accept an email address and look up the display name in an LDAP directory. At a future point in time, the function may be reimplemented to take a variety of different types of unique identifiers, automatically determine the user identifier type and corresponding directory, and return the display name for any type of user identifier. This allows existing functions to continue to be used and function without modification, regardless of the back-end implementation.

[0034] In one embodiment, function 300 may be a table-creation function used to fill values ​​in a table or spreadsheet, where input 302 may be variables or other parameters from either the group-based communication system or external application 210. Thus, output 306 of function 300 may include a table of information with variables filled in specific locations within the table. For example, a function may be contemplated that returns email addresses of users added to a particular channel in a group-based communication system over a period of time, e.g., the past month. Here, variables indicating users added over the past month are obtained from the group-based communication system, and these variables are used as input 302 for the function to fill the table.

[0035] It should be understood that various functions are contemplated for performing operations on tables, lists, spreadsheets, or other data structures, such as writing data, reading data, inserting data, updating data, and deleting data. Accordingly, embodiments are contemplated for data-driven applications in which functions are used to interact with stored data structures, such as tables, lists, or spreadsheets. Furthermore, in some embodiments, changes to such data structures may be associated with a trigger event for initiating a function. Accordingly, embodiments are contemplated in which a function is triggered when a user updates a form, table, or list or makes a change to text in a document. It should be understood that the foregoing data structures may be stored in the group-based communication system data store 162 or may otherwise be stored in an external application.

[0036] In some embodiments, a table may be created to provide persistence capabilities to a function. Thus, a persistence table may be created when a given function is initialized to store argument and event data. The event data may be stored so that it is retrievable by subsequent functions. Thus, embodiments are contemplated in which multiple functions retrieve and update information stored in the persistence table. Furthermore, in some embodiments, the event data may be retrievable by a user to aid in error tracking of the function.

[0037] 3B , function 300 is depicted as a function object associated with some embodiments of the present invention. In some such embodiments, an instance of function 300 may be stored as an instance of a function object in group-based communication system data store 162, as described above. Function 300 includes a function ID 308 and a function name 310, where the function ID 308 and function name 310 may be used to identify the function. For example, in some embodiments, function ID 308 and function name 310 are used to invoke function 300. Accordingly, as discussed below, embodiments are contemplated in which additional functions are invoked from within the output 306 of another function. For example, a first function may include as an output the function ID or function name of a second function such that the second function is invoked by the first function. In some embodiments, function 300 further includes a session request identifier 312 that indicates whether function 300 requires a user session. The session request identifier 312 may include a Boolean variable such as true or false, where true indicates that a user session is required and false indicates that a user session is not required.

[0038] A user session, as described herein, may include an interactive session with a user (e.g., a currently active in-focus user session) to obtain user input that may be used as arguments or input 302 for a function. For example, a modal dialog may be presented to the user allowing the user to supply one or more required parameters (directly or indirectly) for the function. In some embodiments, if the session request identifier 312 is true, a user session may be initiated upon triggering of the function 300. In other embodiments, if a function requiring a user session is called in a non-interactive session, the function may fail. Alternatively, in some embodiments, if the session request identifier 312 is set to false, a user session is not initiated or the user session may be optional. If the user session is optional, at least a portion of the arguments may be filled with default values ​​if the function is called in a non-interactive context, which may be predefined default values ​​stored in the group-based communication system data store 162 along with the function object.

[0039] Turning now to FIG. 4 , a series of functions 400 is depicted in a workflow for some embodiments. Here, the series of functions 400 includes a plurality of n functions, such as a first function 402 (function_a()), a second function 404 (function_b()), and an nth function 406 (function_c()). In some such embodiments, each function of the plurality of functions may generate either an error 304 or an output 306 based on the respective failure or success of the function. In some embodiments, the output 306 may be passed to a subsequent function, as shown. In some embodiments, the series of functions 400 is executed as a workflow within the group-based communication system. In some embodiments, each function in the series of functions 400 performs a different action and generates a different output 306. In some embodiments, the nth function 406 may be the last function, where the output 306 of the nth function 406 is sent back to the group-based communication system server 158 as a set of return values. In some embodiments, functions may be configured when they are created, as described below with respect to FIGS. 7A and 7B .

[0040] Values ​​may be passed between functions directly or via success and / or error messages posted to an event channel of the group-based communication system. In some embodiments, the success message of a configured function may include additional information indicating the subsequent function to be called, eliminating the need to maintain state outside of the function call itself. In some embodiments, the event channel behaves like a traditional channel in the group-based communication system, allowing users to debug functions by joining the event channel like any other channel and monitoring success and error messages. In other embodiments, the event channel may be a hidden data layer on the regular group-based communication channel through which functions are called.

[0041] In some embodiments, each of functions 402, 404, and 406 may be either a predefined function built into the group-based communication system or a custom, user-defined function created by an end user. Thus, embodiments are contemplated in which a user creates the set of functions 400 by selecting from a set of existing functions. Furthermore, in some embodiments, functions 402, 404, and 406 may be invoked from an automated workflow executed by a workflow application of the group-based communication system. Thus, automated workflows that invoke multiple functions to perform a complex set of tasks within the group-based communication system are contemplated.

[0042] In some embodiments, an exemplary automated workflow is contemplated that provides a table for storing information related to users who have signed up for a service in a third-party application. Here, the automated workflow may invoke a first function to create the table, a second function to prompt users to sign up for the service each time a new user is added, and a third function to update the information on the table each time a user signs up for the service. In addition, a function may be provided that returns a particular value stored in the table so that a user can see who has signed up for the third-party service.

[0043] In some embodiments, the arguments are collected from the group-based communication system data store 162. For example, the arguments may include user information, status information for a group-based communication channel, external information from an external resource, or any combination thereof. It should be understood that other sources and types of arguments are also contemplated.

[0044] An exemplary scenario illustrating the operation of the present invention for some embodiments is described below. For the purposes of the example, a function is defined for automatically filling in a form with user information. The function is triggered each time a form is shared within a group-based communication system. Thus, a first user shares a form on a group-based communication channel for a second user to fill out, and a trigger instruction is received in response to the file being shared. After receiving the trigger instruction, arguments are collected. For the purposes of the example, the collected arguments include a set of user information retrieved from a group-based communication data store, such as, for example, user name, user job title, and other user information.

[0045] An HTTP request is generated and sent to the HTTP server 206. The HTTP request includes the obtained user information, information related to the form to be filled out, and additional function-related information that is sent to the HTTP server 206. The HTTP server 206 executes the function, which in this example includes automatically filling at least one input field of the form with the user information. Accordingly, an HTTP callback is received that includes the automatically filled form and an indication of successful completion of the function. The function is then determined to be successful based on the received indication, and a success event is generated. Alternatively, if the function is not completed successfully (e.g., if information to be automatically filled in the form could not be accessed), an error message may be returned, or a message may be returned informing the user that information must be provided manually. As described above, the success or failure of the function may result in a success or failure event message being posted to the event channel (or an appropriate dedicated success or failure channel).

[0046] 5A , an exemplary user interface 500 of a group-based communication system for initiating a function is depicted, according to some embodiments. The user interface 500 includes a function shortcut 502. In some embodiments, the function shortcut 502 is associated with a trigger instruction that initiates the function. In some embodiments, the function shortcut 502 may be accessed from a set of suggested shortcuts 504 presented to a user on the group-based communication system, as shown. Additionally, shortcuts may be searched for using a shortcut search bar 506. Accordingly, embodiments are contemplated in which a user may search for a particular function using the search bar 506. In some embodiments, the function name 310 is displayed within the user interface 500 to indicate which function corresponds to the function shortcut 502. In some embodiments, multiple functions may be presented to a user in the set of suggested shortcuts, along with additional shortcuts that may not be related to the function.

[0047] In some embodiments, the function shortcut 502 may be included as part of a pop-up window within the user interface 500, as shown. Alternatively, in some embodiments, the function shortcut 502 may be accessed by entering a slash command within a text entry box of a group-based communication system. For example, a developer-user may invoke a function by entering a slash followed by the name or other identifier for the function within a text entry field of a group-based communication system typically used to compose a message.

[0048] 5B, an exemplary user interface 500 of a group-based communication system for initiating a function is depicted, according to some embodiments. In some embodiments, the user interface 500 includes a function button 510 for initiating a function, where the function button 510 may be a trigger indication for a given function. In such embodiments, the function button 510 may be selected by a user clicking or tapping the function button 510 within the group-based communication system to initiate the function.

[0049] In some such embodiments, the function button 510 may be included within a message 512 within the group-based communication system, as shown. Accordingly, embodiments are contemplated in which a user may share a function with other users by attaching the function button 510 to a message 512 within a channel of the group-based communication system. Alternatively, the function button 510 may be presented elsewhere within the group-based communication system. It should be appreciated that in some embodiments, the function may be initiated automatically without the user having to manually click a button or select a function shortcut, as described in more detail below with reference to FIG. 5C .

[0050] Turning now to FIG. 5C , an exemplary automatic trigger 520 for some embodiments of the present invention is depicted. In some embodiments, the trigger 520 includes a trigger event 522 and at least one trigger condition 524. Thus, when the trigger event 522 occurs, the trigger condition 524 is checked, and if the trigger condition 524 is satisfied, a function is initiated. It should be appreciated that in some embodiments, a function may be associated with multiple trigger events 522 such that different trigger events may initiate the function. Further, in some embodiments, the trigger event 522 may be an event within the group-based communication system or within an external application. Similarly, information related to the trigger condition 524 may be obtained from the group-based communication system or from an external application. For example, in some embodiments, the trigger condition 524 is associated with a variable stored in the group-based communication system data store 162. In some embodiments, a function may be included to present a form to a new user when the new user joins a particular channel of the group-based communication system. Such functions are described in more detail below.

[0051] In one example, an organization's administrator user defines a function that automatically prompts new users to complete forms related to initial employment paperwork, such as a W4 form. In such an example, the administrator user configures the function to be active for the HR channel, to which all members of the organization are added upon hire. Thus, the administrator user may define a trigger event for the function that is activated each time a new user is added to the HR channel. The administrator user may want the function to run only during regular business hours to ensure that the new user is active when the form prompt is sent. Thus, the administrator user may define a trigger condition for the function that is met when the trigger event time is between 7:00 AM and 7:00 PM, Monday through Friday. In such an embodiment, if the initial trigger event is activated outside of these hours, it may be preferable to schedule subsequent trigger events to occur during these hours to ensure that the new user still receives the form prompt.

[0052] In addition to the manual and automatic triggers described above, a function may also be triggered by a call from another function, as described with reference to FIG. 4 . Additionally, in some embodiments, a single function may be initiated by a variety of different types of triggers. For example, a function for storing email addresses in a spreadsheet may be automatically triggered by receiving an email from a new contact, or may be manually triggered by a user searching for and selecting the function. Furthermore, a function may be invoked by a workflow application of the group-based communication system that executes an automated workflow. Here, the name or ID of the function may be stored in a set of instructions for the automated workflow, e.g., in the group-based communication system data store 162, so that the automated workflow invokes and triggers the function at runtime.

[0053] Turning now to FIG. 6 , a swim lane diagram illustrating component responsibility flow for invoking a function within a group-based communication system, in accordance with some embodiments, is depicted and generally referenced by reference numeral 600. In step 602, a trigger indication is received by the group-based communication system server 158. Such a trigger indication may be associated with any one of the manual or automatic function initiation scenarios described above. For example, the trigger indication may be received in response to a user selecting a function shortcut 502, in response to a user selecting a function button 510, or automatically in response to a trigger event in which a trigger condition is met. Additionally, in some embodiments, as described above, a function may be triggered by an automated workflow or by a previously executed function. In some embodiments, the trigger indication may be an indication that one or more trigger conditions have been met. In some embodiments, the indication is received via an event channel of the group-based communication system. The trigger condition indication may be associated with the trigger condition being met. For example, if the trigger condition is associated with a new member being added to a particular channel within the group-based communication system, the trigger condition may be met when the new member joins the channel. In such a case, the indication may be sent on the event channel in response to the trigger condition being satisfied. Alternatively, if the trigger condition is the successful completion of another function, the trigger condition may be satisfied when an appropriate success event is posted to the event channel.

[0054] In some embodiments, the trigger condition may be selected from user-defined or predefined triggers. For example, the trigger condition may be associated with a user sending a message within a particular channel of a group-based communication system. Thus, the sending of a message within that channel satisfies the trigger condition. It should be understood that various types of trigger conditions are contemplated. For example, the trigger condition may be associated with additional users joining a channel, a new channel being created, additional organizations joining a channel, a reaction to a message, or another event within the group-based communication system. Broadly speaking, a trigger may be any event that matches a predefined condition. These events may be caused by a user action (e.g., a user clicking a button in a user interface or invoking a slash command in a message), an automated system action (e.g., a regularly scheduled recurring event), or a custom action (e.g., a webhook invoked by a third-party integration). The trigger's event may be included as an argument to the triggered function. For example, if the trigger condition is a user joining a particular channel, a user identifier and a channel identifier may be passed as arguments to the function.

[0055] In response to receiving the trigger instruction, the group-based communication system server 158 generates an HTTP request in step 604 and sends the HTTP request to the HTTP server 206 in step 606. The HTTP request may include a variety of information, such as information identifying the function, information identifying the arguments of the function, information identifying the action of the function, authentication information, and other function-related information.

[0056] The HTTP server 206 receives the HTTP request in step 608. In some embodiments, the HTTP server 206 sends a message to the external application 210 in step 610 based on the HTTP request received in step 608. In some embodiments, the message includes various information, such as information related to an action to be performed within the external application 210, authentication information for authenticating a function within the external application, or other function-related information. The external application 210 receives the message in step 612 and performs an operation or set of actions in step 614. In some embodiments, the message may include instructions to perform an operation within the external application 210. For example, in one embodiment, the external application 210 is spreadsheet software, and the message from the HTTP server 206 includes instructions to write a value to a specific cell in the spreadsheet and / or read a value from another cell. In step 616, the external application 210 sends a response back to the HTTP server 206. In some embodiments, the response includes information such as a return value or confirmation that the operation was performed in step 614. For example, values ​​read from a spreadsheet may be returned to the HTTP server 206 in the response.

[0057] In step 620, the HTTP server 206 sends a callback to the group-based communication system server 158. It should be understood that in some embodiments, the HTTP server 206 may not communicate with the external application 210. Thus, steps 610-618 may be skipped in such embodiments and replaced with steps of processing by the HTTP server 206, where the HTTP server 206 may perform the operation associated with the function.

[0058] In step 622, the callback is received by the group-based communication system server 158. In some embodiments, the callback includes one or more return values ​​associated with the function. In response to receiving a success indication in the callback, a success event is generated by the group-based communication system server 158 in step 624. In some embodiments, the one or more return values ​​indicate successful completion of the function. Alternatively, if the callback returns an error, an error event may be generated in step 624 instead of a success event. Such an error event may include displaying an error message within the group-based communication system, as discussed above.

[0059] 7A , an exemplary screenshot of an end-user interface 702 of a group-based communication system is depicted, in accordance with some embodiments. The end-user interface 702 may be displayed to a user on one of the client devices 152, 154, or 156. The end-user interface 702 may be particularly appealing to new users and end-users who are not experienced developers. Thus, the end-user interface 702 may allow a user to define or edit functions within the group-based communication system without requiring the user to write code or use advanced software techniques.

[0060] In some embodiments, end user interface 702 includes a plurality of clickable buttons 704 that provide a simple interface for a user to select parameters of a function. In some embodiments, a drop-down menu 706 may be selectively displayed in response to a user clicking one of the plurality of buttons 704. Drop-down menu 706 may display a plurality of options for a user to select. It should be appreciated that the group-based communication system may be displayed, for example, on a touchscreen of a mobile device, where a user's touching the screen is equivalent to the user clicking an item. Thus, in some embodiments, drop-down menu 706 may be displayed in response to a user either clicking button 704 using a mouse or tapping button 704 on a touchscreen display of one of client devices 152, 154, or 156.

[0061] In some embodiments, the end user interface 702 may include a prompt for the user to select a variable, where the variable may be a parameter accessible within the group-based communication system that can be used as an input for a function. For example, a user may select an email address as the variable to be used as an input for a function. Thus, a situation is contemplated in which a user selects the email address used to invoke the function as the variable to be used as an input for the function. Here, a function may be created that returns the email address of the user who invoked the function. For example, the function may be triggered by a user responding to a message within the group-based communication system. Here, an exemplary function may be used to return the email address associated with the user account to which the user responded.

[0062] In some embodiments, end user interface 702 allows a user to select from a set of predefined functions and saved user-defined functions. Thus, embodiments are contemplated in which a user defines a set of functions similar to set of functions 400 of Figure 4 by interacting with user interface 702 and selecting an existing function from the set of predefined or user-defined functions.

[0063] 7B, a developer interface 720 of the group-based communication system is depicted, according to some embodiments. The developer interface 720 may preferably allow advanced users to define functions within the group-based communication system using code. Thus, the developer interface 720 may be compatible with various coding languages ​​that may be hosted on the group-based communication system. For example, a command window 722 may be provided within the developer interface 720 that allows a user to enter code to define a function. In some embodiments, the developer interface 720 may interface with an external developer application to allow a user to create a function by writing code in the external developer application.

[0064] In some embodiments, developer interface 720 may allow a user to import information from an external repository to define a function in command window 722. Thus, functions may be easily shared between users. For example, an online repository may be accessed to obtain a function template by copying a link to the online repository that stores the function template and pasting it into the command window.

[0065] It should be understood that embodiments are contemplated in which both end user interface 702 and developer interface 720 allow multiple different users to create and define functions within the group-based communication system. Accordingly, a user may be given the ability to select either end user interface 702 or developer interface 720 when defining a function. Additionally, in some embodiments, either end user interface 702 or developer interface 720 may be automatically displayed to a user based on user information associated with the user stored in group-based communication system data store 162. For example, if a user is known to be an advanced software developer based on the user's role within the group-based communication system, developer interface 720 may be automatically displayed when the user wants to define a new function. Alternatively, if the user is a standard user, end user interface 702 may be automatically displayed to the user while defining a new function.

[0066] Furthermore, embodiments are contemplated in which a single user may use both developer interface 720 and end user interface 702 to define functions. For example, a user may define a function within developer interface 720 by typing or pasting code. The function may then be stored or registered within the group-based communication system so that the function is accessible from end user interface 702. The same user or another user may then access the function from end user interface 702. Thus, embodiments are contemplated in which advanced users define complex functions using developer interface 720 that can be invoked by end users via end user interface 702.

[0067] In some embodiments, a function directory may be included, which may be stored in the group-based communication system data store 162. The function directory may contain a plurality of functions that can be installed by users and external applications. In some embodiments, users and external applications may publish functions to the function directory so that the functions can be installed by other users at other organizations. Thus, if a useful function is created by a first organization, the first organization may publish the function so that a second organization may install the function from the function directory.

[0068] Turning now to FIG. 8 , a method for defining a function within a group-based communication system is depicted and generally referred to by reference numeral 800, in accordance with some embodiments. In step 802, one or more trigger conditions for the function are received from a user. It should be appreciated that in some embodiments, the trigger conditions for the function may be received via one of the end user interface 702 or the developer interface 720. Alternatively, in some embodiments, the trigger conditions may be received via a separate trigger configuration interface for setting the triggers for the function. Thus, a user may interact with the trigger configuration interface to assign triggers to a function. Here, the user may select the triggers that should be active for a given function. For example, a user may interact with the trigger configuration interface to assign an automatic trigger event when a new user is added to a channel of the group-based communication system. Additionally, a user may assign a manual shortcut trigger for the function so that other users may manually initiate the function within the group-based communication system by selecting the shortcut, as described for function shortcut 502 of FIG. 5A .

[0069] At step 804, the types and names of one or more arguments of the function are received from the user. At step 806, the types and names of one or more return values ​​of the function are received from the user. In some embodiments, the trigger condition and the types and names of each of the arguments and return values ​​are received from the user through one of the end user interface 702 or the developer interface 720, as shown in Figures 7A and 7B, respectively. At step 808, the user-defined function is stored. In some embodiments, the user-defined function, including the trigger condition and the types and names of each of the arguments and return values, is stored in the group-based communication system data store 162.

[0070] In some embodiments, the user-defined function stored in step 808 can be retrieved and used within the group-based communication system. In some embodiments, the user-defined function can be shared among users and organizations within the group-based communication system. Thus, for example, a first user at a first organization can create a user-defined function for automatically filling in a form with user information and share the function with other users at the first organization as well as users at a second organization.

[0071] It should be understood that the example functions described herein are just a few examples, and that various additional functions having different parameters not described herein are also contemplated to cater to particular scenarios within a group-based communication system.

[0072] 9A and 9B, a function permission configuration user interface 900 for some embodiments of the present invention is depicted. In some embodiments, it may be desirable to restrict access to certain functions to prevent sensitive data from being shared or lost. For example, in some embodiments, certain built-in functions may have access to sensitive user information stored in the group-based communication system data store 162. Therefore, it may be desirable to restrict functions based on function permissions. For example, function permissions may be granted only to certain users of the group-based communication system or to certain external applications, such as external application 210. Here, functions may be allowed or denied based on the function permissions. Additionally, in some embodiments, it may be desirable to restrict functions based on the particular context of the function. For example, an administrator user may configure a built-in function to access user A's data so that it is always allowed when invoked from an automated workflow triggered by user B. Furthermore, the administrator user may configure the same built-in function to always be denied when invoked from external application 210.

[0073] In some embodiments, the function permission configuration user interface 900 includes a function name, such as an exemplary function name 902, as shown in FIG. 9A. The function name 902 indicates the function for which permissions are currently set. In some embodiments, the function permission configuration user interface 900 further includes an always allowed button 904, an allow once button 906, and a not allowed button 908. Thus, a user can select one of these buttons to set the corresponding permissions for the function. For example, if a user is editing access permissions for a get user data function and wants to always allow the function, the user may select the always allowed button 904. Alternatively, if a user wants the function to be allowed only for the current execution, the user may select the allow once button 906 so that the function is allowed, but subsequent executions of the function may not be allowed or may trigger an additional prompt in the function permission configuration user interface 900. Furthermore, if a user wants the function to never be executed, the user may select the not allowed button 908.

[0074] It should be appreciated that in some embodiments, a function permission configuration user interface 900, as depicted in FIG. 9A, may be presented to the user upon execution of a function if the function is not currently allowed, thereby prompting the user to edit the function's permission settings. However, in some embodiments, the prompt may only be activated for the first execution of the function, and subsequent executions will not present the prompt.

[0075] In some embodiments, contextual metadata may be used to determine whether a function should be allowed. In such embodiments, the contextual metadata may include permissions, caller type, caller ID, function ID, user ID, trigger type, trigger ID, or other function-related information, such as channel ID. Therefore, it may be preferable to provide a function permission configuration user interface 900 so that an administrative user or a user with access rights can configure function permissions to allow and deny functions in particular contexts based on contextual metadata.

[0076] Additionally, in some embodiments, functions may be further restricted based on user role or on a user-to-user basis. For example, user A may have access to a first and a second function, while user B may only have access to the first function. Here, an administrator user or a user with access rights may configure function permissions on the function permission configuration user interface 900 to grant or revoke access to functions for specific users, user roles, or other groups of users.

[0077] In some embodiments, a more granular approach to setting function permissions may be preferred. Thus, as shown in FIG. 9B, a function permission configuration user interface 900 may be presented to a user. In such an embodiment, the function permission configuration user interface 900 includes a text description 910 that may read, for example, "Set function permission context," as shown. The function permission configuration user interface 900 may further include a list of context metadata that may be defined by the user. Thus, a user may set function permissions based on a particular context within a group-based communication system.

[0078] In some embodiments, a function may request access while the function is running. For example, if a function is triggered to obtain sensitive data for user A, the function may request access to the sensitive data from user A when the function is triggered. User A may then choose to either allow or deny access to the function. Here, the function may pause execution until a response is received from user A, and if user A allows, the function continues to obtain the sensitive information. Alternatively, if user A denies the function, the function may be stopped or may return an error.

[0079] Although the present invention has been described with reference to the embodiments illustrated in the accompanying drawing figures, it should be noted that equivalents may be employed and substituted herein without departing from the scope of the invention as set forth in the claims.

[0080] Having thus described various embodiments of the present invention, what is claimed as new and desired to be protected by patent language includes the following:

Claims

1. One or more non-transitory computer-readable media storing computer-executable instructions that, when executed by a processor, perform a method for invoking a function in a group-based communication system, the method comprising: receiving an indication over an event channel in a group-based communication system in response to the triggering of the function, wherein a group-based communication channel of the group-based communication system is used as the event channel; receiving one or more arguments of the function; generating an asynchronous request including an identifier of the function and the one or more arguments of the function; receiving a callback including one or more return values ​​of the function; and generating a success event on the event channel within the group-based communication system in response to determining that the one or more return values ​​of the function indicate successful completion of the function.

2. 2. The computer-readable medium of claim 1, wherein receiving one or more arguments of the function comprises receiving a response from a user via an interactive user session indicating the one or more arguments of the function.

3. 2. The computer-readable medium of claim 1, wherein the function is automatically initiated in response to the trigger, and wherein receiving one or more arguments of the function includes receiving one or more predetermined default values ​​for the one or more arguments.

4. 4. The computer-readable medium of claim 3, wherein at least one trigger parameter of the trigger is defined by a user through a trigger configuration interface that is independent of an interface used to define the function.

5. 2. The computer-readable medium of claim 1, wherein the trigger includes a trigger event and at least one trigger condition, and the function is initiated in response to determining that the at least one trigger condition is satisfied after the trigger event occurs.

6. The computer-readable medium of claim 1 , further comprising updating values ​​in a persistence table based at least in part on the one or more arguments of the function.

7. 10. The computer-readable medium of claim 1, wherein function permissions are required to execute the function, and the function permissions are defined by a user via a function permission configuration user interface.

8. 1. A method for invoking a function within a group-based communication system, comprising: receiving an indication over an event channel in a group-based communication system in response to the triggering of the function, wherein a group-based communication channel of the group-based communication system is used as the event channel; receiving one or more arguments of the function; generating an asynchronous request including an identifier of the function and the one or more arguments of the function; receiving a callback including one or more return values ​​of the function; generating a success event on the event channel within the group-based communication system in response to determining that the one or more return values ​​of the function indicate successful completion of the function.

9. 9. The method of claim 8, wherein receiving one or more arguments of the function comprises receiving a response from a user via an interactive user session indicating the one or more arguments of the function.

10. 9. The method of claim 8, wherein the function is started automatically in response to the trigger, and wherein receiving one or more arguments for the function includes receiving one or more predetermined default values ​​for the one or more arguments.

11. The method of claim 10 , wherein at least one trigger parameter of the trigger is defined by a user through a trigger configuration interface that is independent of an interface used to define the function.

12. 9. The method of claim 8, wherein the trigger includes a trigger event and at least one trigger condition, and the function is initiated in response to determining that the at least one trigger condition is satisfied after the trigger event occurs.

13. The method of claim 8 , further comprising updating values ​​in a persistence table based at least in part on the one or more arguments of the function.

14. The method of claim 8 , wherein function permissions are required to execute the function, and the function permissions are defined by a user via a function permission configuration user interface.

15. 1. A function call system for a group-based communication system, comprising: A data store; a processor programmed to execute a method for invoking a function in a group-based communication system, the method comprising: receiving an indication over an event channel in a group-based communication system in response to the triggering of the function, wherein a group-based communication channel of the group-based communication system is used as the event channel; receiving one or more arguments of the function; generating an asynchronous request including an identifier of the function and the one or more arguments of the function; receiving a callback including one or more return values ​​of the function; generating a success event on the event channel within the group-based communication system in response to determining that the one or more return values ​​of the function indicate successful completion of the function.

16. 16. The system of claim 15, wherein receiving one or more arguments of the function comprises receiving a response from a user via an interactive user session indicating the one or more arguments of the function.

17. 16. The system of claim 15, wherein the function is automatically initiated in response to the trigger, and receiving one or more arguments for the function includes receiving one or more predetermined default values ​​for the one or more arguments.

18. 20. The system of claim 17, wherein at least one trigger parameter of the trigger is defined by a user through a trigger configuration interface that is independent of an interface used to define the function.

19. 16. The system of claim 15, wherein the trigger includes a trigger event and at least one trigger condition, and the function is initiated in response to determining that the at least one trigger condition is satisfied after the trigger event occurs.

20. 16. The system of claim 15, further comprising updating values ​​in a persistence table based at least in part on the one or more arguments of the function.

Images