https://github.com/slack-samples/deno-triage-bot
Generate reports for support requests submitted to public channels and configure regularly scheduled reporting
https://github.com/slack-samples/deno-triage-bot
next-gen
Last synced: about 1 year ago
JSON representation
Generate reports for support requests submitted to public channels and configure regularly scheduled reporting
- Host: GitHub
- URL: https://github.com/slack-samples/deno-triage-bot
- Owner: slack-samples
- License: mit
- Created: 2023-08-22T20:53:06.000Z (almost 3 years ago)
- Default Branch: main
- Last Pushed: 2025-02-05T21:13:24.000Z (over 1 year ago)
- Last Synced: 2025-03-31T15:00:04.661Z (about 1 year ago)
- Topics: next-gen
- Language: TypeScript
- Homepage:
- Size: 427 KB
- Stars: 1
- Watchers: 5
- Forks: 3
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# Triage Bot
Triage Bot features workflows where users can generate reports for support
requests in Slack public channels. In addition, users can configure channels to
receive reports on a scheduled basis. A request is any message that begins with
a :white_circle:, :large_blue_circle:, or :red_circle: emoji. A message with
:eyes: reaction is in progress. A message with :white_check_mark: reaction is
done.
**Guide Outline**:
- [Setup](#setup)
- [Install the Slack CLI](#install-the-slack-cli)
- [Clone the Sample App](#clone-the-sample-app)
- [Running Your Project Locally](#running-your-project-locally)
- [Included Workflows](#included-workflows)
- [Creating Triggers](#creating-triggers)
- [Datastores](#datastores)
- [Testing](#testing)
- [Deploying Your App](#deploying-your-app)
- [Viewing Activity Logs](#viewing-activity-logs)
- [Project Structure](#project-structure)
- [Resources](#resources)
---
## Setup
Before getting started, first make sure you have a development workspace where
you have permission to install apps. **Please note that the features in this
project require that the workspace be part of
[a Slack paid plan](https://slack.com/pricing).**
### Install the Slack CLI
To use this sample, you need to install and configure the Slack CLI.
Step-by-step instructions can be found in our
[Quickstart Guide](https://api.slack.com/automation/quickstart).
### Clone the Sample App
Start by cloning this repository:
```zsh
# Clone this project onto your machine
$ slack create my-app -t slack-samples/deno-triage-bot
# Change into the project directory
$ cd my-app
```
## Running Your Project Locally
While building your app, you can see your changes appear in your workspace in
real-time with `slack run`. You'll know an app is the development version if the
name has the string `(local)` appended.
```zsh
# Run app locally
$ slack run
Connected, awaiting events
```
To stop running locally, press ` + C` to end the process.
## Included Workflows
Here is the list of workflows for Triage Bot and steps to create them:
- **Triagebot Help**: Post a private help message in the current channel.
```zsh
$ slack trigger create --trigger-def triggers/help_shortcut_trigger.ts
```
- **Triage**: Post a private triage report for the current channel.
1. create the `private_report_shortcut_trigger` trigger
```zsh
$ slack trigger create --trigger-def triggers/private_report_shortcut_trigger.ts
```
2. Save the shortcut URL with name `private_shortcut` in the `url` datastore
```zsh
$ slack datastore put '{"datastore": "url", "app": "app_id", "item": {"name": "private_shortcut", "url": "shortcut url from step 1"}}'
```
- **Triage Publish**: Post a public triage report for the current channel.
1. create the `public_report_shortcut_trigger` trigger
```zsh
$ slack trigger create --trigger-def triggers/public_report_shortcut_trigger.ts
```
2. Save the shortcut URL with name `public_shortcut` in the `url` datastore
```zsh
$ slack datastore put '{"datastore": "url", "app": "app_id", "item": {"name": "public_shortcut", "url": "shortcut url from step 1"}}'
```
- **Manage Triagebot Configuration**: Manage channel configuration for scheduled
posts and lookback days for triage requests. To get scheduled posts working,
you need to first create `private_report_webhook_trigger` and add the webhook
url to the `url` datastore.
1. create the `private_report_webhook_trigger` trigger
```zsh
$ slack trigger create --trigger-def triggers/private_report_webhook_trigger.ts
```
2. Save the webhook URL with name `private_webhook` in the `url` datastore
```zsh
$ slack datastore put '{"datastore": "url", "app": "app_id", "item": {"name": "private_webhook", "url": "webhook url from step 1"}}'
```
3. Run the following command to create the `post scheduled messages` workflow
```zsh
$ slack trigger create --trigger-def triggers/post_messages_scheduled_trigger.ts
```
4. Run the following command to create the `manage configuration` workflow
```zsh
$ slack trigger create --trigger-def triggers/manage_configuration_shortcut_trigger.ts
```
5. Save the shortcut URL with name `manage_shortcut` in the `url` datastore
```zsh
$ slack datastore put '{"datastore": "url", "app": "app_id", "item": {"name": "manage_shortcut", "url": "shortcut url from step 3"}}'
```
- **Triage by lookback days**: Post a private triage report in the current
channel with the specified lookback days for triage requests. To get this
workflow to work, you need to create `public_report_webhook_trigger` and add
the webhook url to the `url` datastore.
1. create the `public_report_webhook_trigger` trigger
```zsh
$ slack trigger create --trigger-def triggers/public_report_webhook_trigger.ts
```
2. Save the webhook URL with name `public_webhook` in the `url` datastore
```zsh
$ slack datastore put '{"datastore": "url", "app": "app_id", "item": {"name": "public_webhook", "url": "webhook url from step 1"}}'
```
3. Run the following command to enable the `triage by days` workflow
```zsh
$ slack trigger create --trigger-def triggers/triage_by_days_shortcut_trigger.ts
```
4. Save the shortcut URL with name `triage_shortcut` in the `url` datastore
```zsh
$ slack datastore put '{"datastore": "url", "app": "app_id", "item": {"name": "triage_shortcut", "url": "shortcut url from step 3"}}'
```
## Creating Triggers
In the [previous section](#included-workflows) we've created different triggers.
[Triggers](https://api.slack.com/automation/triggers) are what cause workflows
to run. These triggers can be invoked by a user, or automatically as a response
to an event within Slack.
When you `run` or `deploy` your project for the first time, the CLI will prompt
you to create a trigger if one is found in the `triggers/` directory. For any
subsequent triggers added to the application, each must be
[manually added using the `trigger create` command](#manual-trigger-creation).
We were creating triggers manually in
[the Included Workflows section](#included-workflows).
When creating triggers, you must select the workspace and environment that you'd
like to create the trigger in. Each workspace can have a local development
version (denoted by `(local)`), as well as a deployed version. _Triggers created
in a local environment will only be available to use when running the
application locally._
### Link Triggers
A [link trigger](https://api.slack.com/automation/triggers/link) is a type of
trigger that generates a **Shortcut URL** which, when posted in a channel or
added as a bookmark, becomes a link. When clicked, the link trigger will run the
associated workflow.
Link triggers are _unique to each installed version of your app_. This means
that Shortcut URLs will be different across each workspace, as well as between
[locally run](#running-your-project-locally) and
[deployed apps](#deploying-your-app).
With link triggers, after selecting a workspace and environment, the output
provided will include a Shortcut URL. Copy and paste this URL into a channel as
a message, or add it as a bookmark in a channel of the workspace you selected.
Interacting with this link will run the associated workflow.
**Note: triggers won't run the workflow unless the app is either running locally
or deployed!**
### Manual Trigger Creation
To manually create a trigger, use the following command:
```zsh
$ slack trigger create --trigger-def triggers/trigger.ts
```
## Datastores
All datastores can be found in the `/datastores` directory
- `conf` - datastores for channel configurations.
```
{
"channel_id": "C0A1B2C3D",
"lookback_days": "7",
"schedule": "0 9-17 * * *"
}
```
- `url` - datastores for various workflow and webhook URLs.
```
{
"name": "triage_shortcut",
"url": "https://slack.com/shortcuts/unique_identifier"
}
```
- `done_emojis` - ddatastores for emojis that indicate a request is done, in
addition to the default list of emojis.
```
{
"name": "red-x"
}
```
- `in_progress_emojis` - datastores for emojis that indicate a request is
currently being looked at in addition to the default list of emojis.
```
{
"name": "eyes_right"
}
```
- `urgency_emojis` - datastores for emojis that indicate which messages is a
request, with their associated urgency levels. in addition to the default list
of emojis. **Note** that emojis are added in the format of :emoji: instead of
emoji.
```
{
"name": ":white-c:",
"urgency": 2
}
```
For storing data related to your app, datastores offer secure storage on Slack
infrastructure. The use of a datastore requires the
`datastore:write`/`datastore:read` scopes to be present in your manifest.
You may also intereact with datastores using the
[Slack command line interface](https://api.slack.com/automation/cli/commands#datastore).
Interacting datastores using the slack cli is examplified in workflow creations
in [the Included Workflows section](#included-workflows).
## Testing
For an example of how to test a function, see `functions/triage_test.ts`. Test
filenames should be suffixed with `_test`.
Run all tests with `deno test`:
```zsh
$ deno test
```
## Deploying Your App
Once development is complete, deploy the app to Slack infrastructure using
`slack deploy`:
```zsh
$ slack deploy
```
When deploying for the first time, you'll be prompted to
[create a new link trigger](#creating-triggers) for the deployed version of your
app. When that trigger is invoked, the workflow should run just as it did when
developing locally (but without requiring your server to be running).
## Viewing Activity Logs
Activity logs of your application can be viewed live and as they occur with the
following command:
```zsh
$ slack activity --tail
```
## Project Structure
### `.slack/`
Contains `apps.dev.json` and `apps.json`, which include installation details for
development and deployed apps.
### `datastores/`
[Datastores](https://api.slack.com/automation/datastores) securely store data
for your application on Slack infrastructure. Required scopes to use datastores
include `datastore:write` and `datastore:read`.
### `functions/`
[Functions](https://api.slack.com/automation/functions) are reusable building
blocks of automation that accept inputs, perform calculations, and provide
outputs. Functions can be used independently or as steps in workflows.
### `triggers/`
[Triggers](https://api.slack.com/automation/triggers) determine when workflows
are run. A trigger file describes the scenario in which a workflow should be
run, such as a user pressing a button or when a specific event occurs.
### `workflows/`
A [workflow](https://api.slack.com/automation/workflows) is a set of steps
(functions) that are executed in order.
Workflows can be configured to run without user input or they can collect input
by beginning with a [form](https://api.slack.com/automation/forms) before
continuing to the next step.
### `manifest.ts`
The [app manifest](https://api.slack.com/automation/manifest) contains the app's
configuration. This file defines attributes like app name and description.
### `slack.json`
Used by the CLI to interact with the project's SDK dependencies. It contains
script hooks that are executed by the CLI and implemented by the SDK.
## Resources
To learn more about developing automations on Slack, visit the following:
- [Automation Overview](https://api.slack.com/automation)
- [CLI Quick Reference](https://api.slack.com/automation/cli/quick-reference)
- [Samples and Templates](https://api.slack.com/automation/samples)