Event-based application hosting

Abstract

A medium, method, and system for hosting an event-based application are disclosed. Application instructions corresponding to processing steps to be taken in response to a particular event are received from a development environment. The event is associated with a group-based communication channel. An application including computer-executable instructions is generated based on the application instructions and metadata associated with the event. Execution of the computer-executable instructions is triggered in response to detecting one or more events. A response corresponding to an output from applying the processing steps to the event is received. A message is posted to a respective communication channel corresponding to the response.

Description

[Technical Field]

[0001] FIELD OF THE INVENTION Embodiments of the present invention relate to hosting event-based applications, and more particularly, to enabling the deployment and hosting of event-based applications in connection with group-based communication systems. [Background technology]

[0002] Developing, deploying, and hosting event-based applications that operate in conjunction with group-based communication systems has traditionally required a significant amount of software development experience and domain-specific knowledge related to application hosting. Such domain-specific knowledge includes knowledge of the group-based communication system application's programming interfaces, methods for deploying and hosting event-based applications, and the complexities associated with network connectivity between the group-based communication system and the application execution environment in which the event-based application is deployed. As a result, building, running, and maintaining group-based communication system applications requires experienced software developers with knowledge of the group-based communication system in addition to knowledge of application deployment and hosting. This creates a significant barrier to entry for the associated development platforms.

[0003] What is needed is a user-friendly platform for enabling the deployment and hosting of event-based applications in the context of a group-based communication system that allows users without domain-specific knowledge to deploy and host event-based applications in an application execution environment, thereby reducing the barrier to entry. Summary of the Invention

[0004]

[0009] Embodiments of the present invention address the above-identified problems by providing a platform for building, running, deploying, and maintaining event-based applications in association with one or more group-based communication systems. In particular, in a first embodiment, the present invention includes one or more non-transitory computer-readable media storing computer-executable instructions that, when executed by a processor, perform a method for hosting an application in association with a group-based communication system, the method including: receiving, from a development environment, application instructions and application configuration parameters associated with the application corresponding to processing steps performed in response to a plurality of events; in response to detecting one or more events in a respective group-based communication system channel of the group-based communication system, triggering execution of the computer-executable instructions based on metadata associated with the one or more events; and posting a message to the group-based communication system channel based on the response in response to the one or more events.

[0005] In a second embodiment, the invention includes a method for hosting an event-based application in association with a group-based communication system, the method including receiving, from a development environment, application instructions and application configuration parameters associated with the application corresponding to processing steps to be performed in response to a plurality of events, triggering execution of computer-executable instructions based on metadata associated with the one or more events in response to detecting one or more events in a group-based communication system channel of the group-based communication system, and posting a message to the group-based communication system channel based on the response in response to the one or more events.

[0006] In a third embodiment, the present invention includes a system having at least one processor and at least one non-transitory memory storing computer-executable instructions that, when executed by the processor, cause the system to perform actions including receiving application instructions and application configuration parameters associated with an application from a development environment, the application instructions and application configuration parameters corresponding to processing steps performed in response to a plurality of events; in response to detecting one or more events from a group-based communication system channel of a group-based communication system, triggering execution of the computer-executable instructions based on metadata associated with the one or more events; and posting a message to the group-based communication system channel based on the response in response to the one or more events.

[0007] 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]

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

[0009] [Figure 1] 1 illustrates an exemplary hardware platform for certain embodiments of the present invention. [Figure 2] 1 illustrates components of a system for implementing an embodiment of the present invention. [Figure 3] 1 shows a block diagram for implementing an embodiment of the present invention; [Figure 4] 1 illustrates components of a user interface for adding a workflow step in a specific embodiment of the present invention. [Figure 5A] 1 illustrates components of a user interface for configuring arguments to a function in one specific embodiment of the present invention. [Figure 5B] 1 illustrates components of a user interface for inserting variables associated with arguments to a function in a specific embodiment of the present invention. [Figure 6] FIG. 1 shows a data flow diagram for implementing an embodiment of the present invention. [Figure 7] 1 shows an exemplary flowchart for illustrating the operation of a method according to one embodiment of the present invention.

[0010] 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

[0011] (Background and Concept of the Invention) As used herein, the term "group-based communication system" refers to a collaborative communication system used within an organization. In some embodiments, the group-based communication system is a channel-based messaging platform. Within a group-based communication system, communications may be organized into "channels," each dedicated to a specific topic or set of users. Generally, a channel is a long-term, persistent discussion about a specific topic. Members of a particular channel can post messages that are visible to other members in that channel, along with other messages in that channel. A user may select a channel to browse to see only messages related to that channel's topic, without seeing messages posted in other channels on different topics. For example, a software development company may have different channels for each software product under development, allowing developers working on a particular project to converse without having to bother (or be bothered by) developers working on other projects. Because channels are generally persistent and directed to a specific topic or group, users can quickly and easily refer to previous communications for reference.

[0012] Communication data in a group-based communication system may include messages, queries, files (e.g., documents, spreadsheets, computer code, images, video, audio, and / or electronic contact information), mentions, users or user profiles, interactions (e.g., reactions, edits, deletions, and / or prioritization such as by pinning or staring), tickets, channels, applications integrated into one or more channels, conversations (e.g., a group of messages segmented as a single unit), workspaces (e.g., a set of channels, users, projects, tasks within an organization that may have their own set of permissions and, in some examples, may be organized substantially along an organizational chart), or other data generated by or shared among users of the group-based communication system that is associated with the communication data of an organization that uses the group-based communication system.

[0013] In some examples, the communication data may include data associated with the user, including, but not limited to, a user identifier, one or more communication channel identifiers associated with communication channels the user is authorized to access, one or more group identifiers for groups (or organizations, teams, entities, etc.) with which the user is associated, an indication of whether the user is the owner or administrator of any communication channels, an indication of whether the user has any communication channel restrictions, a plurality of messages, a plurality of emojis, a plurality of conversations, a plurality of conversation topics, an avatar, an email address, a real name (e.g., Austin Author), a username (e.g., austin_a), a password, user preferences and / or settings, a time zone, a status, a token, and other user-specific information. In some embodiments, the group-based communication system may additionally or alternatively store permission data associated with the permissions of individual users of the group-based communication system. In some embodiments, the permissions associated with individual users may be mapped to or otherwise associated with an account or profile associated with the user data. The permissions may indicate which users can communicate directly with other users, channels the user is authorized to access, individual channel restrictions, workspaces the user is authorized to access, individual workspace restrictions, etc. In some embodiments, authorization can support group-based communication systems by maintaining security to limit access to defined groups of users, in some such embodiments, such users may be defined by common access credentials, group identifiers, or other criteria, as described above.

[0014] In some embodiments, a group-based communication system may be divided into different workspaces, which may be associated with different groups of users. Each workspace may be associated with a group identifier, and one or more user identifiers may be mapped to or otherwise associated with the group identifier. Users corresponding to such user identifiers may be referred to as "members" of the group. A workspace may include one or more channels specific to that workspace and / or one or more channels shared among one or more workspaces. In some embodiments, a workspace may be associated with one or more organization identifiers, which may be associated with an organization or other entity associated with the group-based communication system. In some embodiments, such data may be mapped to or otherwise associated with other types of data (e.g., user data, permission data, or channel data).

[0015] To extend the functionality of the group-based communication system, event-based applications are developed to integrate group-based communication system functionality with external platforms. In some embodiments, an event-driven application development and hosting platform is provided. Application developers write code to build and host applications in association with the group-based communication system. In some embodiments, a command line interface is provided for developers to quickly create cloud-based event-driven applications, which are then deployed to an application execution environment associated with the group-based communication system.

[0016] In some embodiments, the event-driven application development and hosting platform can be utilized in conjunction with a workflow construction user interface to build event-based applications without the need to write program code. In such embodiments, event-based applications can be built by users who understand workflows but are untrained or otherwise unwilling to write code. In other embodiments, aspects of the event-driven application development and hosting platform are provided to trained software developers, who implement event-based applications by writing code to implement application logic.

[0017] In some embodiments, a set of application development tools is provided in the form of a command line interface (CLI). The CLI provides functionality for authenticating a developer's identity to the application development platform. In one embodiment, a developer invokes the CLI with a "whoami" parameter to determine whether the developer has previously been authenticated. If the developer has previously been authenticated as a particular user, the CLI with the "whoami" parameter returns the already authenticated username. If the developer has not previously been authenticated, the CLI may provide an error message that the CLI session is not authenticated.

[0018] The developer can then invoke the CLI with the "login" parameter to provide authentication information, or the "logout" parameter to log out of the CLI session. In this embodiment, when a developer invokes the CLI with the "login" parameter, the CLI generates a command that can be cut and pasted to be executed in an authenticated session of the group-based communication system. The generated command includes a ticket, which contains a unique random number represented as a hexadecimal string that is only valid for a few minutes. When the developer pastes the generated command into an authenticated client interface of the group-based communication system, an authentication token is generated that is used to authenticate the hosted application for both deployment and execution.

[0019] Once a developer is authenticated, the developer can build a project from scratch, check out a project from a source code repository, or use the CLI to create a predefined project skeleton. The predefined project skeletons are based on patterns for various types or categories of applications that a developer may need to build. In some embodiments, a set of predefined project skeletons is made available via the CLI by the application development platform provider. A developer can initiate commands via the CLI to build a skeleton app that corresponds to the general type of app the developer is trying to build. From there, the developer can edit and extend the skeleton app to build the specific functionality specified by the requirements for the application the developer is working on.

[0020] In one embodiment, to initialize a new, empty project, a developer invokes the CLI with the "new" parameter. This creates a very basic application framework with a minimally initialized configuration file and a set of source code files containing example code that, in some embodiments, is commented out. In some embodiments, the development environment is Node.js, and the configuration files are provided in a human-readable data serialization language format, such as YAML. In some other embodiments, an alternative programming language, such as Python or Golang, is provided.

[0021] Once a developer has edited configuration files and added and / or updated code in source code files, the developer can deploy and run the application in an event-based application hosting environment. In some embodiments, the developer invokes the CLI with the CLI parameter “deploy” to deploy the application to an application execution environment associated with the hosting environment. In some embodiments, the developer may view logs associated with the CLI by invoking the CLI with the parameter “activity.” In some embodiments, the chronologically most recent portion of the log can be viewed in conjunction with the CLI parameter “activity--tail.” Once deployed, the application functionality is operational in a group-based communication system user interface corresponding to the group-based communication system associated with the runtime environment in which the application was deployed. In some embodiments, the application can be undeployed or deleted from the execution environment using the CLI parameter “delete.” In this embodiment, the parameter “delete” does not delete the configuration and source code from the developer's development environment, but rather undeploys the application from the application execution environment.

[0022] Such deployed applications can implement group-based communication system application functions or can invoke group-based communication system application functions associated with other deployed applications. In some embodiments, such application functions are atomic pieces of application logic that can be reused. Broadly speaking, a function defines inputs, outputs, and includes application logic for generating the outputs from the inputs. In some cases, a function further performs certain specified functions (also called "side effects") in addition to generating the outputs. For example, the function post_message() may have inputs including a message, a channel identifier, and a user identifier. The function application logic has the side effect of posting a provided message, attributed to an indicated user, on an indicated channel, with return values ​​of "success" and "failure" indicating whether the message was successfully posted.

[0023] Generally, a function receives inputs and generates either an error or an output in response to those inputs. The inputs may include any one or more arguments of the function, the name of the function, and other suitable information used to implement the function. An error may be generated in response to a failure of the function. For example, if a required argument is not provided in the input, the function may fail and generate an error. The error may be returned to the group-based communication system server and displayed as an error message on a client device associated with the group-based communication system. Alternatively, an output may be generated by a function in response to successful execution of the function. In some embodiments, the output (and / or error) may generate a success event (or a failure event in the case of an error) 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 functions to be configured by having an event on the event channel serve as a trigger condition for another function.

[0024] Alternatively, or additionally, in some examples, either the output or the error may be sent directly to the subsequent function as an input argument of the subsequent function. In some embodiments, the input may be received as an argument to the function. Furthermore, the input may be received from the group-based communication system as message or event information. In some embodiments, the data undercurrent may be associated with a particular channel of the group-based communication system. The data undercurrent includes various information associated with the group-based communication channel, such as, for example, metadata of messages posted in 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 data undercurrent 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. For example, a function is contemplated that identifies the last user to post a message in a channel.

[0025] In some embodiments, it may be desirable to utilize existing resources associated with a group-based communication channel for a function. For example, channel-related information and features, such as access control, data scoping, subscriptions, application programming interfaces (APIs), data loss prevention integration, encryption key management, and international data residency integration, 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.

[0026] 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 the event message so that metadata associated with the event message can be used to initiate and provide information to the function. Alternatively, in some embodiments, it may be undesirable to publish all events as event messages within a channel, as doing so could result in users receiving excessive, 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.

[0027] In some embodiments, a function is an object within the context of the group-based communication system, such as an object in an object-oriented programming environment. Accordingly, a function may be stored in a memory, such as a group-based communication system data store, and associated with an identifier used to identify the function. Furthermore, in some embodiments, a function may be authenticated by either the group-based communication system or an external application. In some embodiments, a function may be authenticated in a single authentication step that satisfies the authentication requirements of each of the group-based communication system and the external application. Furthermore, a function may be authenticated along with the user who initiated the function. Thus, embodiments are contemplated in which a user is authenticated by the group-based communication system and does not require further action to be authenticated by the associated external application. Here, information regarding user authentication may be sent as an argument to the function, e.g., via a bearer token. Thus, if the user is authenticated within the group-based communication system, the user can run the function in conjunction with the external application. Built-in functions are extensions of the core functionality of the group-based communication system and are standard interfaces to the core API of the group-based communication system.

[0028] In some embodiments, a workflow builder user interface is provided to enable users of the group-based communication system to build and extend event-based applications without writing code. The workflow builder user interface can be used to automate processes into automated workflows in the group-based communication system. Workflows can be of any complexity and can be integrated with third-party applications and services. In the context of a workflow, a trigger is what starts the workflow. A trigger may be automatically generated in response to any event in the group-based communication system that matches pre-specified conditions. A trigger may also be manually initiated, for example, by a user of the group-based communication system interacting with a shortcut menu that, when selected, launches a workflow. In some embodiments, the shortcut menu may be accessed from a menu in a group-based communication system channel.

[0029] A workflow may incorporate workflow steps. A workflow step is a unit of execution that performs an action, such as sending a group-based communication system message or presenting a custom form user interface element to a user of the group-based communication system. Execution logic corresponding to a workflow step may be exposed from within the group-based communication system application to allow a particular workflow to be integrated with external systems (e.g., via an API). When a workflow-building user inserts a step, the workflow-building user may configure one or more parameters to pass information entered by an end user of the workflow. The workflow-building user may employ a configuration modal dialog box to configure such actions within the workflow. The configuration modal dialog box includes a set of fields. Each field in the configuration modal dialog box allows the workflow-building user to define the source of input data that the workflow consumes as input. In some embodiments, the workflow-building user may insert variables enclosed in double brackets "{{variables}}" into plain text fields to auto-populate output data from a previous workflow step.

[0030] In some embodiments, row-based and column-based objects are provided for persisting data associated with an event-based application consistent with the present invention. In these embodiments, metadata associated with a data dictionary corresponding to the persisted data may be provided in a configuration file for the event-based application. In an exemplary embodiment, a table name is provided in a YAML configuration file, followed by a list of columns with column names and standard data types corresponding to each of the columns. In some embodiments, the standard data types include: (i) a type "id," which is a string that uniquely represents a particular row in the persisted data; (ii) a type "text," which corresponds to a UTF-8 encoded string of any length; (iii) a type "user," which corresponds to a uniquely defined user identifier corresponding to a user of a group-based communication system; (iv) a type "channel," which corresponds to a channel of the group-based communication system; (v) a type "date," which takes the form of an ISO 8601-formatted string; and (vi) a type "number," which corresponds to an integer or floating-point number.

[0031] In some embodiments, data may be persisted and queried in connection with the data persistence service by making API calls to APIs provided in connection with code provided in an initial skeleton application provided by the application development platform. The data persistence API, in some embodiments, may include the methods described below that have the prefix "apps.hosted.tables." One method, named "putRow," may be called to create or update a row when providing an object mapping to table name and column name values. If a row with an "id" value corresponding to the "id" in the provided object mapping does not exist, a new row may be created. If a row with a corresponding "id" value already exists in persistent storage, the row with that "id" is updated according to the values ​​contained in the remainder of the object mapping.

[0032] Another method, "getRow," may be called to retrieve a single row given the table name and the "id" corresponding to the row to be retrieved. Yet another method that may be provided is "deleteRow," which deletes a single row given the table name and row "id." Yet another method is "query," which may be called to query a particular table and return a certain number of rows. The query expression may be any type of query term that may be used to query a database, such as a query term that may be used to query an SQL or NoSQL type database. In some embodiments, there are user interface components for interacting with and managing the data maintained in the above manner.

[0033] Various categories of users and organizations interact in several ways with the exemplary event-driven application and associated application development, deployment, and hosting environment, including, but not limited to, (i) end users of the group-based communication system, (ii) workflow users associated with the group-based communication system and using pre-built workflows, (iii) workflow construction users who build workflows to perform automated functions within the group-based communication system, (iv) users who customize group-based communication system functions and configure associated triggers, (v) subscribing organizations of the group-based communication system that develop event-based applications via group-based communication system functionality to support automations requested by subscribing organizations, and (vi) partner organizations that develop event-based applications and integrations that operate in connection with the group-based communication system.

[0034] As a non-limiting example, a group-based communication system end user in the course of using the group-based communication system may use an interactive group-based communication system channel to provide feedback about a particular product. In doing so, the end user may want to create a similar feedback flow for other end users and other products. Using the group-based communication system, the end user may seek ways to copy or use the same or similar workflows. In this capacity, the end user may become a workflow user and wish to customize an existing workflow. Within the group-based communication system client interface, the end user, now a workflow user, begins the process of customizing an existing workflow. The workflow user adds a solution based on the existing workflow and customizes the new solution. The workflow user may then add the customized solution to a particular group-based communication system channel. The workflow user may then send a message in the channel to inform channel members about the new solution. Channel members may provide comments about the new solution, and based on those comments, the workflow user may update the workflow solution configuration by, for example, updating a question in a feedback form associated with the solution.

[0035] In another example, while using a group-based communication system, a workflow user may have an immediate requirement for their team to have a way to review contracts. In this example, the workflow user may refer to available workflows to determine whether an existing workflow can be configured to allow their team to use it to review contracts. If an existing workflow can be simply configured to allow this, the workflow user may configure and add a solution as described above. Alternatively, the workflow user may determine that no existing workflow exists to meet their contract review needs. At this point, the workflow user may decide to build an appropriate workflow, and the workflow user assumes the role of a workflow construction user. In this case, the workflow construction user opens the workflow builder user interface and begins the process of creating a new workflow. In some embodiments, not all users have the privilege to create new workflows, and an administrative user of the group-based communication system may need to grant permission to the workflow construction user to create a new workflow.

[0036] When a workflow builder user begins the process of creating a new workflow in Workflow Builder, the workflow builder user may refer to the workflow templates to determine whether there is an existing workflow template to use as a basis for building the new workflow. If a template exists, the workflow builder user may open the template and add, modify, or delete workflow steps and define required inputs. If a template does not exist, the workflow builder user may choose to build the workflow from scratch by adding workflow steps as needed and defining required inputs. In either case, the workflow builder user should test the newly created workflow by running it and observing its execution based on a set of test inputs. Finally, depending on administrative configuration, the workflow builder user may choose to publish the workflow for some or all users of the group-based communication system to use.

[0037] As a third example, a power user of a group-based communication system may encounter a need to initiate a technical support incident in a support ticket tracking system if the error rate on a supported technology platform exceeds a certain error rate threshold. One option for the power user is for the power user to browse available workflows and add a solution if such a solution already exists in the group-based communication system. As discussed above, this may involve simply customizing a workflow as a workflow user, or it may involve building a workflow from scratch or based on a workflow template. If such workflow functionality does not exist, the power user may determine that they need to write code to implement a new event-based application.

[0038] In this case, a power user views a group-based communication system function in either a workflow browser or a function browser or other source of function description documents. The function description documents must provide names of functions and descriptions of inputs and outputs so that the power user, acting as a software developer writing code, can write software code to access the group-based communication system function. In some embodiments, using a function browser user interface associated with the group-based communication system, the power user identifies a function entitled "Start Incident" that appears to provide the functionality needed to initiate a technical support incident that matches the power user's requirements. In some embodiments, using the function browser user interface, the power user selects an option that allows the power user to request permission to build an application using the identified function. In this embodiment, an administrative user reviews the request and determines whether to grant the power user's permission to build such an application.

[0039] If permission to build the application is granted, the power user assumes the role of a developer and initializes a new application skeleton within the application development environment using a CLI as described above. The developer then determines whether an existing trigger can be leveraged. If an existing trigger is not appropriate, the developer creates a new trigger. In an example in which a support incident is initiated when the error rate of a supported technology platform exceeds a certain error rate threshold, the trigger may be the occurrence of an error rate above a predefined error rate. The developer then configures the application and writes the code necessary to invoke the function. In some embodiments, the developer iteratively writes the code and optionally tests the application locally within the development environment. When the developer is ready to test the application in a hosted application execution environment, the developer may use the CLI to deploy the application to the application execution environment. Once the application is deployed, the developer may create an associated workflow that connects the trigger to a function in the deployed application. The developer may then configure the associated trigger (e.g., set the error threshold). In this example, a support incident is automatically initiated when the application is enabled and errors exceed the set threshold.

[0040] Within an organization using the group-based communication system, a requirement to manage different types of incidents may arise. For example, physical security, emergencies, engineering support issues, and change requests may all be separately managed incidents. Organizational users may search available functions from third-party partners to the operators of the group-based communication system to determine whether there are functions available from third parties that provide integration with the incident management system (or incident management systems) used by the organization. In some cases, existing applications exist in a published application directory. In this case, organizational users can refer to functions and other published documentation about functions published by the published application. Organizational users may need to obtain the necessary permissions to start new applications or otherwise create workflows and configure triggers as described above. In this case, once permission is granted, organizational users can configure the group-based communication system to use third-party published applications to integrate with the incident management system according to the organization's requirements.

[0041] On the other hand, if a suitable third-party partner integration does not exist, the developer may choose to implement the integration directly. In this example, the developer requests administrator permission to build an application that implements new functions to perform the integration. In this embodiment, the administrative user reviews the request and determines whether to grant the developer permission to build such an application that implements the specified functions.

[0042] If permission to build an application is granted, within the application development environment, the developer initializes a new application skeleton using a CLI such as that described above. Next, in this example, the developer creates an "Alert User" function that contacts notified users until the notified users acknowledge the incident or the incident times out. In this example, the developer also creates a "Start Incident" function. The developer then creates a new configurable trigger and deploys the application to a hosted application execution environment. In some embodiments, the developer may configure the developed group-based communication system functions to be reusable (given appropriate permissions) within the developer's organization.

[0043] Finally, a third-party partner of the operator of the group-based communication system may wish to drive adoption of the partner's platform by the existing user base of users of the group-based communication system. To drive such platform adoption, the partner may choose to develop and maintain an event-based application hosted by the operator of the group-based communication system. The partner may receive requests from its customers to utilize the partner's platform from a client interface of the group-based communication system. For example, in the case of a partner that is a provider of an incident management system, the partner may have a requirement that its customers trigger, escalate, and resolve incidents from a client interface of the group-based communication system.

[0044] In this example, a partner developer creates an application that is an official partner-branded application to provide integration with the partner's application and / or platform. A partner user creates configuration steps to authenticate the group-based communication system to the partner's application and / or platform. The partner developer then creates configuration steps to map specific group-based communication channels to components of the application, such as, in this example, groups of users to be notified about support incidents. The partner developer then creates an integration function that implements the integration with the partner's application and / or platform, for example, using APIs exposed by the partner's application and / or platform. In some embodiments, the function is hosted by the group-based communication system operator. In some other embodiments, the integration function is hosted remotely, for example, in connection with a public or private cloud platform or in a data center maintained by the partner. In some embodiments, the partner developer configures the function to be publicly reusable and publishes it to a public or private application directory.

[0045] A rich set of management capabilities is advantageous for protecting access to sensitive information associated with event-based applications running in connection with a group-based communication system. Hosted applications and corresponding capabilities that can be utilized by a broader set of users raise potential data governance concerns, as providing additional data access and other capabilities increases the complexity of the overall group-based communication system, thereby raising potential issues regarding data security and compliance.

[0046] In some embodiments, an administrative user of a group-based communication system can manage roles corresponding to groups of users who are authorized to develop, deploy, configure, modify, and use applications hosted in association with the group-based communication system. The administrative user may specify which users can host applications in association with a particular organization's group-based communication system. The administrative user enables groups or groups of users to develop and deploy hosted applications in a secure sandbox environment without concern about data moving outside the organization's boundaries. In some embodiments, test data associated with a sandbox environment is random data or data that is otherwise sanitized and de-identified to personally identifiable information or other sensitive information. The administrative user can grant permission to a group or groups of "trusted" users to deploy hosted applications that can communicate with systems outside the group-based communication system, such as the organization's internal on-premises enterprise applications, or other third-party external systems. Furthermore, the administrative user himself or herself can assign a group or groups of users to be application hosting and / or application development platform administrators.

[0047] To control data egress, administrative users can control which applications have the ability to call external APIs to various destinations. These destinations include a particular organization's internal systems, on-premise systems, and other third-party external systems. Administrative users can specify a list of group-based communication system OAuth scopes that are permitted for use with a particular organization's hosted applications. Administrative users can restrict where a particular organization's hosted functions and / or triggers can be made available to external organizations. Administrative users can restrict which group-based communication system workspaces within a particular organization can access a particular hosted application. In some embodiments, administrative users can define required fields and values ​​in a hosted application's application configuration metadata to ensure that access control measures are not circumvented. For various types of hosted applications, administrative users can select whether a particular hosted application should undergo validation before the hosted application is deployed.

[0048] Administrative users may have the ability to visualize and monitor the number and type of hosted applications, functions, and / or triggers hosted by a particular organization, as well as the respective owners and / or collaborators who have access rights and permissions to a particular application, function, and / or trigger. Administrative users can audit log data regarding the external functions and / or triggers an organization is using, as well as input, output, and status. Administrative users can detect and audit configuration changes to a particular organization's hosted applications. Administrative users may investigate resource consumption and understand the hosting costs of a particular hosted application. Administrative users may monitor the usage and associated resource consumption of each hosted application and / or function. Administrative users can restrict whether a particular organization's triggers are invoked from a particular webhook. Administrative users may audit the external endpoints invoked by a particular organization's applications, functions, and / or triggers. Administrative users may audit the Core Group-based Communication System API endpoints invoked by a particular organization's functions. Administrative users may detect and audit changes to hosting roles and permissions. Administrative users may access the source code on which a particular hosted application is based, as well as the change history of each source code control. Data governance principles apply to data storage practices that adhere to specific organizational compliance standards, such as enterprise key management and international data residency.

[0049] An administrative user may grant specific roles to hosting developers. Such roles correspond to a set of features that a particular developer can incorporate into the developer's hosted applications, functions, and / or triggers. In some embodiments, an administrative user may create new hosting permission roles and specify fine-grained feature availability for the new hosting permission roles. In one embodiment, three roles are provided: basic, basic plus storage, and trusted. The basic hosting permission role does not allow data storage. Applications assigned to the basic role (basic application) may call built-in group-based communication system functions and group-based communication system features hosted by the same organization. The basic role cannot call external APIs. Functions implemented and exposed in applications assigned to the basic role may be called by group-based communication system workflows and other group-based communication system functions hosted by the same organization. The basic application itself may not be called by group-based communication system functions owned by external organizations, and functions associated with the basic application may not be called by webhooks implemented by the basic application. Applications assigned to the basic plus storage role have the same characteristics as the basic application, except that they can store data. Applications assigned to trusted roles (trusted applications) store and call data and can be invoked in the same way as basic applications. Additionally, trusted applications may call external APIs. Trusted applications may be invoked by functions in a group-based communication system owned by an external organization (which implements the necessary authentication and authorization). Functions associated with trusted applications may be invoked by webhooks implemented by the trusted application.

[0050] In some embodiments, when a developer attempts to deploy an application with an unauthorized feature due to role-based authorization constraints configured in the application development environment or other implemented organizational rules, an error may be returned to the developer and the application may not be deployed. In some embodiments, the base application may call functions exposed by the trusted application. In this embodiment, the base application must provide any authentication credentials, such as a bearer token, that the trusted application may require.

[0051] The subject matter of the present invention is described in detail below to satisfy statutory requirements, but the description itself is not intended to limit the scope of the claims. Rather, the claimed subject matter may be embodied in other ways, including different steps or combinations of steps similar to those described herein, in conjunction with other current or future technologies. Minor variations from the following description will be understood by those skilled in the art and are intended to be captured within the scope of the claimed invention. No term should be construed as implying a particular order of the various steps described, unless the order of individual steps is explicitly recited.

[0052] The following detailed description of embodiments of the present invention refers to the accompanying drawings, which show, by way of illustration, specific embodiments in which the invention may be practiced. These embodiments are intended to describe aspects of the present 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 present invention. Therefore, the following detailed description is not to be construed in a limiting sense. The scope of embodiments of the present invention is defined only by the appended claims, including the full range of equivalents to which such claims are entitled.

[0053] 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, or operation 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.

[0054] (Operating Environment for an Embodiment of the Invention) Referring first to FIG. 1 , an exemplary hardware platform for certain embodiments of the present invention is shown. The 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. The computer 102 shows several components for illustrative purposes. In some embodiments, certain components may be located differently or may not be present. Additional components may be present. The computer 102 includes a system bus 104 that allows other components of the computer 102 to communicate with each other. In certain embodiments, multiple buses or components may communicate directly with each other. A central processing unit (CPU) 106 is connected to the system bus 104. Also connected to the system bus 104 are one or more random access memory (RAM) modules 108. Also connected to the system bus 104 is a graphics card 110. In some embodiments, the graphics card 110 may not be a physically separate card, but rather may be integrated into the motherboard or the 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 into 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 internal to the computer 102 or externally, removably attached.

[0055] 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.

[0056] Finally, a network interface card (NIC) 124 is also connected to the system bus 104, thereby enabling the computer 102 to communicate over a network, such as network 126. The NIC 124 may be any form of network interface known in the art, such as Ethernet, ATM, fiber, Bluetooth, or Wi-Fi (i.e., the Institute of Electrical and Electronics Engineers (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 where information can be stored and retrieved 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, etc. 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 public Internet 132. Local network 126, in turn, is connected to the public 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 public Internet 132.

[0057] Turning now to FIG. 2 , an exemplary diagram illustrating components of a system for implementing embodiments of the present invention is shown, generally referred to by reference numeral 200. System 200 provides a platform for building, deploying, running, monitoring, and maintaining event-based applications. System 200 includes any number of client devices, such as a group-based communication system client device 204, a mobile client device 206, and a developer client device 202. Individual users may connect to the components of system 200 using a single client device or multiple client devices, either simultaneously or sequentially. Similarly, in some embodiments, multiple users may share a single client device (simultaneously or sequentially) to access the group-based communication system. As shown in FIG. 2 , the client devices may be any form of computing device described above with respect to FIG. 1 . In particular, users may access the components of system 200 using desktop, laptop, or mobile devices. The components of system 200 may be accessible via dedicated software on the particular client device or via a web browser associated with the client device. In some embodiments, developers and application hosting system administrators can access administrative functions via any client device. In other embodiments, the management functions may be accessible only from a limited subset of client devices (e.g., only via developer client device 202). In some embodiments, group-based communication system 212 is a channel-based messaging platform that may host multiple group-based communication system servers and group-based communication data stores, such as group-based communication system server 210 and group-based communication data store 208.

[0058] In some embodiments, group-based communication system 212 provides services in association with group-based communication system server 210. Group-based communication system server 210 may be a dedicated server, a shared server, a virtual machine instance in a cloud computing environment, or any other form of computing device described above with respect to FIG. 1. While a single group-based communication system server 210 is shown, 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, for security reasons, a software development company may not want to host its group-based communication system on the same server as a competitor's group-based communication system.

[0059] Cloud service provider 214 represents an on-demand cloud computing platform that provides data storage and computing resources in the form of dedicated servers, shared servers, virtual machine instances within a cloud computing environment, or any other form of computing device described above with respect to FIG. 1. Cloud service provider 214 may offer Software as a Service (SaaS), Infrastructure as a Service (IaaS), or Platform as a Service (PaaS), including serverless execution in an event-driven serverless execution environment. The serverless execution environment may enable deployment of application containers built for a specific execution environment. Generally, an application container is an isolated instance of a specific application that includes application code, application configuration resources, and certain associated libraries and application dependencies that enable rapid and independent deployment of the application.

[0060] Server 210 is communicatively coupled to client devices 202, 204, and 206 and cloud service provider 214 via network 216. Network 216 may be a local area network (LAN), a wide area network (WAN), a virtual private network (VPN), or the Internet. Generally, any type of network is contemplated for providing communication between the various components of system 200. Group-based communication system server 210 may provide web server functionality to enable web-based clients and non-web server functionality to enable clients using specialized applications. Alternatively, both web-based clients and specialized application clients may use a single web server, or the web server may be a gateway providing web-based access to specialized application servers. Other technologies for enabling communication between various types of client applications are also contemplated.

[0061] Group-based communication system data store 208 is communicatively connected to group-based communication system server 210. As shown, group-based communication system data store 208 is directly connected to group-based communication system server 210, although any form of communication connection (e.g., network-attached storage (NAS), network file system (NFS), or cloud-based storage) may be employed. Broadly speaking, group-based communication system data store 208 stores all of the durable information used by group-based communication system server 210. For example, group-based communication system data store 208 may store all of the 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 200. In such embodiments, each group-based communication system server may have its own copy of group-based communication system data store 208. 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, the data may be split across multiple group-based communication system data stores.

[0062] Referring now to FIG. 3 , a block diagram for implementing embodiments of the present invention is shown and generally referred to by reference numeral 300. In various embodiments, a trigger 302 is configured to trigger the execution of a function 320. The trigger initiates the execution of an application and may take the form of a schedule 304, a webhook 306, a shortcut 308, or a slash command 310. In some embodiments, the schedule 304 acts like a timer, such that periodic firing of the trigger can be scheduled. In some embodiments, an end user of an event-based application sets an arbitrary schedule for firing of the trigger, such as once an hour or at 9:15 AM daily. Furthermore, the trigger 302 may take the form of a webhook 306. The webhook 306 is a software component that listens on a webhook URL and port. In some embodiments, the trigger fires when an appropriate HTTP request is received on the webhook URL and port. In some embodiments, the webhook 306 requires appropriate authentication, such as via a bearer token. In some embodiments, the payload associated with a particular webhook call includes information that is processed by the webhook before firing any triggers. In some embodiments, one of the triggers 302 fires each time a webhook 306 is called, and some or all of the payload associated with the particular webhook call is passed to one or more of the functions 320. In some other embodiments, the trigger depends on the payload content.

[0063] Another source of one of the triggers 302 is a shortcut within shortcuts 308 associated with the group-based communication system. In some embodiments, the shortcuts 308 are global to the group-based communication system or specific to a group-based communication system channel. A global shortcut is not specific to a group-based communication system channel or workspace. A global shortcut may be initiated from a shortcut button in a group-based communication message composer or from within a search interface associated with a group-based communication system client interface. A global shortcut may trigger a function that can be performed without the context of a particular group-based communication system message or group-based communication channel. In contrast, a message-based or channel-based shortcut is specific to a group-based communication system message or channel and operates within the context of a particular group-based communication system message or group-based communication channel.

[0064] A further source of one of the triggers 302 may be provided by a slash command 310. The slash command 310 may serve as an entry point for a group-based communication system function, integration with an external service, or a group-based communication system message response. In some embodiments, the slash command 310 may be entered by a user of the group-based communication system to trigger the execution of a particular application function. A particular slash command may be entered by a user of the group-based communication system directly into a user input component normally used to enter group-based communication system messages. In some embodiments, the slash command 310 is distinguishable from a group-based communication system message in that it is preceded by a forward slash (“ / ”). The slash command may be followed by slash command line parameters that may be passed along to any group-based communication system function that is invoked in connection with the triggering of the group-based communication system function, such as one of the functions 320.

[0065] An additional source of triggering a function is when an event (e.g., event 312) matches one or more conditions predefined in a subscription (e.g., subscription 318). Event 312 may be subscribed to by any number of subscriptions 318, with each subscription specifying different conditions and triggering a different function. In some embodiments, an event is a group-based communication system message received on one or more group-based communication system channels. Application event 314 may be a group-based communication system message with associated metadata created by an application in a group-based communication system channel. Event 312 may also be a direct message received by one or more group-based communication system users, who may be actual users or technical users such as bots. Bots are technical users of the group-based communication system used to automate tasks. Bots may be programmatically controlled to perform various functions. Bots may monitor and assist in processing group-based communication system channel activity, as well as post messages to group-based communication system channels and react to member activity in the channels. Bots may have a name, profile, and profile picture associated with the group-based communication system. Bots may be referenced in group-based communication system messages and sent direct messages, and may be able to post messages, upload files, and be invited and removed from both public and private channels in the group-based communication system.

[0066] Event 312 may also be any event associated with the group-based communication system. Such group-based communication system events 316 include events related to the creation, modification, or deletion of a user account in the group-based communication system, and events related to messages in a group-based communication system channel (such as creating a message, editing or deleting a message, or reacting to a message). Event 312 may also be related to the creation, modification, or deletion of a group-based communication system channel, or channel membership. Event 312 may also be related to a user profile modification or group creation, member maintenance, or group deletion. Event 312 may also be triggered by a change detected by a third-party integration, such as a change in the status of a ticket in a third-party incident management system.

[0067] As described above, subscriptions 318 indicate one or more conditions that, when matched by an event, trigger a function. In some embodiments, a set of event subscriptions is maintained in association with the group-based communication system, such that when an event occurs, information about the event is matched against the set of subscriptions to determine which, if any, of functions 320 should be invoked. In some embodiments, the events to which a particular application may subscribe are managed by an authorization framework. In one embodiment, the event types matched against subscriptions are managed by OAuth permission scopes, which may be maintained by an administrator of a particular group-based communication system.

[0068] The functions 320 triggered by the triggers 302 and subscribed events 312 may be provided in a variety of forms. First, there are group-based communication system "built-ins" 322 associated with specific group-based communication system core functionality. Some examples include creating group-based communication system users or channels. Next, there are group-based communication system user builder "no code" functions 324 that may be developed by a group-based communication system user in association with the workflow builder user interface, as described above. Finally, there are code "hosted" 326 functions implemented by the group-based communication system application that are developed as software code in association with a software development environment.

[0069] These various types of functions 320 may then be integrated with APIs 328. In some embodiments, the APIs 328 are associated with third-party services that the functions 320 employ to provide custom integration between a particular third-party service and the group-based communication system. Examples of third-party service integrations include video conferencing, sales, marketing, customer service, project management, and engineering application integration. In such an example, one of the triggers 302 may be a slash command 310 used to trigger a code “hosted” function 326 that makes an API call to a third-party video conferencing provider through one of the integrated APIs 328. As shown in FIG. 3 , the API 328 itself may also be the source of one or more triggers 302 or events 312. In this example, the successful completion of the video conference triggers one of the functions 320 to send a message that initiates a further API call to the third-party video conferencing provider to download and archive the video conference recording and save it to a group-based communication system channel.

[0070] In addition to integrating with API 328, function 320 may persist and access data in table 330. In some embodiments, table 330 is implemented in association with a database environment associated with the serverless execution environment in which a particular event-based application is running. In one embodiment, table 330 may be provided in association with a relational database environment. In other embodiments, table 330 is provided in association with a database mechanism that does not employ relational database technology. As shown in FIG. 3 , in some embodiments, a read or write of certain data to one or more of tables 330, or data in a table that matches predefined conditions, is itself the source of one or more triggers 302 or events 312. For example, if table 330 is used to maintain ticketing data in an incident management system, a count of open tickets exceeding a predetermined threshold may trigger a message being posted to an incident management channel in a group-based communication system.

[0071] 4, components of a user interface for adding a workflow step in a specific embodiment of the present invention are shown and generally referenced by the reference numeral 400. In various embodiments, a corpus of available workflow steps is made available to a workflow construction user. In one embodiment, a search field 402 is provided to allow a workflow construction user to search for a particular workflow step by name or other characteristic of the workflow step required to perform that particular step within a workflow. A workflow construction user may search for a workflow step based on the creator of the workflow step, in terms of the workflow step's function or description, or based on a date range associated with the creation or publication of a particular workflow step.

[0072] In some embodiments, one or more of the listed available workflow steps may be added to a workflow by clicking an “Add” button associated with the respective workflow step. As shown in the example of FIG. 4 , various workflow steps may be provided. Workflow step 404 performs the function of creating a form that is displayed to an end user of the group-based communication system and made interactive for use by the end user. Further configuration of the workflow step (not shown) may be performed by the workflow construction user when the workflow construction user clicks to add workflow step 404 to the workflow being constructed. Workflow step 406 performs the function of sending a message within the group-based communication system. Workflow step 408 is a shortcut for implementing a group-based communication system shortcut, which performs the underlying group-based communication system function associated with the shortcut as configured in the group-based communication system. Workflow steps 404, 406, and 408 are shown in the illustrated embodiment to be from “GBCS Co.”, the operator of the particular group-based communication system. These workflow steps are said to be built-in because they are part of the core functionality of the group-based communication system.

[0073] In some embodiments, filter criteria are provided to assist the workflow builder user in filtering the available workflow steps. Such filter criteria include empty filter criteria 416, which provides an unrestricted list of all steps as shown. The filter criteria also include filter criteria 418, which limits the display to built-in workflow steps provided by GBCS Co. In this embodiment, the filter criteria also include filter criteria 420, which limits the display to workflow steps provided by third-party applications, such as workflow steps 410 and 412, which provide the ability to add and remove spreadsheet rows based on the configuration of the workflow steps and any current state of the workflow up to that point.

[0074] Additionally, workflow step 414 is a step exposed by a hosted group-based communication system application that implements and exposes the group-based communication system's functionality within the workflow builder user interface shown in Figure 4. Workflow step 414 is titled "Host Running" and is associated with a group-based application titled "Hosting Up." In various embodiments, a workflow builder user may interact with user interface component 400 to filter the displayed workflow steps to only those provided by specific third-party applications, such as application identifiers 422 and 424, which correspond to the "Spreadsheet for Workflow Builder" and "Host Up" third-party applications, respectively.

[0075] Referring now to FIG. 5A, a user interface component for configuring arguments to a function in a specific embodiment of the present invention is shown and generally referenced by reference numeral 500. User interface component 500 is presented to a workflow construction user in association with the workflow construction user selecting to add workflow step 414 of FIG. 4. FIG. 5A illustrates a step configuration modal dialog box that enables the workflow construction user to further configure a workflow step associated with a function implemented by a hosted application. User input elements 502 and 504 correspond to input arguments of the function associated with the workflow step being configured in association with user interface component 500, which confirms whether a particular host is operational, i.e., “running.” The first argument is titled “When someone says a host is running, you say…” In some embodiments, user input element 502 is a text box into which the workflow construction user enters a thumbs-up emoji and the text “Of course.” In one embodiment, a hosted application that exposes a particular function provides default values ​​for user input elements 502 and 504.

[0076] In some embodiments, a workflow construction user may select which variable links 512 and 514 to insert to provide variables instead of constant strings in association with user input elements 502 and 504. Configuring user input elements 502 and 504 with variables is further described in connection with FIG. 5B below. In various embodiments, a checkbox 516 is provided to allow a workflow construction user to specify whether a workflow step should be performed synchronously. If checkbox 516 titled "Wait for step to complete before continuing" is checked, the workflow step is treated as a synchronous step, and workflow execution is blocked until the workflow step is completed. Alternatively, if the checkbox is cleared, execution is not blocked while the workflow step is being performed. In some embodiments, a delete button 510, a cancel button 508, and a save button 506 are provided in user interface component 500. Selecting the delete button 510 removes the workflow step from the workflow. The cancel button 508 cancels the workflow step configuration operation, and the save button 506 saves any changes made in connection with the workflow step configuration operation.

[0077] Referring now to FIG. 5B , in certain embodiments of the present invention, a user interface component for inserting variables associated with arguments to a function is shown and generally referenced by reference numeral 550. User interface component 550 is presented to a workflow construction user in connection with the workflow construction user selecting to insert a variable in FIG. 5A . FIG. 5B illustrates a modal dialog box “Insert Variable” that allows a workflow construction user to specify a variable to be inserted in connection with configuring a workflow step associated with a function implemented by a hosted application. In some embodiments, a list of potential variables to insert associated with the group-based communication system function and workflow is provided. In some embodiments, the variable to be inserted is associated with a shortcut associated with the group-based communication system function being called; such exemplary shortcuts are illustrated in FIG. 5A as shortcuts 552 and 554. A variable associated with a function implementing a workflow step is illustrated as variable 556 entitled “Status.” In some embodiments, right-clicking (or providing a long press gesture) on one of the variables provides additional information about the variable. Selecting a variable hides the modal dialog box and inserts the variable into the respective user input associated with the workflow step configuration user interface control, such as user interface control 500 in FIG. 5A.

[0078] (Operation of an embodiment of the present invention) Referring now to Figure 6, a data flow diagram 600 for implementing an embodiment of the present invention is shown. Illustrated in data flow diagram 600 is an event-based application development environment 602. In some embodiments, event-based application development environment 602 is created with a source code editor and various other source code development tools. In some embodiments, these tools are installed on a developer device, such as developer device 202 of Figure 2. Alternatively, the event-based application development system can be hosted remotely, providing a front-end interface to developers so that they can interact with event-based application development environment 602.

[0079] In addition to the event-based application development environment 602, also shown is an event-based application execution environment 604, which is an environment for executing one or more event-based applications. The event-based application execution environment 604 may be hosted in a data center operated by an operator of the group-based communication system. Alternatively, the event-based application execution environment 604 may be hosted on-premise in a public or private cloud or in a data center operated by an enterprise consuming services from the group-based communication system, but does not permit hosting of a particular event-based application and associated data outside of a data center operated by the enterprise. In some embodiments, the event-based application execution environment 604 is a serverless execution environment hosted in association with a public or private cloud platform.

[0080] Dataflow diagram 600 also illustrates external event source 606, which is any source of events potentially consumed by the event-based application, as described above with respect to FIG. 3 . External event source 606 may be a user entering a message into a group-based communication system channel. A user may enter a message directly into a group-based communication system channel by entering text or other data into a client interface associated with the group-based communication system. A user may also generate an event by clicking an interactive interface associated with the client interface, by (for example) clicking a button within the interface, or by otherwise interacting with an interface associated with the group-based communication system. External event source 606 may also be an event-based application that generates one or more output events based on one or more trigger events. External event source 606 may also be an external application, such as a news source or social media site. Group-based communication system 608 is also illustrated as both a source and recipient of events in the dataflow, as well as the interface and execution environment for group-based communication system workflow steps, as described below.

[0081] Within the environment of data flow diagram 600, as shown in flow 610, an application developer may scaffold a new project or retrieve code for an existing project in the context of developing an event-based application. In some embodiments, this data flows from the event-based application execution environment 604, as if a skeleton application is provided in a central location associated with the event-based application execution environment 604. This may also be the case, for example, when a source code repository function is also provided by the event-based application execution environment 604. It is understood that an external source code repository (not shown) may also be utilized to provide source code control capabilities to the application developer. Once the application developer has scaffolded a skeleton application or retrieved an existing project, the application developer can debug or add functionality to the event-based application. In some embodiments, an emulator or simulation of the application execution environment is provided in association with the event-based application development environment 602 to enable the application developer to iteratively develop the event-based application. Alternatively, the event-based application is deployed on the event-based application execution environment 604 whenever a file change occurs within a set of files associated with the event-based application.

[0082] Flow 612 illustrates these deployment and / or run instructions. In some embodiments, deploying an event-based application to the event-based application execution environment 604 requires creating the application if the application has not already been created based on application configuration metadata. Alternatively, the application is updated based on updated application source code and application configuration metadata. In some embodiments, if an application icon file associated with the event-based application has changed since the last deployment, the application icon file is preprocessed and uploaded to the application execution environment. Preprocessing requires centering and cropping the icon according to application icon sizing requirements, such as the size and dimensions of the icon file. In some embodiments, the source code is bundled and uploaded to the application execution environment hosting platform. If the execution environment associated with the event-based application has not yet been provisioned, the execution environment is provisioned. In some embodiments, an application container is constructed in flow 616 prior to deployment to the application execution environment.

[0083] In flow 618, an application developer creates and monitors debug events to test the event-based application during application development. This may include using APIs associated with the group-based communication system to implement an application test suite with predefined inputs and corresponding associated expected outputs. When the event-based application is deployed, whether in development or in a production environment, it receives the events, processes them, and generates output corresponding to the application logic implemented by the event-based application.

[0084] Referring now to FIG. 7 , an exemplary flowchart 700 is depicted to illustrate the operation of a method according to one embodiment of the present invention. In various embodiments, an application developer works in a development environment to develop source code that provides the basis for an event-based application. The application developer inputs source code instructions and application metadata, such as application configuration parameters in application configuration files. In some embodiments, the source code instructions are provided in the form of source code files in a scripting language, such as one of the ECMAScript family of programming languages. In other embodiments, the source code instructions are provided in the form of uncompiled or pre-compiled source code in a compiled programming language. In some embodiments, the application configuration parameters are provided in the form of YAML configuration files. In other embodiments, another markup language (such as JSON or XML) is used. In some embodiments, data files that comprise the application instructions and configuration parameters are packaged into an archive for transmission as a single data file. In some other embodiments, the files may be transmitted individually to a hosting environment. In step 702, these application instructions and configuration parameters are received. In some embodiments, the application instructions and configuration parameters are received by an intermediate processing program associated with the development environment, which may be run on the application developer's development client device, such as development device 202 of FIG. 2 . In various embodiments, the application instructions are designed to act on a particular event when the event is received in the group-based communication system.

[0085] Next, in step 704, an application container is generated based on the application instructions and application configuration parameters. As used herein, an application container is a unit of software that packages code and dependencies, such as libraries, so that an application can be seamlessly and reliably deployed from one application execution environment to another. In some embodiments, an application container image is a lightweight, standalone package of software and configuration metadata that contains everything needed to run an application in a particular run time. A container run time is an execution environment in which a particular category of application container can be run. In some embodiments, an application container is a virtual machine image that can run in any virtual machine execution environment.

[0086] Next, in step 706, the application container is deployed to an application execution environment. In some embodiments, the application container is transferred over a network to a remote data center hosting either a public or private cloud. In some test environments, the execution environment may be an application execution environment residing on the application developer's development device. In some embodiments, the application execution environment is hosted by the operator of the group-based communication system, either in a data center operated by the operator of the group-based communication system or in another public or private cloud. In some other embodiments, the application execution environment is hosted on-premise in a data center operated by a company that consumes services from the group-based communication system, but is not permitted to host data associated with a particular event-based application outside of a data center operated by the company. In some embodiments, deployment of the application container also requires that processing associated with the event-based application begin execution. In this embodiment, the event-based application listens on a webhook URL and port associated with a public IP address. In some other embodiments, the event-based application is simply deployed and does not run until an associated event is received in the group-based communication system.

[0087] Continuing with test 708, once the event-based application is deployed, the monitoring process determines whether an actionable event has been received in association with one or more group-based communication system channels associated with the group-based communication system. In some embodiments, the criteria by which it may be determined whether an actionable event has been received is based on the configuration of one or more triggers. A trigger may be a description of an event that should be routed to a particular function associated with the event-based application, as generally described above with respect to FIG. 3. If an actionable event is not received, the monitoring continues to wait for an actionable event to be received. If an actionable event is received in test 708, execution proceeds to step 710.

[0088] At step 710, the actionable event is sent to the appropriate deployed application container. In some embodiments, this includes the group-based communication system detecting that a trigger has occurred, such that a certain condition associated with the trigger has been met by a message or other event occurring in association with the group-based communication system. In some embodiments, this may be the receipt of a message or other group-based communication object received on a group-based communication system channel. Generally, the events described above with respect to FIG. 3 are contemplated as being processed at step 710. In some embodiments, the event is formatted by the group-based communication system as a JSON object and sent to the event-based application by posting an HTTP transmission to a webhook URL associated with the event-based application. In these embodiments, the HTTP transmission is an indication that an actionable event has been received and that it should trigger execution of the event-based application.

[0089] Next, in step 712, the group-based communication system receives a response in response to the event sent in the previous step. In some embodiments, the response is a composite output associated with a function contained within the event-based application and including application logic associated with the group-based communication system. In some embodiments, execution of the application logic associated with the event-based application results in various side effects, such as opening a video conference session or writing data to a data persistence store.

[0090] Finally, in step 714, a message is posted to the respective group-based communication system channel based on the response. In some embodiments, the posted message is itself an event that may trigger further processing in the event-based application or another event-based application. In some other embodiments, the posted message may include interactivity attributes that, when further acted upon by a user of the group-based communication system, cause a further event to trigger further execution by one or more event-based applications associated with the group-based communication system.

[0091] Many different arrangements of the various components depicted, and components not shown, are possible without departing from the scope of the following claims. The embodiments of the invention are described with the intention of being illustrative, not restrictive. Alternative embodiments will become apparent to the reader after and because of reading this disclosure. Alternative means for implementing the foregoing may be accomplished without departing from the scope of the following claims. Certain features and subcombinations are useful and may be used without reference to other features and subcombinations and are contemplated within the scope of the claims. While the invention has been described with reference to 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.

[0092] 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 hosting an application in association with a group-based communication system, the method comprising: receiving, from a development environment, application instructions and application configuration parameters associated with the application corresponding to processing steps to be performed in response to at least one group-based communication system event, the at least one group-based communication system event being associated with a group-based communication system channel of the group-based communication system; constructing an application container based on the application instructions and the application configuration parameters; deploying the application container to a third party cloud computing environment separate from the group-based communication system; in response to detecting the at least one group-based communication system event in the group-based communication system channel of the group-based communication system; transmitting, from the group-based communication system to the application container deployed within the third-party cloud computing environment, a representation including the at least one group-based communication system event and metadata associated with the at least one group-based communication system event; triggering execution by the third-party cloud computing environment of the application instructions based on the indication, thereby generating an execution result responsive to at least one group-based communication system event; receiving, by the group-based communication system, the execution result from the application container deployed in the third-party cloud computing environment; and posting a message to the group-based communication system channel based on the execution result. One or more non-transitory computer-readable media.

2. One or more non-transitory computer-readable media as described in claim 1, wherein a video conferencing session is initiated based on the execution result.

3. One or more non-transitory computer-readable media as described in claim 1, wherein the messages are posted to different group-based communication system channels.

4. One or more non-transitory computer-readable media as described in claim 1, wherein the application container is deployed in response to a determination that a development user of the group-based communication system has authority to deploy cloud-based applications.

5. The method of claim 1, wherein executing the application instructions in response to the at least one group-based communication system event comprises: storing the data in a data persistence service accessible to the third-party cloud computing environment via a persistence application programming interface; 10. One or more non-transitory computer-readable media according to claim 1.

6. 6. The one or more non-transitory computer-readable media of claim 5, wherein storing the data in a data persistence service comprises storing the data in a predefined portion of a data persistence table and causing the group-based communication system channel of the group-based communication system to generate a further event.

7. One or more non-transitory computer-readable media as described in claim 1, wherein a management interface associated with the application defines application programming interface access permissions based on associated network destinations.

8. 1. A method for hosting an application in connection with a group-based communication system, comprising: receiving, by at least one processor of the system, application instructions and application configuration parameters associated with the application from a development environment, the application instructions and application configuration parameters corresponding to processing steps to be performed in response to at least one group-based communication system event, wherein the at least one group-based communication system event is associated with a group-based communication system channel of the group-based communication system; constructing an application container based on the application instructions and the application configuration parameters; the at least one processor deploying the application container to a third party cloud computing environment separate from the group-based communication system; in response to detecting the at least one group-based communication system event in the group-based communication system channel of the group-based communication system; the at least one processor transmitting from the group-based communication system to the application container deployed in the third-party cloud computing environment an indication including the at least one group-based communication system event and metadata associated with the at least one group-based communication system event; triggering, by the at least one processor, execution by the third party cloud computing environment of the application instructions based on the indication to generate an execution result responsive to at least one group-based communication system event; receiving, by the at least one processor, the execution result from the application container deployed in the third-party cloud computing environment via the group-based communication system; and posting a message to the group-based communication system channel based on the execution result. method.

9. The method described in claim 8, wherein a video conferencing session is initiated based on the execution result.

10. The method of claim 8, wherein the messages are posted to different group-based communication system channels.

11. The method of claim 8, wherein the application container is deployed in response to a determination that a development user of the group-based communication system has authority to deploy cloud-based applications.

12. The method of claim 11, wherein executing the application instructions in response to the at least one group-based communication system event comprises: storing the data in a data persistence service accessible to the third-party cloud computing environment via a persistence application programming interface; The method of claim 8.

13. 10. The method of claim 8, wherein storing the data in a data persistence service comprises storing the data in a predefined portion of a data persistence table and causing a further event to be generated on the group-based communication system channel of the group-based communication system.

14. The method of claim 13, wherein a management interface associated with the application defines application programming interface access permissions based on associated network destinations.

15. 1. A system comprising: at least one processor; and at least one non-transitory memory storing computer-executable instructions, The computer-executable instructions, when executed by the processor, cause the system to perform the method of any one of claims 8 to 14. system.

Images