From 7362cac4ad045dc8ddd7e846c61427c97ecb9213 Mon Sep 17 00:00:00 2001
From: reoring
Date: Wed, 11 Nov 2026 10:57:38 +0900
Subject: [PATCH 1/3] Slack conversation give: shared schema, domain types,
inbound declaration
---
catalog/entry.yaml | 8 ++
cmd/server/internal/domain/peerbonus.go | 1 +
cmd/server/internal/domain/slack.go | 12 +-
cmd/server/internal/domain/slack_give.go | 103 ++++++++++++++++++
.../006_slack_conversation_give.sql | 40 +++++++
5 files changed, 160 insertions(+), 4 deletions(-)
create mode 100644 cmd/server/internal/domain/slack_give.go
create mode 100644 cmd/server/internal/store/migrations/006_slack_conversation_give.sql
diff --git a/catalog/entry.yaml b/catalog/entry.yaml
index 92c0477..c4aa867 100644
--- a/catalog/entry.yaml
+++ b/catalog/entry.yaml
@@ -54,6 +54,14 @@ spec:
installPolicy: Automatic
publicURLEnv: PEERBONUS_DIRECTORY_PUBLIC_URL
urlEnv: PEERBONUS_DIRECTORY_URL
+ inbound:
+ - name: slack
+ path: /slack
+ limits:
+ methods:
+ - POST
+ maxBodyBytes: 65536
+ timeout: 10s
display:
category: collaborate
description: Send points and thanks to colleagues every week; close each month
diff --git a/cmd/server/internal/domain/peerbonus.go b/cmd/server/internal/domain/peerbonus.go
index 7c25ce1..e8fe294 100644
--- a/cmd/server/internal/domain/peerbonus.go
+++ b/cmd/server/internal/domain/peerbonus.go
@@ -48,6 +48,7 @@ type Post struct {
ClapCount, ClapPoints, ClappedByMe int
Clappers []Member
CreatedAt time.Time
+ SlackPermalink *string // the Slack message this post was given from, if any
}
type Clap struct {
ID string
diff --git a/cmd/server/internal/domain/slack.go b/cmd/server/internal/domain/slack.go
index 8babbea..36cc6ba 100644
--- a/cmd/server/internal/domain/slack.go
+++ b/cmd/server/internal/domain/slack.go
@@ -48,10 +48,14 @@ type SlackIntegration struct {
AnnouncePosts bool
DMRecipientOnPost bool
GiveFromSlack bool
- Locale SlackLocale
- LastErrorCode *string
- LastErrorAt *time.Time
- UpdatedAt time.Time
+ // GiveInConversation enables bot mentions and reactions (Events API).
+ GiveInConversation bool
+ MentionPointChoices []int // amounts offered when a mention omits points
+ ReactionRules []SlackReactionRule // ordered; empty = mentions only
+ Locale SlackLocale
+ LastErrorCode *string
+ LastErrorAt *time.Time
+ UpdatedAt time.Time
}
// Delivers reports whether a write transaction must enqueue deliveries of
diff --git a/cmd/server/internal/domain/slack_give.go b/cmd/server/internal/domain/slack_give.go
new file mode 100644
index 0000000..a225532
--- /dev/null
+++ b/cmd/server/internal/domain/slack_give.go
@@ -0,0 +1,103 @@
+package domain
+
+import (
+ "errors"
+ "strings"
+ "time"
+)
+
+// Limits of giving inside a Slack conversation (design reaction-give §2).
+const (
+ SlackMaxReactionRules = 8
+ SlackMaxMentionRecipients = 5
+ SlackMaxPointChoices = 5
+ SlackPendingGiveTTL = 24 * time.Hour
+)
+
+var (
+ // ErrSlackPendingGiveGone: the pending give expired, was used, or belongs to someone else.
+ ErrSlackPendingGiveGone = errors.New("slack_pending_give_gone")
+)
+
+// SlackReactionRule maps one emoji to the points a reaction gives (R11).
+// Emoji is normalized by NormalizeSlackEmoji. ValueKey is an optional Program value.
+type SlackReactionRule struct {
+ Emoji string
+ Points int
+ ValueKey *string
+}
+
+// SlackGiveSource identifies the Slack message a give came from (RL2).
+// Emoji is empty for a mention.
+type SlackGiveSource struct {
+ ChannelID, MessageTS string
+ Emoji string
+ Permalink *string
+}
+
+// SlackPendingGive is a mention without points, waiting for the sender to
+// choose an amount (R8). It is usable once, only by SenderID, until ExpiresAt.
+type SlackPendingGive struct {
+ ID, ChannelID, MessageTS string
+ ThreadTS *string
+ SenderID string
+ RecipientIDs []string
+ Message string
+ ExpiresAt time.Time
+}
+
+// NormalizeSlackEmoji returns the bare emoji name: no colons, no skin-tone
+// modifier ("+1::skin-tone-3" and ":+1:" both become "+1"), lower case.
+func NormalizeSlackEmoji(name string) string {
+ name = strings.ToLower(strings.TrimSpace(name))
+ if i := strings.Index(name, "::"); i >= 0 {
+ name = name[:i]
+ }
+ return strings.Trim(name, ":")
+}
+
+// ValidateSlackReactionRules expects normalized emoji names. Points are
+// bounded by the Program's current maximum; value keys must exist in it.
+func ValidateSlackReactionRules(rules []SlackReactionRule, program Program) error {
+ if len(rules) > SlackMaxReactionRules {
+ return &ValidationError{Field: "reactionRules", Msg: "must contain at most 8 rules"}
+ }
+ seen := make(map[string]bool, len(rules))
+ for _, rule := range rules {
+ if rule.Emoji == "" || len(rule.Emoji) > 100 || strings.ContainsAny(rule.Emoji, ": \t\n") {
+ return &ValidationError{Field: "reactionRules", Msg: "emoji must be a Slack emoji name without colons"}
+ }
+ if seen[rule.Emoji] {
+ return &ValidationError{Field: "reactionRules", Msg: "emoji must be unique"}
+ }
+ seen[rule.Emoji] = true
+ if rule.Points < 1 || rule.Points > program.MaxPointsPerPost {
+ return &ValidationError{Field: "reactionRules", Msg: "points must be between 1 and the maximum per post"}
+ }
+ if rule.ValueKey != nil {
+ known := false
+ for _, value := range program.Values {
+ known = known || value.Key == *rule.ValueKey
+ }
+ if !known {
+ return ErrUnknownValue
+ }
+ }
+ }
+ return nil
+}
+
+// ValidateMentionPointChoices bounds the amounts offered when a mention omits points.
+func ValidateMentionPointChoices(choices []int, program Program) error {
+ if len(choices) < 1 || len(choices) > SlackMaxPointChoices {
+ return &ValidationError{Field: "mentionPointChoices", Msg: "must contain 1 to 5 amounts"}
+ }
+ seen := make(map[int]bool, len(choices))
+ for _, points := range choices {
+ if points < 1 || points > program.MaxPointsPerPost || seen[points] {
+ return &ValidationError{Field: "mentionPointChoices", Msg: "amounts must be unique and between 1 and the maximum per post"}
+ }
+ seen[points] = true
+ }
+ return nil
+}
diff --git a/cmd/server/internal/store/migrations/006_slack_conversation_give.sql b/cmd/server/internal/store/migrations/006_slack_conversation_give.sql
new file mode 100644
index 0000000..d86097e
--- /dev/null
+++ b/cmd/server/internal/store/migrations/006_slack_conversation_give.sql
@@ -0,0 +1,40 @@
+-- Giving inside a Slack conversation: bot mentions and admin-chosen reactions
+-- (design: nexus features/peerbonus-slack/reaction-give.md §3).
+ALTER TABLE slack_integration ADD COLUMN give_in_conversation boolean NOT NULL DEFAULT false;
+ALTER TABLE slack_integration ADD COLUMN mention_point_choices integer[] NOT NULL DEFAULT '{10,30,50}';
+
+CREATE TABLE slack_reaction_rules (
+ emoji text PRIMARY KEY,
+ points integer NOT NULL CHECK (points > 0),
+ value_key text,
+ position smallint NOT NULL
+);
+
+-- RL2: one give per (message, sender, recipient, means). emoji = '' is a mention.
+-- The row outlives idempotency_keys, so removing and re-adding a reaction never gives twice.
+CREATE TABLE slack_gives (
+ channel_id text NOT NULL,
+ message_ts text NOT NULL,
+ sender_id text NOT NULL REFERENCES members(id),
+ recipient_id text NOT NULL REFERENCES members(id),
+ emoji text NOT NULL DEFAULT '',
+ post_id text NOT NULL REFERENCES posts(id),
+ clap_id text REFERENCES claps(id),
+ permalink text,
+ created_at timestamptz NOT NULL,
+ PRIMARY KEY (channel_id, message_ts, sender_id, recipient_id, emoji)
+);
+CREATE INDEX slack_gives_post ON slack_gives (post_id);
+
+-- R8: a mention without points waits for the sender to pick an amount.
+CREATE TABLE slack_pending_gives (
+ id text PRIMARY KEY,
+ channel_id text NOT NULL,
+ message_ts text NOT NULL,
+ thread_ts text,
+ sender_id text NOT NULL REFERENCES members(id),
+ recipient_ids text[] NOT NULL,
+ message text NOT NULL,
+ expires_at timestamptz NOT NULL,
+ UNIQUE (channel_id, message_ts)
+);
From ee1196ab77eda4428d8674ab0bd2caab57941e6f Mon Sep 17 00:00:00 2001
From: reoring
Date: Wed, 11 Nov 2026 11:14:49 +0900
Subject: [PATCH 2/3] Give inside a Slack conversation: bot mentions, amount
prompt, and reaction rules
---
README.md | 7 +-
cmd/server/internal/api/api.go | 4 +
cmd/server/internal/api/api_test.go | 52 ++
cmd/server/internal/api/openapi.json | 40 +-
cmd/server/internal/api/slack_admin.go | 119 +++-
cmd/server/internal/api/slack_admin_test.go | 166 +++++-
cmd/server/internal/api/types.go | 48 +-
cmd/server/internal/slack/client.go | 70 ++-
cmd/server/internal/slack/client_test.go | 175 +++++-
.../slack/slacktest/cmd/fakeslack/main.go | 14 +-
.../slacktest/cmd/fakeslack/main_test.go | 23 +-
cmd/server/internal/slack/slacktest/server.go | 79 ++-
.../internal/slack/slacktest/server_test.go | 102 +++-
cmd/server/internal/slackinbound/commands.go | 11 +-
cmd/server/internal/slackinbound/events.go | 296 ++++++++++
.../internal/slackinbound/events_test.go | 508 ++++++++++++++++++
cmd/server/internal/slackinbound/handler.go | 72 ++-
.../internal/slackinbound/handler_test.go | 93 +++-
cmd/server/internal/slackinbound/http_test.go | 2 +-
.../internal/slackinbound/interactions.go | 64 ++-
cmd/server/internal/slackinbound/mention.go | 50 ++
.../internal/slackinbound/mention_test.go | 39 ++
cmd/server/internal/slackinbound/pending.go | 170 ++++++
.../internal/slackinbound/pending_test.go | 264 +++++++++
cmd/server/internal/slackinbound/signature.go | 14 +-
.../slackinboundtest/signature.go | 12 +
cmd/server/internal/store/posts.go | 7 +-
cmd/server/internal/store/slack.go | 53 +-
cmd/server/internal/store/slack_give.go | 206 +++++++
cmd/server/internal/store/slack_give_test.go | 329 ++++++++++++
cmd/server/internal/store/writes.go | 166 ++++--
cmd/server/peerbonus.go | 2 +-
web/src/api/peerbonus.test.ts | 1 +
web/src/api/peerbonus.ts | 22 +-
web/src/copy/posts.ts | 1 +
web/src/copy/slack.ts | 83 ++-
web/src/dev/mock-admin.test.ts | 56 +-
web/src/dev/mock-admin.ts | 82 ++-
web/src/dev/mock-peerbonus.test.ts | 10 +-
web/src/dev/mock-peerbonus.ts | 9 +-
.../admin/slack/conversation-settings.tsx | 383 +++++++++++++
web/src/features/admin/slack/manifest.test.ts | 9 +-
web/src/features/admin/slack/manifest.ts | 16 +-
.../features/admin/slack/slack-form.test.ts | 128 ++++-
web/src/features/admin/slack/slack-form.ts | 166 +++++-
web/src/features/admin/slack/slack-page.tsx | 26 +-
.../features/admin/slack/slack-settings.tsx | 6 +-
.../features/admin/slack/slack-state.test.ts | 37 +-
web/src/features/admin/slack/slack-state.ts | 11 +
web/src/features/posts/post-card.test.tsx | 11 +
web/src/features/posts/post-card.tsx | 19 +-
web/src/routes/admin-pages.tsx | 2 +
52 files changed, 4054 insertions(+), 281 deletions(-)
create mode 100644 cmd/server/internal/slackinbound/events.go
create mode 100644 cmd/server/internal/slackinbound/events_test.go
create mode 100644 cmd/server/internal/slackinbound/mention.go
create mode 100644 cmd/server/internal/slackinbound/mention_test.go
create mode 100644 cmd/server/internal/slackinbound/pending.go
create mode 100644 cmd/server/internal/slackinbound/pending_test.go
create mode 100644 cmd/server/internal/store/slack_give.go
create mode 100644 cmd/server/internal/store/slack_give_test.go
create mode 100644 web/src/features/admin/slack/conversation-settings.tsx
diff --git a/README.md b/README.md
index 19afca8..dfb8cb6 100644
--- a/README.md
+++ b/README.md
@@ -6,8 +6,11 @@ statements. The Go server serves the React SPA, `/api/peerbonus/v1/*`, `/config`
`/launcher`, `/healthz`, `/readyz`, and `/releasez` from one origin. PostgreSQL
stores application data; Directory remains a separate app called over HTTP.
The SPA uses the session cookie behind the OIDC edge and never handles tokens.
-Optional Slack credentials enable announcements, direct messages, and inbound
-commands and interactions.
+Optional Slack credentials enable announcements, direct messages, the
+`/peerbonus` command, and giving inside a conversation: mentioning the bot
+(`@Peer Bonus @recipient 30 message`; the bot asks for the amount when it is
+omitted) or adding an admin-chosen reaction. Slack reaches the server through
+the `slack` inbound endpoint declared in `catalog/entry.yaml` (`/slack/*`).
## Develop
diff --git a/cmd/server/internal/api/api.go b/cmd/server/internal/api/api.go
index 5be3455..6e1bb2f 100644
--- a/cmd/server/internal/api/api.go
+++ b/cmd/server/internal/api/api.go
@@ -38,6 +38,7 @@ type API struct {
slack slackAdminClient
slackStore slackAdminStore
slackSigningSecretConfigured bool
+ slackInbound *slackInboundClient
slackChannelsMu sync.Mutex
slackChannels []slack.Channel
slackChannelsExpires time.Time
@@ -58,6 +59,9 @@ func New(database *store.Store, auth *identity.Authenticator, upstream *platform
if slackOptions.Client != nil {
a.slack = slackOptions.Client
}
+ if slackOptions.PlatformAPIURL != "" {
+ a.slackInbound = newSlackInboundClient(slackOptions.PlatformAPIURL, upstream.ProjectID, auth.HTTPClient().Transport)
+ }
a.mux.HandleFunc("GET /api/peerbonus/v1/openapi.json", a.openapi)
a.route("GET /api/peerbonus/v1/me", false, true, a.me)
a.route("GET /api/peerbonus/v1/program", false, false, a.program)
diff --git a/cmd/server/internal/api/api_test.go b/cmd/server/internal/api/api_test.go
index f7363c8..1c41a2f 100644
--- a/cmd/server/internal/api/api_test.go
+++ b/cmd/server/internal/api/api_test.go
@@ -704,3 +704,55 @@ func TestV2InputAndResponseContractWithoutDatabase(t *testing.T) {
require.NotNil(t, insights.TopSenders)
require.NotNil(t, a.renderParticipation(domain.Participation{}).Items)
}
+
+func TestSlackConversationPostJSON(t *testing.T) {
+ a := &API{}
+ for _, permalink := range []*string{nil, new("https://acme.slack.com/archives/C123/p123456")} {
+ body, err := json.Marshal(a.renderPost(domain.Post{ID: "post", SlackPermalink: permalink}))
+ require.NoError(t, err)
+ var result map[string]json.RawMessage
+ require.NoError(t, json.Unmarshal(body, &result))
+ require.Contains(t, result, "slackPermalink")
+ expected, err := json.Marshal(permalink)
+ require.NoError(t, err)
+ require.JSONEq(t, string(expected), string(result["slackPermalink"]))
+ }
+}
+
+func TestSlackConversationOpenAPI(t *testing.T) {
+ type schema struct {
+ Type string `json:"type"`
+ Ref string `json:"$ref"`
+ Nullable bool `json:"nullable"`
+ Required []string `json:"required"`
+ Properties map[string]*schema `json:"properties"`
+ Items *schema `json:"items"`
+ MinItems int `json:"minItems"`
+ MaxItems int `json:"maxItems"`
+ }
+ var document struct {
+ Components struct {
+ Schemas map[string]*schema `json:"schemas"`
+ } `json:"components"`
+ }
+ require.NoError(t, json.Unmarshal(openapiDocument, &document))
+ schemas := document.Components.Schemas
+ settings := schemas["SlackIntegration"].Properties["settings"]
+ patch := schemas["SlackSettingsPatch"]
+ for _, field := range []string{"giveInConversation", "mentionPointChoices", "reactionRules"} {
+ require.Contains(t, settings.Required, field)
+ require.Contains(t, settings.Properties, field)
+ require.Contains(t, patch.Properties, field)
+ }
+ require.Equal(t, "boolean", patch.Properties["giveInConversation"].Type)
+ require.Equal(t, "#/components/schemas/SlackMentionPointChoices", patch.Properties["mentionPointChoices"].Ref)
+ require.Equal(t, 1, schemas["SlackMentionPointChoices"].MinItems)
+ require.Equal(t, 5, schemas["SlackMentionPointChoices"].MaxItems)
+ require.Equal(t, 8, patch.Properties["reactionRules"].MaxItems)
+ require.Equal(t, "#/components/schemas/SlackReactionRule", patch.Properties["reactionRules"].Items.Ref)
+ require.ElementsMatch(t, []string{"emoji", "points"}, schemas["SlackReactionRule"].Required)
+ require.True(t, schemas["SlackReactionRule"].Properties["valueKey"].Nullable)
+ require.Contains(t, schemas["Post"].Required, "slackPermalink")
+ require.Equal(t, "string", schemas["Post"].Properties["slackPermalink"].Type)
+ require.True(t, schemas["Post"].Properties["slackPermalink"].Nullable)
+}
diff --git a/cmd/server/internal/api/openapi.json b/cmd/server/internal/api/openapi.json
index 44e42fb..79c034a 100644
--- a/cmd/server/internal/api/openapi.json
+++ b/cmd/server/internal/api/openapi.json
@@ -1040,7 +1040,7 @@
"get": {
"operationId": "getAdminSlack",
"summary": "Read Slack integration settings and delivery health",
- "description": "Team Admin only. Credentials expose presence booleans, never secret values. State is unconfigured without a client, configured without a verified workspace, team_changed when lastError.code is team_changed, otherwise connected. Inbound is null until platform inbound discovery is available.",
+ "description": "Team Admin only. Credentials expose presence booleans, never secret values. State is unconfigured without a client, configured without a verified workspace, team_changed when lastError.code is team_changed, otherwise connected. Inbound is discovered from the Platform API peerbonus-slack endpoint using the viewer's bearer: absent returns null; found returns its URL, generation-aware ready flag and Ready condition reason. Discovery failure returns {url:null,ready:false,reason:\"platform_unavailable\"} without failing this response.",
"x-appthrust-link": true,
"responses": {
"200": {
@@ -1056,7 +1056,7 @@
"patch": {
"operationId": "patchAdminSlack",
"summary": "Update Slack settings",
- "description": "Team Admin only. Channel and flag changes require connected state. Channel IDs must resolve to a public channel; null clears the channel. announcePosts requires a channel. giveFromSlack requires a configured signing secret. Locale may be changed before connecting.",
+ "description": "Team Admin only. Channel and flag changes require connected state (409 slack_not_connected). Channel IDs must resolve to a public channel; null clears the channel. announcePosts requires a channel. Enabling giveFromSlack or giveInConversation requires a configured signing secret (409 slack_signing_secret_missing). Mention point choices contain 1-5 unique amounts. Reaction rules replace all existing rules, preserve order and contain at most 8 unique normalized emoji names. Emoji names are lowercased and stripped of surrounding colons and skin-tone modifiers. Amounts must be positive and no greater than the current Program maxPointsPerPost; non-null valueKey must exist in the current Program. Locale, point choices and rules may be changed before connecting.",
"requestBody": {
"required": true,
"content": {"application/json": {"schema": {"$ref": "#/components/schemas/SlackSettingsPatch"}}}
@@ -1067,7 +1067,7 @@
"content": {"application/json": {"schema": {"$ref": "#/components/schemas/SlackIntegration"}}}
},
"400": {
- "description": "invalid_request: invalid channel, missing announce channel, or invalid locale",
+ "description": "invalid_request: invalid channel, missing announce channel, invalid locale, invalid point choices or invalid reaction rules; unknown_value: a rule valueKey is absent from the current Program",
"content": {"application/json": {"schema": {"$ref": "#/components/schemas/Error"}}}
},
"409": {
@@ -1245,7 +1245,7 @@
},
"settings": {
"type": "object",
- "required": ["announceChannel", "announcePosts", "dmRecipientOnPost", "giveFromSlack", "locale"],
+ "required": ["announceChannel", "announcePosts", "dmRecipientOnPost", "giveFromSlack", "giveInConversation", "mentionPointChoices", "reactionRules", "locale"],
"properties": {
"announceChannel": {
"type": "object",
@@ -1256,12 +1256,16 @@
"announcePosts": {"type": "boolean"},
"dmRecipientOnPost": {"type": "boolean"},
"giveFromSlack": {"type": "boolean"},
+ "giveInConversation": {"type": "boolean"},
+ "mentionPointChoices": {"$ref": "#/components/schemas/SlackMentionPointChoices"},
+ "reactionRules": {"type": "array", "maxItems": 8, "items": {"$ref": "#/components/schemas/SlackReactionRule"}},
"locale": {"type": "string", "enum": ["ja", "en"]}
}
},
"inbound": {
"type": "object",
"nullable": true,
+ "description": "Null when discovery is not configured or the endpoint is absent. Platform failures return url=null, ready=false and reason=platform_unavailable.",
"required": ["url", "ready", "reason"],
"properties": {
"url": {"type": "string", "nullable": true},
@@ -1282,6 +1286,25 @@
}
}
},
+ "SlackMentionPointChoices": {
+ "type": "array",
+ "description": "Unique amounts offered when a mention omits points, each no greater than the current Program maxPointsPerPost when patched.",
+ "minItems": 1,
+ "maxItems": 5,
+ "uniqueItems": true,
+ "items": {"type": "integer", "minimum": 1},
+ "example": [10, 30, 50]
+ },
+ "SlackReactionRule": {
+ "type": "object",
+ "additionalProperties": false,
+ "required": ["emoji", "points"],
+ "properties": {
+ "emoji": {"type": "string", "description": "Normalized to lowercase without colons or skin-tone modifiers; the resulting name must be unique across rules and contain 1-100 characters without whitespace.", "example": "pb-10"},
+ "points": {"type": "integer", "minimum": 1, "description": "No greater than the current Program maxPointsPerPost when patched."},
+ "valueKey": {"type": "string", "nullable": true, "description": "Optional key of a current Program value; null assigns no value."}
+ }
+ },
"SlackSettingsPatch": {
"type": "object",
"additionalProperties": false,
@@ -1290,6 +1313,9 @@
"announcePosts": {"type": "boolean"},
"dmRecipientOnPost": {"type": "boolean"},
"giveFromSlack": {"type": "boolean"},
+ "giveInConversation": {"type": "boolean", "description": "Requires connected state; enabling also requires the signing secret."},
+ "mentionPointChoices": {"$ref": "#/components/schemas/SlackMentionPointChoices"},
+ "reactionRules": {"type": "array", "maxItems": 8, "description": "Replaces all rules in the supplied order; emoji names must be unique after normalization.", "items": {"$ref": "#/components/schemas/SlackReactionRule"}},
"locale": {"type": "string", "enum": ["ja", "en"]}
}
},
@@ -1722,6 +1748,11 @@
"message": {
"type": "string"
},
+ "slackPermalink": {
+ "type": "string",
+ "nullable": true,
+ "description": "Original Slack message URL for a conversation give; null for posts without a recorded permalink."
+ },
"values": {
"type": "array",
"items": {
@@ -1764,6 +1795,7 @@
"recipient",
"points",
"message",
+ "slackPermalink",
"values",
"clapCount",
"clapPoints",
diff --git a/cmd/server/internal/api/slack_admin.go b/cmd/server/internal/api/slack_admin.go
index 2c63ac9..1508304 100644
--- a/cmd/server/internal/api/slack_admin.go
+++ b/cmd/server/internal/api/slack_admin.go
@@ -4,6 +4,9 @@ import (
"context"
"encoding/json"
"errors"
+ "io"
+ "net/http"
+ "net/url"
"strings"
"time"
@@ -13,10 +16,11 @@ import (
"github.com/appthrust/peerbonus/cmd/server/internal/store"
)
-// SlackOptions contains process-wide credentials, never persisted by the API.
+// SlackOptions contains process-wide credentials and platform discovery configuration.
type SlackOptions struct {
Client *slack.Client
SigningSecretConfigured bool
+ PlatformAPIURL string
}
type slackAdminClient interface {
@@ -26,6 +30,7 @@ type slackAdminClient interface {
}
type slackAdminStore interface {
+ Program(context.Context) (domain.Program, error)
SlackIntegration(context.Context) (domain.SlackIntegration, error)
UpdateSlackSettings(context.Context, store.SlackSettingsPatch, time.Time) (domain.SlackIntegration, error)
FixSlackWorkspace(context.Context, domain.SlackWorkspace, bool, time.Time) (domain.SlackIntegration, error)
@@ -34,6 +39,70 @@ type slackAdminStore interface {
SlackDeliveryStats(context.Context, time.Time) (domain.SlackDeliveryStats, error)
}
+type slackInboundClient struct {
+ url string
+ http *http.Client
+}
+
+func newSlackInboundClient(origin, projectID string, transport http.RoundTripper) *slackInboundClient {
+ if transport == nil {
+ transport = http.DefaultTransport.(*http.Transport).Clone()
+ }
+ return &slackInboundClient{
+ url: strings.TrimRight(origin, "/") + "/api/v1/projects/" + url.PathEscape(projectID) + "/inbound-endpoints/peerbonus-slack",
+ http: &http.Client{Transport: transport, Timeout: 10 * time.Second, CheckRedirect: func(*http.Request, []*http.Request) error {
+ return http.ErrUseLastResponse
+ }},
+ }
+}
+
+func (a *API) discoverSlackInbound(s *request) *slackInboundResponse {
+ if a.slackInbound == nil {
+ return nil
+ }
+ r, err := http.NewRequestWithContext(s.r.Context(), http.MethodGet, a.slackInbound.url, nil)
+ if err != nil {
+ return &slackInboundResponse{Reason: new("platform_unavailable")}
+ }
+ r.Header.Set("Authorization", s.bearer)
+ r.Header.Set("Accept", "application/json")
+ response, err := a.slackInbound.http.Do(r)
+ if err != nil {
+ return &slackInboundResponse{Reason: new("platform_unavailable")}
+ }
+ defer response.Body.Close()
+ if response.StatusCode == http.StatusNotFound {
+ return nil
+ }
+ if response.StatusCode != http.StatusOK {
+ return &slackInboundResponse{Reason: new("platform_unavailable")}
+ }
+ var endpoint struct {
+ URL string `json:"url"`
+ Ready bool `json:"ready"`
+ Conditions []struct {
+ Type string `json:"type"`
+ Reason string `json:"reason"`
+ } `json:"conditions"`
+ }
+ if err := json.NewDecoder(io.LimitReader(response.Body, 8<<20)).Decode(&endpoint); err != nil {
+ return &slackInboundResponse{Reason: new("platform_unavailable")}
+ }
+ result := &slackInboundResponse{Ready: endpoint.Ready}
+ if endpoint.URL != "" {
+ result.URL = &endpoint.URL
+ }
+ for _, condition := range endpoint.Conditions {
+ if condition.Type == "Ready" {
+ if condition.Reason != "" {
+ result.Reason = &condition.Reason
+ }
+ break
+ }
+ }
+ return result
+}
+
type slackAPIError struct {
Status int `json:"-"`
Code string `json:"error"`
@@ -81,21 +150,31 @@ func (a *API) slackResponse(s *request, integration domain.SlackIntegration) (an
result.Settings.AnnouncePosts = integration.AnnouncePosts
result.Settings.DMRecipientOnPost = integration.DMRecipientOnPost
result.Settings.GiveFromSlack = integration.GiveFromSlack
+ result.Settings.GiveInConversation = integration.GiveInConversation
+ result.Settings.MentionPointChoices = integration.MentionPointChoices
+ result.Settings.ReactionRules = make([]slackReactionRule, 0, len(integration.ReactionRules))
+ for _, rule := range integration.ReactionRules {
+ result.Settings.ReactionRules = append(result.Settings.ReactionRules, slackReactionRule(rule))
+ }
result.Settings.Locale = integration.Locale
if integration.LastErrorCode != nil {
result.LastError = &slackLastErrorResponse{Code: *integration.LastErrorCode, At: integration.LastErrorAt}
}
result.Deliveries = slackDeliveryStatsResponse(stats)
+ result.Inbound = a.discoverSlackInbound(s)
return result, 200, nil
}
func (a *API) patchSlack(s *request) (any, int, error) {
var input struct {
- AnnounceChannelID json.RawMessage `json:"announceChannelId"`
- AnnouncePosts *bool `json:"announcePosts"`
- DMRecipientOnPost *bool `json:"dmRecipientOnPost"`
- GiveFromSlack *bool `json:"giveFromSlack"`
- Locale *domain.SlackLocale `json:"locale"`
+ AnnounceChannelID json.RawMessage `json:"announceChannelId"`
+ AnnouncePosts *bool `json:"announcePosts"`
+ DMRecipientOnPost *bool `json:"dmRecipientOnPost"`
+ GiveFromSlack *bool `json:"giveFromSlack"`
+ GiveInConversation *bool `json:"giveInConversation"`
+ MentionPointChoices *[]int `json:"mentionPointChoices"`
+ ReactionRules *[]slackReactionRule `json:"reactionRules"`
+ Locale *domain.SlackLocale `json:"locale"`
}
if err := decode(s, &input); err != nil {
return nil, 0, err
@@ -107,13 +186,35 @@ func (a *API) patchSlack(s *request) (any, int, error) {
if err != nil {
return nil, 0, err
}
- if (input.AnnounceChannelID != nil || input.AnnouncePosts != nil || input.DMRecipientOnPost != nil || input.GiveFromSlack != nil) && a.slackState(integration) != domain.SlackStateConnected {
+ if (input.AnnounceChannelID != nil || input.AnnouncePosts != nil || input.DMRecipientOnPost != nil || input.GiveFromSlack != nil || input.GiveInConversation != nil) && a.slackState(integration) != domain.SlackStateConnected {
return nil, 0, slackNotConnected()
}
- if input.GiveFromSlack != nil && *input.GiveFromSlack && !a.slackSigningSecretConfigured {
+ if ((input.GiveFromSlack != nil && *input.GiveFromSlack) || (input.GiveInConversation != nil && *input.GiveInConversation)) && !a.slackSigningSecretConfigured {
return nil, 0, httpx.Fail(409, "slack_signing_secret_missing", "Configure the Slack signing secret before enabling Slack input")
}
- patch := store.SlackSettingsPatch{AnnouncePosts: input.AnnouncePosts, DMRecipientOnPost: input.DMRecipientOnPost, GiveFromSlack: input.GiveFromSlack, Locale: input.Locale}
+ patch := store.SlackSettingsPatch{AnnouncePosts: input.AnnouncePosts, DMRecipientOnPost: input.DMRecipientOnPost, GiveFromSlack: input.GiveFromSlack, GiveInConversation: input.GiveInConversation, MentionPointChoices: input.MentionPointChoices, Locale: input.Locale}
+ if input.MentionPointChoices != nil || input.ReactionRules != nil {
+ program, err := a.slackStore.Program(s.r.Context())
+ if err != nil {
+ return nil, 0, err
+ }
+ if input.MentionPointChoices != nil {
+ if err := domain.ValidateMentionPointChoices(*input.MentionPointChoices, program); err != nil {
+ return nil, 0, err
+ }
+ }
+ if input.ReactionRules != nil {
+ rules := make([]domain.SlackReactionRule, len(*input.ReactionRules))
+ for i, rule := range *input.ReactionRules {
+ rules[i] = domain.SlackReactionRule(rule)
+ rules[i].Emoji = domain.NormalizeSlackEmoji(rule.Emoji)
+ }
+ if err := domain.ValidateSlackReactionRules(rules, program); err != nil {
+ return nil, 0, err
+ }
+ patch.ReactionRules = &rules
+ }
+ }
if input.AnnounceChannelID != nil {
var id *string
if err := json.Unmarshal(input.AnnounceChannelID, &id); err != nil || (id != nil && *id == "") {
diff --git a/cmd/server/internal/api/slack_admin_test.go b/cmd/server/internal/api/slack_admin_test.go
index 8a6da16..8b659cf 100644
--- a/cmd/server/internal/api/slack_admin_test.go
+++ b/cmd/server/internal/api/slack_admin_test.go
@@ -43,6 +43,8 @@ func (f *fakeSlackAdminClient) PostMessage(_ context.Context, channel string, me
type fakeSlackAdminStore struct {
integration domain.SlackIntegration
+ program domain.Program
+ programErr error
stats domain.SlackDeliveryStats
deliveries []domain.SlackDelivery
listState string
@@ -53,6 +55,9 @@ type fakeSlackAdminStore struct {
func (f *fakeSlackAdminStore) SlackIntegration(context.Context) (domain.SlackIntegration, error) {
return f.integration, nil
}
+func (f *fakeSlackAdminStore) Program(context.Context) (domain.Program, error) {
+ return f.program, f.programErr
+}
func (f *fakeSlackAdminStore) UpdateSlackSettings(_ context.Context, patch store.SlackSettingsPatch, now time.Time) (domain.SlackIntegration, error) {
f.updates++
if patch.AnnounceChannel != nil {
@@ -67,6 +72,15 @@ func (f *fakeSlackAdminStore) UpdateSlackSettings(_ context.Context, patch store
if patch.GiveFromSlack != nil {
f.integration.GiveFromSlack = *patch.GiveFromSlack
}
+ if patch.GiveInConversation != nil {
+ f.integration.GiveInConversation = *patch.GiveInConversation
+ }
+ if patch.MentionPointChoices != nil {
+ f.integration.MentionPointChoices = *patch.MentionPointChoices
+ }
+ if patch.ReactionRules != nil {
+ f.integration.ReactionRules = *patch.ReactionRules
+ }
if patch.Locale != nil {
f.integration.Locale = *patch.Locale
}
@@ -101,7 +115,10 @@ func (f *fakeSlackAdminStore) ListSlackDeliveries(_ context.Context, state strin
func newSlackAdminTest() (*API, *fakeSlackAdminStore, *fakeSlackAdminClient) {
now := time.Date(2026, 10, 20, 1, 0, 0, 0, time.UTC)
- db := &fakeSlackAdminStore{integration: domain.SlackIntegration{Locale: domain.SlackLocaleJA, DMRecipientOnPost: true}}
+ db := &fakeSlackAdminStore{
+ integration: domain.SlackIntegration{Locale: domain.SlackLocaleJA, DMRecipientOnPost: true, MentionPointChoices: []int{10, 30, 50}},
+ program: domain.Program{MaxPointsPerPost: 40, Values: []domain.Value{{Key: "care"}}},
+ }
client := &fakeSlackAdminClient{
info: slack.AuthInfo{TeamID: "T123", TeamName: "Acme", BotUserID: "UBOT", EnterpriseID: "E123"},
channels: []slack.Channel{{ID: "C1", Name: "general", IsMember: true}, {ID: "C2", Name: "gifts"}, {ID: "C3", Name: "random", IsMember: true}},
@@ -112,8 +129,9 @@ func newSlackAdminTest() (*API, *fakeSlackAdminStore, *fakeSlackAdminClient) {
func slackAdminCall(t *testing.T, a *API, fn endpoint, method, path, body string, status int) []byte {
t.Helper()
r := httptest.NewRequest(method, "/api/peerbonus/v1"+path, strings.NewReader(body))
+ r.Header.Set("Authorization", "Bearer admin-viewer")
w := httptest.NewRecorder()
- s := &request{r: r, w: w, now: a.now(), member: domain.Member{ID: "admin"}, access: platformclient.ProjectAccess{Roles: platformclient.Roles{IsConsoleAdmin: true}}}
+ s := &request{r: r, w: w, bearer: r.Header.Get("Authorization"), now: a.now(), member: domain.Member{ID: "admin"}, access: platformclient.ProjectAccess{Roles: platformclient.Roles{IsConsoleAdmin: true}}}
result, code, err := a.admin(fn)(s)
if err != nil {
writeError(w, err)
@@ -380,3 +398,147 @@ func TestSlackAdminRoutesWithDatabase(t *testing.T) {
require.Equal(t, post.ID, item.PostID)
}
}
+
+func TestSlackConversationSettings(t *testing.T) {
+ t.Run("normalizes and replaces settings", func(t *testing.T) {
+ a, db, _ := newSlackAdminTest()
+ db.integration.Workspace = &domain.SlackWorkspace{TeamID: "T123"}
+ a.slackSigningSecretConfigured = true
+ body := slackAdminCall(t, a, a.patchSlack, "PATCH", "/admin/slack", `{"giveInConversation":true,"mentionPointChoices":[10,40],"reactionRules":[{"emoji":":PB-10:","points":10,"valueKey":null},{"emoji":":CARE:","points":40,"valueKey":"care"}]}`, 200)
+ require.True(t, db.integration.GiveInConversation)
+ require.Equal(t, []int{10, 40}, db.integration.MentionPointChoices)
+ require.Equal(t, []domain.SlackReactionRule{{Emoji: "pb-10", Points: 10}, {Emoji: "care", Points: 40, ValueKey: new("care")}}, db.integration.ReactionRules)
+ for _, response := range [][]byte{body, slackAdminCall(t, a, a.adminSlack, "GET", "/admin/slack", "", 200)} {
+ var result struct {
+ Settings json.RawMessage `json:"settings"`
+ }
+ require.NoError(t, json.Unmarshal(response, &result))
+ require.JSONEq(t, `{"announceChannel":null,"announcePosts":false,"dmRecipientOnPost":true,"giveFromSlack":false,"giveInConversation":true,"mentionPointChoices":[10,40],"reactionRules":[{"emoji":"pb-10","points":10,"valueKey":null},{"emoji":"care","points":40,"valueKey":"care"}],"locale":"ja"}`, string(result.Settings))
+ }
+ a.slackSigningSecretConfigured = false
+ body = slackAdminCall(t, a, a.patchSlack, "PATCH", "/admin/slack", `{"giveInConversation":false,"reactionRules":[]}`, 200)
+ require.False(t, db.integration.GiveInConversation)
+ require.Empty(t, db.integration.ReactionRules)
+ require.Contains(t, string(body), `"reactionRules":[]`)
+ require.Equal(t, []int{10, 40}, db.integration.MentionPointChoices)
+ })
+
+ for _, tc := range []struct {
+ name, body, code string
+ connected bool
+ status int
+ }{
+ {"nine rules", `{"reactionRules":[{"emoji":"a","points":1},{"emoji":"b","points":1},{"emoji":"c","points":1},{"emoji":"d","points":1},{"emoji":"e","points":1},{"emoji":"f","points":1},{"emoji":"g","points":1},{"emoji":"h","points":1},{"emoji":"i","points":1}]}`, "invalid_request", true, 400},
+ {"duplicate normalized emoji", `{"reactionRules":[{"emoji":":PB-10:","points":10},{"emoji":"pb-10","points":10}]}`, "invalid_request", true, 400},
+ {"rule above current maximum", `{"reactionRules":[{"emoji":"pb-50","points":41}]}`, "invalid_request", true, 400},
+ {"zero rule points", `{"reactionRules":[{"emoji":"pb-0","points":0}]}`, "invalid_request", true, 400},
+ {"empty emoji", `{"reactionRules":[{"emoji":"::","points":10}]}`, "invalid_request", true, 400},
+ {"unknown value", `{"reactionRules":[{"emoji":"pb-10","points":10,"valueKey":"missing"}]}`, "unknown_value", true, 400},
+ {"empty choices", `{"mentionPointChoices":[]}`, "invalid_request", true, 400},
+ {"six choices", `{"mentionPointChoices":[1,2,3,4,5,6]}`, "invalid_request", true, 400},
+ {"duplicate choices", `{"mentionPointChoices":[10,10]}`, "invalid_request", true, 400},
+ {"choices above current maximum", `{"mentionPointChoices":[41]}`, "invalid_request", true, 400},
+ {"zero choice", `{"mentionPointChoices":[0]}`, "invalid_request", true, 400},
+ {"missing signing secret", `{"giveInConversation":true}`, "slack_signing_secret_missing", true, 409},
+ {"not connected", `{"giveInConversation":true}`, "slack_not_connected", false, 409},
+ {"cannot disable before connecting", `{"giveInConversation":false}`, "slack_not_connected", false, 409},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ a, db, _ := newSlackAdminTest()
+ if tc.connected {
+ db.integration.Workspace = &domain.SlackWorkspace{TeamID: "T123"}
+ }
+ body := slackAdminCall(t, a, a.patchSlack, "PATCH", "/admin/slack", tc.body, tc.status)
+ slackAdminErrorCode(t, body, tc.code)
+ require.Zero(t, db.updates)
+ })
+ }
+
+ t.Run("defaults are non-null", func(t *testing.T) {
+ a, _, _ := newSlackAdminTest()
+ body := slackAdminCall(t, a, a.adminSlack, "GET", "/admin/slack", "", 200)
+ require.Contains(t, string(body), `"giveInConversation":false`)
+ require.Contains(t, string(body), `"mentionPointChoices":[10,30,50]`)
+ require.Contains(t, string(body), `"reactionRules":[]`)
+ })
+
+ t.Run("cannot enable after workspace change", func(t *testing.T) {
+ a, db, _ := newSlackAdminTest()
+ db.integration.Workspace = &domain.SlackWorkspace{TeamID: "T123"}
+ db.integration.LastErrorCode = new("team_changed")
+ a.slackSigningSecretConfigured = true
+ body := slackAdminCall(t, a, a.patchSlack, "PATCH", "/admin/slack", `{"giveInConversation":true}`, 409)
+ slackAdminErrorCode(t, body, "slack_not_connected")
+ require.Zero(t, db.updates)
+ })
+
+ t.Run("program failure prevents update", func(t *testing.T) {
+ a, db, _ := newSlackAdminTest()
+ db.programErr = errors.New("program unavailable")
+ r := httptest.NewRequest("PATCH", "/admin/slack", strings.NewReader(`{"mentionPointChoices":[10]}`))
+ _, _, err := a.patchSlack(&request{r: r})
+ require.ErrorIs(t, err, db.programErr)
+ require.Zero(t, db.updates)
+ })
+}
+
+func TestSlackConversationInbound(t *testing.T) {
+ for _, tc := range []struct {
+ name, response, want string
+ status int
+ }{
+ {"missing", `{"error":"not_found"}`, `null`, 404},
+ {"ready", `{"id":"peerbonus-slack","url":"https://inbound.example/slack","ready":true,"conditions":[{"type":"Bound","status":"False","reason":"Other"},{"type":"Ready","status":"True","reason":"Ready"}]}`, `{"url":"https://inbound.example/slack","ready":true,"reason":"Ready"}`, 200},
+ {"not ready", `{"url":"","ready":false,"conditions":[{"type":"Ready","status":"False","reason":"TargetNotReady"}]}`, `{"url":null,"ready":false,"reason":"TargetNotReady"}`, 200},
+ {"stale generation", `{"url":"https://inbound.example/slack","ready":false,"conditions":[{"type":"Ready","status":"True","reason":"Ready"}]}`, `{"url":"https://inbound.example/slack","ready":false,"reason":"Ready"}`, 200},
+ {"no ready condition", `{"url":"","ready":false,"conditions":[{"type":"Bound","reason":"Other"}]}`, `{"url":null,"ready":false,"reason":null}`, 200},
+ {"platform failure", `{"message":"secret-token"}`, `{"url":null,"ready":false,"reason":"platform_unavailable"}`, 503},
+ {"denied", `{"error":"forbidden"}`, `{"url":null,"ready":false,"reason":"platform_unavailable"}`, 403},
+ {"invalid json", `not-json`, `{"url":null,"ready":false,"reason":"platform_unavailable"}`, 200},
+ {"redirect", ``, `{"url":null,"ready":false,"reason":"platform_unavailable"}`, 302},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ calls := 0
+ platform := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ calls++
+ require.Equal(t, http.MethodGet, r.Method)
+ require.Equal(t, "/api/v1/projects/pj-test/inbound-endpoints/peerbonus-slack", r.URL.Path)
+ require.Equal(t, "Bearer admin-viewer", r.Header.Get("Authorization"))
+ require.Equal(t, "application/json", r.Header.Get("Accept"))
+ if tc.status == 302 {
+ w.Header().Set("Location", "/must-not-follow")
+ }
+ w.WriteHeader(tc.status)
+ _, _ = w.Write([]byte(tc.response))
+ }))
+ defer platform.Close()
+ a, _, _ := newSlackAdminTest()
+ a.slackInbound = newSlackInboundClient(platform.URL+"/", "pj-test", platform.Client().Transport)
+ for _, call := range []struct {
+ method, body string
+ fn endpoint
+ }{
+ {"GET", "", a.adminSlack},
+ {"PATCH", `{"locale":"en"}`, a.patchSlack},
+ } {
+ body := slackAdminCall(t, a, call.fn, call.method, "/admin/slack", call.body, 200)
+ var result struct {
+ Inbound json.RawMessage `json:"inbound"`
+ }
+ require.NoError(t, json.Unmarshal(body, &result))
+ require.JSONEq(t, tc.want, string(result.Inbound))
+ require.NotContains(t, string(body), "secret-token")
+ }
+ require.Equal(t, 2, calls, "each response uses its viewer; redirects are not followed")
+ })
+ }
+
+ t.Run("transport failure", func(t *testing.T) {
+ platform := httptest.NewServer(http.NotFoundHandler())
+ a, _, _ := newSlackAdminTest()
+ a.slackInbound = newSlackInboundClient(platform.URL, "pj-test", platform.Client().Transport)
+ platform.Close()
+ body := slackAdminCall(t, a, a.adminSlack, "GET", "/admin/slack", "", 200)
+ require.Contains(t, string(body), `"inbound":{"url":null,"ready":false,"reason":"platform_unavailable"}`)
+ })
+}
diff --git a/cmd/server/internal/api/types.go b/cmd/server/internal/api/types.go
index abbb6bf..31f0929 100644
--- a/cmd/server/internal/api/types.go
+++ b/cmd/server/internal/api/types.go
@@ -16,11 +16,14 @@ type slackIntegrationResponse struct {
State domain.SlackState `json:"state"`
Workspace *slackWorkspaceResponse `json:"workspace"`
Settings struct {
- AnnounceChannel *slackChannelResponse `json:"announceChannel"`
- AnnouncePosts bool `json:"announcePosts"`
- DMRecipientOnPost bool `json:"dmRecipientOnPost"`
- GiveFromSlack bool `json:"giveFromSlack"`
- Locale domain.SlackLocale `json:"locale"`
+ AnnounceChannel *slackChannelResponse `json:"announceChannel"`
+ AnnouncePosts bool `json:"announcePosts"`
+ DMRecipientOnPost bool `json:"dmRecipientOnPost"`
+ GiveFromSlack bool `json:"giveFromSlack"`
+ GiveInConversation bool `json:"giveInConversation"`
+ MentionPointChoices []int `json:"mentionPointChoices"`
+ ReactionRules []slackReactionRule `json:"reactionRules"`
+ Locale domain.SlackLocale `json:"locale"`
} `json:"settings"`
Inbound *slackInboundResponse `json:"inbound"`
LastError *slackLastErrorResponse `json:"lastError"`
@@ -45,6 +48,12 @@ type slackChannelCandidate struct {
IsMember bool `json:"isMember"`
}
+type slackReactionRule struct {
+ Emoji string `json:"emoji"`
+ Points int `json:"points"`
+ ValueKey *string `json:"valueKey"`
+}
+
type slackInboundResponse struct {
URL *string `json:"url"`
Ready bool `json:"ready"`
@@ -127,19 +136,20 @@ type programAdminResponse struct {
Currency string `json:"currency"`
}
type postResponse struct {
- ID string `json:"id"`
- Sender memberResponse `json:"sender"`
- Recipient memberResponse `json:"recipient"`
- Points int `json:"points"`
- Message string `json:"message"`
- Values []string `json:"values"`
- ClapCount int `json:"clapCount"`
- ClapPoints int `json:"clapPoints"`
- ClappedByMe int `json:"clappedByMe"`
- Clappers []memberResponse `json:"clappers"`
- Period string `json:"period"`
- Month string `json:"month"`
- CreatedAt time.Time `json:"createdAt"`
+ ID string `json:"id"`
+ Sender memberResponse `json:"sender"`
+ Recipient memberResponse `json:"recipient"`
+ Points int `json:"points"`
+ Message string `json:"message"`
+ Values []string `json:"values"`
+ ClapCount int `json:"clapCount"`
+ ClapPoints int `json:"clapPoints"`
+ ClappedByMe int `json:"clappedByMe"`
+ Clappers []memberResponse `json:"clappers"`
+ Period string `json:"period"`
+ Month string `json:"month"`
+ CreatedAt time.Time `json:"createdAt"`
+ SlackPermalink *string `json:"slackPermalink"`
}
type clapResponse struct {
ID string `json:"id"`
@@ -393,7 +403,7 @@ func (a *API) renderPost(p domain.Post) postResponse {
for _, member := range p.Clappers {
clappers = append(clappers, a.renderMember(member))
}
- return postResponse{ID: p.ID, Sender: a.renderMember(p.Sender), Recipient: a.renderMember(p.Recipient), Points: p.Points, Message: p.Message, Values: values, ClapCount: p.ClapCount, ClapPoints: p.ClapPoints, ClappedByMe: p.ClappedByMe, Clappers: clappers, Period: p.PeriodKey, Month: p.MonthKey, CreatedAt: p.CreatedAt}
+ return postResponse{ID: p.ID, Sender: a.renderMember(p.Sender), Recipient: a.renderMember(p.Recipient), Points: p.Points, Message: p.Message, Values: values, ClapCount: p.ClapCount, ClapPoints: p.ClapPoints, ClappedByMe: p.ClappedByMe, Clappers: clappers, Period: p.PeriodKey, Month: p.MonthKey, CreatedAt: p.CreatedAt, SlackPermalink: p.SlackPermalink}
}
func (a *API) renderClap(c domain.Clap) clapResponse {
return clapResponse{ID: c.ID, Member: a.renderMember(c.Member), CreatedAt: c.CreatedAt}
diff --git a/cmd/server/internal/slack/client.go b/cmd/server/internal/slack/client.go
index cb0ee5d..f0db12f 100644
--- a/cmd/server/internal/slack/client.go
+++ b/cmd/server/internal/slack/client.go
@@ -9,6 +9,7 @@ import (
"encoding/json"
"errors"
"fmt"
+ "io"
"net/http"
"net/url"
"strconv"
@@ -96,7 +97,7 @@ func (e *Error) Error() string {
var ErrUserNotFound = errors.New("slack: user not found")
func (e *Error) Unwrap() error {
- if e.Code == "users_not_found" {
+ if e.Code == "users_not_found" || e.Code == "user_not_found" {
return ErrUserNotFound
}
return nil
@@ -115,8 +116,14 @@ type AuthInfo struct {
}
type Message struct {
- Text string `json:"text"`
- Blocks json.RawMessage `json:"blocks,omitempty"`
+ Text string `json:"text"`
+ Blocks json.RawMessage `json:"blocks,omitempty"`
+ ThreadTS string `json:"thread_ts,omitempty"`
+}
+
+type User struct {
+ ID, Email string
+ IsBot, Deleted bool
}
type Channel struct {
@@ -137,16 +144,24 @@ type response interface{ status() envelope }
func (c *Client) call(ctx context.Context, method string, body any, out response) error {
ctx, cancel := context.WithTimeout(ctx, callTimeout)
defer cancel()
- data, err := json.Marshal(body)
- if err != nil {
- return fmt.Errorf("slack: %s: encode request: %w", method, err)
+ var reader io.Reader
+ contentType := "application/json; charset=utf-8"
+ if form, ok := body.(url.Values); ok {
+ reader = strings.NewReader(form.Encode())
+ contentType = "application/x-www-form-urlencoded"
+ } else {
+ data, err := json.Marshal(body)
+ if err != nil {
+ return fmt.Errorf("slack: %s: encode request: %w", method, err)
+ }
+ reader = bytes.NewReader(data)
}
- req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.base+"/"+method, bytes.NewReader(data))
+ req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.base+"/"+method, reader)
if err != nil {
return fmt.Errorf("slack: %s: create request: %w", method, err)
}
req.Header.Set("Authorization", "Bearer "+c.token)
- req.Header.Set("Content-Type", "application/json; charset=utf-8")
+ req.Header.Set("Content-Type", contentType)
resp, err := c.http.Do(req)
if err != nil {
return fmt.Errorf("slack: %s: request: %w", method, err)
@@ -243,21 +258,38 @@ func (c *Client) LookupUserByEmail(ctx context.Context, email string) (string, e
ID string `json:"id"`
} `json:"user"`
}
- body := struct {
- Email string `json:"email"`
- }{email}
- err := c.call(ctx, "users.lookupByEmail", body, &out)
+ err := c.call(ctx, "users.lookupByEmail", url.Values{"email": {email}}, &out)
return out.User.ID, err
}
+func (c *Client) UserInfo(ctx context.Context, userID string) (User, error) {
+ var out struct {
+ envelope
+ User struct {
+ ID string `json:"id"`
+ IsBot bool `json:"is_bot"`
+ Deleted bool `json:"deleted"`
+ Profile struct {
+ Email string `json:"email"`
+ } `json:"profile"`
+ } `json:"user"`
+ }
+ err := c.call(ctx, "users.info", url.Values{"user": {userID}}, &out)
+ return User{ID: out.User.ID, Email: out.User.Profile.Email, IsBot: out.User.IsBot, Deleted: out.User.Deleted}, err
+}
+
+func (c *Client) Permalink(ctx context.Context, channel, ts string) (string, error) {
+ var out struct {
+ envelope
+ Permalink string `json:"permalink"`
+ }
+ err := c.call(ctx, "chat.getPermalink", url.Values{"channel": {channel}, "message_ts": {ts}}, &out)
+ return out.Permalink, err
+}
+
// ListPublicChannels follows Slack cursors, returning at most 1,000 channels.
func (c *Client) ListPublicChannels(ctx context.Context) ([]Channel, error) {
- body := struct {
- Types string `json:"types"`
- ExcludeArchived bool `json:"exclude_archived"`
- Limit int `json:"limit"`
- Cursor string `json:"cursor,omitempty"`
- }{Types: "public_channel", ExcludeArchived: true, Limit: 200}
+ body := url.Values{"types": {"public_channel"}, "exclude_archived": {"true"}, "limit": {"200"}}
channels := make([]Channel, 0)
for {
var out struct {
@@ -274,7 +306,7 @@ func (c *Client) ListPublicChannels(ctx context.Context) ([]Channel, error) {
if len(channels) == 1000 || out.Metadata.NextCursor == "" {
return channels, nil
}
- body.Cursor = out.Metadata.NextCursor
+ body.Set("cursor", out.Metadata.NextCursor)
}
}
diff --git a/cmd/server/internal/slack/client_test.go b/cmd/server/internal/slack/client_test.go
index 8084df0..9d27d95 100644
--- a/cmd/server/internal/slack/client_test.go
+++ b/cmd/server/internal/slack/client_test.go
@@ -8,6 +8,7 @@ import (
"io"
"net/http"
"net/http/httptest"
+ "net/url"
"strings"
"testing"
"time"
@@ -91,12 +92,21 @@ func TestRateLimitRetryAfter(t *testing.T) {
t.Cleanup(server.Close)
client, err := slack.New("test-token", slack.WithBaseURL(server.URL))
require.NoError(t, err)
- _, err = client.AuthTest(t.Context())
- require.True(t, slack.IsRateLimited(fmt.Errorf("wrapped: %w", err)))
- var apiError *slack.Error
- require.ErrorAs(t, err, &apiError)
- require.Equal(t, tc.want, apiError.RetryAfter)
- require.Equal(t, tc.status, apiError.Status)
+ for _, method := range []string{"auth.test", "users.info"} {
+ t.Run(method, func(t *testing.T) {
+ if method == "auth.test" {
+ _, err = client.AuthTest(t.Context())
+ } else {
+ _, err = client.UserInfo(t.Context(), "U1")
+ }
+ require.True(t, slack.IsRateLimited(fmt.Errorf("wrapped: %w", err)))
+ var apiError *slack.Error
+ require.ErrorAs(t, err, &apiError)
+ require.Equal(t, method, apiError.Method)
+ require.Equal(t, tc.want, apiError.RetryAfter)
+ require.Equal(t, tc.status, apiError.Status)
+ })
+ }
})
}
require.False(t, slack.IsRateLimited(nil))
@@ -120,8 +130,8 @@ func TestPagination(t *testing.T) {
require.Len(t, calls, 3)
for _, call := range calls {
require.Equal(t, "public_channel", call.Body["types"])
- require.Equal(t, true, call.Body["exclude_archived"])
- require.Equal(t, float64(200), call.Body["limit"])
+ require.Equal(t, "true", call.Body["exclude_archived"])
+ require.Equal(t, "200", call.Body["limit"])
}
require.Empty(t, calls[0].Body["cursor"])
require.NotEmpty(t, calls[1].Body["cursor"])
@@ -131,12 +141,9 @@ func TestPagination(t *testing.T) {
func TestPaginationCapsAtThousand(t *testing.T) {
calls := 0
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- var body struct {
- Cursor string `json:"cursor"`
- }
- require.NoError(t, json.NewDecoder(r.Body).Decode(&body))
+ require.NoError(t, r.ParseForm())
if calls > 0 {
- require.Equal(t, fmt.Sprint(calls), body.Cursor)
+ require.Equal(t, fmt.Sprint(calls), r.PostForm.Get("cursor"))
}
calls++
channels := make([]slack.Channel, 200)
@@ -213,3 +220,145 @@ func TestTransportRejectsRedirects(t *testing.T) {
require.Equal(t, http.StatusTemporaryRedirect, apiError.Status)
require.False(t, redirected)
}
+
+func TestLookupUserByEmailFormEncoding(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ require.Equal(t, http.MethodPost, r.Method)
+ require.Equal(t, "/users.lookupByEmail", r.URL.Path)
+ require.Equal(t, "Bearer test-token", r.Header.Get("Authorization"))
+ require.Equal(t, "application/x-www-form-urlencoded", r.Header.Get("Content-Type"))
+ require.Empty(t, r.URL.RawQuery)
+ require.NoError(t, r.ParseForm())
+ require.Equal(t, "alice+bonus@example.com", r.PostForm.Get("email"))
+ require.Empty(t, r.PostForm.Get("token"))
+ _, _ = io.WriteString(w, `{"ok":true,"user":{"id":"U1"}}`)
+ }))
+ t.Cleanup(server.Close)
+ client, err := slack.New("test-token", slack.WithBaseURL(server.URL))
+ require.NoError(t, err)
+ id, err := client.LookupUserByEmail(t.Context(), "alice+bonus@example.com")
+ require.NoError(t, err)
+ require.Equal(t, "U1", id)
+}
+
+func TestConversationReadMethodsFormEncoding(t *testing.T) {
+ for _, tc := range []struct {
+ method string
+ form url.Values
+ response string
+ call func(*testing.T, *slack.Client)
+ }{
+ {"users.info", url.Values{"user": {"U1"}},
+ `{"ok":true,"user":{"id":"U1","profile":{"email":"alice@example.com"},"is_bot":false,"deleted":false}}`,
+ func(t *testing.T, client *slack.Client) {
+ user, err := client.UserInfo(t.Context(), "U1")
+ require.NoError(t, err)
+ require.Equal(t, slack.User{ID: "U1", Email: "alice@example.com"}, user)
+ }},
+ {"chat.getPermalink", url.Values{"channel": {"C1"}, "message_ts": {"1700000000.000123"}},
+ `{"ok":true,"permalink":"https://acme.slack.com/archives/C1/p1700000000000123"}`,
+ func(t *testing.T, client *slack.Client) {
+ link, err := client.Permalink(t.Context(), "C1", "1700000000.000123")
+ require.NoError(t, err)
+ require.Equal(t, "https://acme.slack.com/archives/C1/p1700000000000123", link)
+ }},
+ {"conversations.list", url.Values{"types": {"public_channel"}, "exclude_archived": {"true"}, "limit": {"200"}},
+ `{"ok":true,"channels":[{"id":"C1","name":"thanks","is_member":true}],"response_metadata":{"next_cursor":""}}`,
+ func(t *testing.T, client *slack.Client) {
+ channels, err := client.ListPublicChannels(t.Context())
+ require.NoError(t, err)
+ require.Equal(t, []slack.Channel{{ID: "C1", Name: "thanks", IsMember: true}}, channels)
+ }},
+ } {
+ t.Run(tc.method, func(t *testing.T) {
+ calls := 0
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ calls++
+ require.Equal(t, http.MethodPost, r.Method)
+ require.Equal(t, "/"+tc.method, r.URL.Path)
+ require.Equal(t, "Bearer test-token", r.Header.Get("Authorization"))
+ require.Equal(t, "application/x-www-form-urlencoded", r.Header.Get("Content-Type"))
+ require.Empty(t, r.URL.RawQuery)
+ require.NoError(t, r.ParseForm())
+ require.Equal(t, tc.form, r.PostForm)
+ _, _ = io.WriteString(w, tc.response)
+ }))
+ t.Cleanup(server.Close)
+ client, err := slack.New("test-token", slack.WithBaseURL(server.URL))
+ require.NoError(t, err)
+ tc.call(t, client)
+ require.Equal(t, 1, calls)
+ })
+ }
+}
+
+func TestUserInfoFlagsAndErrors(t *testing.T) {
+ for _, tc := range []struct {
+ name, response string
+ want slack.User
+ }{
+ {"bot", `{"ok":true,"user":{"id":"UBOT","is_bot":true,"profile":{}}}`, slack.User{ID: "UBOT", IsBot: true}},
+ {"deleted", `{"ok":true,"user":{"id":"U1","deleted":true,"profile":{"email":"alice@example.com"}}}`, slack.User{ID: "U1", Email: "alice@example.com", Deleted: true}},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+ _, _ = io.WriteString(w, tc.response)
+ }))
+ t.Cleanup(server.Close)
+ client, err := slack.New("test-token", slack.WithBaseURL(server.URL))
+ require.NoError(t, err)
+ user, err := client.UserInfo(t.Context(), tc.want.ID)
+ require.NoError(t, err)
+ require.Equal(t, tc.want, user)
+ })
+ }
+ server := slacktest.New(t)
+ client, err := slack.New("test-token", slack.WithBaseURL(server.URL))
+ require.NoError(t, err)
+ _, err = client.UserInfo(t.Context(), "U_MISSING")
+ require.ErrorIs(t, err, slack.ErrUserNotFound)
+ require.EqualError(t, err, "slack: users.info: user_not_found (HTTP 200)")
+ var apiError *slack.Error
+ require.ErrorAs(t, err, &apiError)
+ require.Equal(t, "user_not_found", apiError.Code)
+ server.Fail("users.info", "invalid_auth")
+ _, err = client.UserInfo(t.Context(), "U1")
+ require.EqualError(t, err, "slack: users.info: invalid_auth (HTTP 200)")
+ require.False(t, errors.Is(err, slack.ErrUserNotFound))
+}
+
+func TestThreadMessagesJSONEncoding(t *testing.T) {
+ for _, method := range []string{"chat.postMessage", "chat.postEphemeral"} {
+ for _, threadTS := range []string{"", "1700000000.000123"} {
+ t.Run(method+"/"+threadTS, func(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ require.Equal(t, "/"+method, r.URL.Path)
+ require.Equal(t, "application/json; charset=utf-8", r.Header.Get("Content-Type"))
+ var body map[string]any
+ require.NoError(t, json.NewDecoder(r.Body).Decode(&body))
+ require.Equal(t, "C1", body["channel"])
+ require.Equal(t, "thanks", body["text"])
+ if method == "chat.postEphemeral" {
+ require.Equal(t, "U1", body["user"])
+ }
+ if threadTS == "" {
+ require.NotContains(t, body, "thread_ts")
+ } else {
+ require.Equal(t, threadTS, body["thread_ts"])
+ }
+ _, _ = io.WriteString(w, `{"ok":true,"ts":"1700000000.000124","message_ts":"1700000000.000124"}`)
+ }))
+ t.Cleanup(server.Close)
+ client, err := slack.New("test-token", slack.WithBaseURL(server.URL))
+ require.NoError(t, err)
+ message := slack.Message{Text: "thanks", ThreadTS: threadTS}
+ if method == "chat.postMessage" {
+ _, err = client.PostMessage(t.Context(), "C1", message)
+ } else {
+ err = client.PostEphemeral(t.Context(), "C1", "U1", message)
+ }
+ require.NoError(t, err)
+ })
+ }
+ }
+}
diff --git a/cmd/server/internal/slack/slacktest/cmd/fakeslack/main.go b/cmd/server/internal/slack/slacktest/cmd/fakeslack/main.go
index 7a7e9b8..5ed2fc0 100644
--- a/cmd/server/internal/slack/slacktest/cmd/fakeslack/main.go
+++ b/cmd/server/internal/slack/slacktest/cmd/fakeslack/main.go
@@ -1,10 +1,12 @@
// fakeslack runs the same Slack fake used by package tests. For example:
//
// go run ./cmd/server/internal/slack/slacktest/cmd/fakeslack \
-// --listen 127.0.0.1:0 --user alice@example.com=U1 --channel C1=thanks:member
+// --listen 127.0.0.1:0 --user alice@example.com=U1 --bot bot@example.com=UBOT \
+// --channel C1=thanks:member
//
// It prints URL= once. GET /_calls returns recorded calls, persistent
-// messages (including updates/deletions), and opened views, with auth redacted.
+// messages (including thread_ts, updates/deletions), and opened views, with auth
+// redacted. --bot registers a user whose users.info response has is_bot=true.
package main
import (
@@ -47,6 +49,14 @@ func run(ctx context.Context, args []string, stdout, stderr io.Writer) error {
fake.AddUser(email, id)
return nil
})
+ flags.Func("bot", "email=UID for a bot user (repeatable)", func(raw string) error {
+ email, id, ok := strings.Cut(raw, "=")
+ if !ok || email == "" || id == "" {
+ return errors.New("bot must be email=UID")
+ }
+ fake.AddBot(email, id)
+ return nil
+ })
flags.Func("channel", "id=name[:member] (repeatable; member, true, or false)", func(raw string) error {
id, name, ok := strings.Cut(raw, "=")
if !ok || id == "" || name == "" {
diff --git a/cmd/server/internal/slack/slacktest/cmd/fakeslack/main_test.go b/cmd/server/internal/slack/slacktest/cmd/fakeslack/main_test.go
index 6386dad..065a029 100644
--- a/cmd/server/internal/slack/slacktest/cmd/fakeslack/main_test.go
+++ b/cmd/server/internal/slack/slacktest/cmd/fakeslack/main_test.go
@@ -23,7 +23,7 @@ func TestRunSeedsFixturesAndStops(t *testing.T) {
output := make(startupOutput, 1)
done := make(chan error, 1)
go func() {
- done <- run(ctx, []string{"--listen", "127.0.0.1:0", "--user", "alice@example.com=U1", "--user", "bob@example.com=U2", "--channel", "C1=thanks:member", "--channel", "C2=general", "--channel", "C3=team:true"}, output, io.Discard)
+ done <- run(ctx, []string{"--listen", "127.0.0.1:0", "--user", "alice@example.com=U1", "--user", "bob@example.com=U2", "--bot", "bot@example.com=UBOT", "--channel", "C1=thanks:member", "--channel", "C2=general", "--channel", "C3=team:true"}, output, io.Discard)
}()
t.Cleanup(func() {
cancel()
@@ -48,12 +48,22 @@ func TestRunSeedsFixturesAndStops(t *testing.T) {
id, err := client.LookupUserByEmail(t.Context(), email)
require.NoError(t, err)
require.Equal(t, want, id)
+ user, err := client.UserInfo(t.Context(), id)
+ require.NoError(t, err)
+ require.Equal(t, slack.User{ID: id, Email: email}, user)
}
+ bot, err := client.UserInfo(t.Context(), "UBOT")
+ require.NoError(t, err)
+ require.Equal(t, slack.User{ID: "UBOT", Email: "bot@example.com", IsBot: true}, bot)
channels, err := client.ListPublicChannels(t.Context())
require.NoError(t, err)
require.Equal(t, []slack.Channel{{ID: "C1", Name: "thanks", IsMember: true}, {ID: "C2", Name: "general", IsMember: false}, {ID: "C3", Name: "team", IsMember: true}}, channels)
- ts, err := client.PostMessage(t.Context(), "C1", slack.Message{Text: "thanks"})
+ ts, err := client.PostMessage(t.Context(), "C1", slack.Message{Text: "thanks", ThreadTS: "1699999999.000001"})
+ require.NoError(t, err)
+ link, err := client.Permalink(t.Context(), "C1", ts)
require.NoError(t, err)
+ require.Equal(t, "https://example.slack.com/archives/C1/p"+strings.ReplaceAll(ts, ".", ""), link)
+ require.NoError(t, client.PostEphemeral(t.Context(), "C1", "U1", slack.Message{Text: "thanks privately", ThreadTS: "1699999999.000001"}))
require.NoError(t, client.UpdateMessage(t.Context(), "C1", ts, slack.Message{Text: "updated"}))
require.NoError(t, client.DeleteMessage(t.Context(), "C1", ts))
resp, err := http.Get(base + "/_calls")
@@ -64,8 +74,14 @@ func TestRunSeedsFixturesAndStops(t *testing.T) {
Messages []slacktest.Posted `json:"messages"`
}
require.NoError(t, json.NewDecoder(resp.Body).Decode(&dump))
- require.Len(t, dump.Calls, 7)
+ require.Len(t, dump.Calls, 12)
+ for _, call := range dump.Calls {
+ if call.Method == "chat.postMessage" || call.Method == "chat.postEphemeral" {
+ require.Equal(t, "1699999999.000001", call.Body["thread_ts"])
+ }
+ }
require.Len(t, dump.Messages, 1)
+ require.Equal(t, "1699999999.000001", dump.Messages[0].ThreadTS)
require.True(t, dump.Messages[0].Deleted)
require.Equal(t, 1, dump.Messages[0].Updates)
require.Equal(t, "updated", dump.Messages[0].Text)
@@ -74,6 +90,7 @@ func TestRunSeedsFixturesAndStops(t *testing.T) {
func TestInvalidFlags(t *testing.T) {
for _, args := range [][]string{
{"--user", "alice"}, {"--user", "=U1"}, {"--user", "alice="},
+ {"--bot", "bot"}, {"--bot", "=UBOT"}, {"--bot", "bot="},
{"--channel", "C1"}, {"--channel", "=thanks"}, {"--channel", "C1="},
{"--channel", "C1=:member"}, {"--channel", "C1=thanks:maybe"},
{"unexpected"},
diff --git a/cmd/server/internal/slack/slacktest/server.go b/cmd/server/internal/slack/slacktest/server.go
index d306136..abe60b9 100644
--- a/cmd/server/internal/slack/slacktest/server.go
+++ b/cmd/server/internal/slack/slacktest/server.go
@@ -6,6 +6,7 @@ package slacktest
import (
"encoding/json"
"fmt"
+ "mime"
"net/http"
"net/http/httptest"
"slices"
@@ -21,7 +22,7 @@ type Server struct {
URL string
mu sync.Mutex
team slack.AuthInfo
- users map[string]string
+ users map[string]slack.User
channels []slack.Channel
failures map[string][]string
calls []Call
@@ -41,12 +42,13 @@ type Call struct {
}
type Posted struct {
- Channel string `json:"channel"`
- TS string `json:"ts"`
- Text string `json:"text"`
- Blocks json.RawMessage `json:"blocks,omitempty"`
- Deleted bool `json:"deleted"`
- Updates int `json:"updates"`
+ Channel string `json:"channel"`
+ TS string `json:"ts"`
+ ThreadTS string `json:"thread_ts,omitempty"`
+ Text string `json:"text"`
+ Blocks json.RawMessage `json:"blocks,omitempty"`
+ Deleted bool `json:"deleted"`
+ Updates int `json:"updates"`
}
func New(t testing.TB, opts ...ServerOption) *Server {
@@ -60,10 +62,12 @@ func New(t testing.TB, opts ...ServerOption) *Server {
// NewHandler creates a fake without opening a listener. It also serves GET
// /_calls with calls, messages, and views; authorization values are redacted.
+// Slack methods accept JSON or form bodies. Permalinks also cover incoming
+// messages not posted through this fake, provided their channel is configured.
func NewHandler(opts ...ServerOption) *Server {
s := &Server{
team: slack.AuthInfo{TeamID: "T123", TeamName: "Acme", BotUserID: "UBOT"},
- users: make(map[string]string), failures: make(map[string][]string),
+ users: make(map[string]slack.User), failures: make(map[string][]string),
channels: []slack.Channel{}, calls: []Call{}, messages: []Posted{}, views: []json.RawMessage{},
}
for _, opt := range opts {
@@ -79,9 +83,18 @@ func (s *Server) Team() slack.AuthInfo {
}
func (s *Server) AddUser(email, userID string) {
+ s.addUser(slack.User{ID: userID, Email: email})
+}
+
+// AddBot registers a user returned by users.info with is_bot set.
+func (s *Server) AddBot(email, userID string) {
+ s.addUser(slack.User{ID: userID, Email: email, IsBot: true})
+}
+
+func (s *Server) addUser(user slack.User) {
s.mu.Lock()
defer s.mu.Unlock()
- s.users[strings.ToLower(email)] = userID
+ s.users[strings.ToLower(user.Email)] = user
}
func (s *Server) AddChannel(id, name string, botMember bool) {
@@ -177,7 +190,18 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
return
}
var body map[string]any
- if err := json.NewDecoder(r.Body).Decode(&body); err != nil || body == nil {
+ contentType, _, _ := mime.ParseMediaType(r.Header.Get("Content-Type"))
+ if contentType == "application/x-www-form-urlencoded" {
+ if err := r.ParseForm(); err != nil {
+ w.WriteHeader(http.StatusBadRequest)
+ writeError(w, "invalid_form")
+ return
+ }
+ body = make(map[string]any, len(r.PostForm))
+ for key := range r.PostForm {
+ body[key] = r.PostForm.Get(key)
+ }
+ } else if err := json.NewDecoder(r.Body).Decode(&body); err != nil || body == nil {
w.WriteHeader(http.StatusBadRequest)
writeError(w, "invalid_json")
return
@@ -204,12 +228,34 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
slack.AuthInfo
}{true, s.team})
case "users.lookupByEmail":
- id, ok := s.users[strings.ToLower(field("email"))]
+ user, ok := s.users[strings.ToLower(field("email"))]
if !ok {
writeError(w, "users_not_found")
return
}
- writeJSON(w, map[string]any{"ok": true, "user": map[string]string{"id": id}})
+ writeJSON(w, map[string]any{"ok": true, "user": map[string]string{"id": user.ID}})
+ case "users.info":
+ for _, user := range s.users {
+ if user.ID == field("user") {
+ writeJSON(w, map[string]any{"ok": true, "user": map[string]any{
+ "id": user.ID, "is_bot": user.IsBot, "deleted": user.Deleted,
+ "profile": map[string]string{"email": user.Email},
+ }})
+ return
+ }
+ }
+ writeError(w, "user_not_found")
+ case "chat.getPermalink":
+ channel, ts := field("channel"), field("message_ts")
+ if code := s.channelError(channel); code != "" {
+ writeError(w, code)
+ return
+ }
+ if ts == "" {
+ writeError(w, "message_not_found")
+ return
+ }
+ writeJSON(w, map[string]any{"ok": true, "channel": channel, "permalink": "https://example.slack.com/archives/" + channel + "/p" + strings.ReplaceAll(ts, ".", "")})
case "conversations.list":
start := 0
if cursor := field("cursor"); cursor != "" {
@@ -238,7 +284,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
writeJSON(w, map[string]any{"ok": true, "message_ts": ts})
return
}
- s.messages = append(s.messages, Posted{Channel: channel, TS: ts, Text: field("text"), Blocks: rawField(body, "blocks")})
+ s.messages = append(s.messages, Posted{Channel: channel, TS: ts, ThreadTS: field("thread_ts"), Text: field("text"), Blocks: rawField(body, "blocks")})
writeJSON(w, map[string]any{"ok": true, "channel": channel, "ts": ts})
case "chat.update", "chat.delete":
channel := field("channel")
@@ -280,8 +326,8 @@ func (s *Server) channelError(id string) string {
return ""
}
}
- for _, userID := range s.users {
- if userID == id {
+ for _, user := range s.users {
+ if user.ID == id {
return ""
}
}
@@ -293,6 +339,9 @@ func rawField(body map[string]any, key string) json.RawMessage {
if !ok {
return nil
}
+ if data, ok := value.(string); ok {
+ return json.RawMessage(data)
+ }
data, _ := json.Marshal(value) // Values were produced by encoding/json.
return data
}
diff --git a/cmd/server/internal/slack/slacktest/server_test.go b/cmd/server/internal/slack/slacktest/server_test.go
index 7405365..9216421 100644
--- a/cmd/server/internal/slack/slacktest/server_test.go
+++ b/cmd/server/internal/slack/slacktest/server_test.go
@@ -5,6 +5,8 @@ import (
"fmt"
"io"
"net/http"
+ "net/url"
+ "strings"
"testing"
"time"
@@ -36,13 +38,14 @@ func TestMessageLifecycleViewsAndEphemeral(t *testing.T) {
require.NoError(t, err)
require.Equal(t, slack.AuthInfo{TeamID: "T123", TeamName: "Acme", BotUserID: "UBOT"}, team)
blocks := json.RawMessage(`[{"type":"section","text":{"type":"mrkdwn","text":"thanks <@U1>"}}]`)
- ts, err := client.PostMessage(t.Context(), "C1", slack.Message{Text: "thanks", Blocks: blocks})
+ ts, err := client.PostMessage(t.Context(), "C1", slack.Message{Text: "thanks", Blocks: blocks, ThreadTS: "1699999999.000001"})
require.NoError(t, err)
require.NotEmpty(t, ts)
messages := server.Messages()
require.Len(t, messages, 1)
require.Equal(t, "C1", messages[0].Channel)
require.Equal(t, ts, messages[0].TS)
+ require.Equal(t, "1699999999.000001", messages[0].ThreadTS)
require.Equal(t, "thanks", messages[0].Text)
require.JSONEq(t, string(blocks), string(messages[0].Blocks))
updatedBlocks := json.RawMessage(`[{"type":"divider"}]`)
@@ -66,13 +69,14 @@ func TestMessageLifecycleViewsAndEphemeral(t *testing.T) {
require.NoError(t, err)
require.NotEqual(t, ts, dmTS)
require.Len(t, server.Messages(), 2)
- require.NoError(t, client.PostEphemeral(t.Context(), "C1", "U1", slack.Message{Text: "clapped"}))
+ require.NoError(t, client.PostEphemeral(t.Context(), "C1", "U1", slack.Message{Text: "clapped", ThreadTS: "1699999999.000001"}))
require.Len(t, server.Messages(), 2, "ephemeral messages are not persistent")
calls := server.Calls("chat.postEphemeral")
require.Len(t, calls, 1)
require.Equal(t, "U1", calls[0].Body["user"])
require.Equal(t, "C1", calls[0].Body["channel"])
require.Equal(t, "clapped", calls[0].Body["text"])
+ require.Equal(t, "1699999999.000001", calls[0].Body["thread_ts"])
view := json.RawMessage(`{"type":"modal","title":{"type":"plain_text","text":"Give"},"blocks":[]}`)
require.NoError(t, client.OpenView(t.Context(), "trigger-1", view))
views := server.Views()
@@ -141,9 +145,10 @@ func TestSnapshotsCannotMutateServerAndDumpRedactsAuthorization(t *testing.T) {
server := slacktest.New(t)
server.AddChannel("C1", "thanks", true)
client := clientFor(t, server)
- _, err := client.PostMessage(t.Context(), "C1", slack.Message{Text: "thanks", Blocks: json.RawMessage(`[{"type":"divider"}]`)})
+ _, err := client.PostMessage(t.Context(), "C1", slack.Message{Text: "thanks", Blocks: json.RawMessage(`[{"type":"divider"}]`), ThreadTS: "1699999999.000001"})
require.NoError(t, err)
require.NoError(t, client.OpenView(t.Context(), "trigger", json.RawMessage(`{"type":"modal"}`)))
+ require.NoError(t, client.PostEphemeral(t.Context(), "C1", "U1", slack.Message{Text: "private thanks", ThreadTS: "1699999999.000001"}))
calls := server.Calls("chat.postMessage")
calls[0].Body["text"] = "changed"
calls[0].Body["blocks"].([]any)[0].(map[string]any)["type"] = "changed"
@@ -169,9 +174,12 @@ func TestSnapshotsCannotMutateServerAndDumpRedactsAuthorization(t *testing.T) {
Views []json.RawMessage `json:"views"`
}
require.NoError(t, json.Unmarshal(data, &dump))
- require.Len(t, dump.Calls, 2)
+ require.Len(t, dump.Calls, 3)
require.Len(t, dump.Messages, 1)
require.Len(t, dump.Views, 1)
+ require.Equal(t, "1699999999.000001", dump.Calls[0].Body["thread_ts"])
+ require.Equal(t, "1699999999.000001", dump.Calls[2].Body["thread_ts"])
+ require.Equal(t, "1699999999.000001", dump.Messages[0].ThreadTS)
require.Equal(t, "Bearer [redacted]", dump.Calls[0].Auth)
require.Equal(t, "Bearer fake-token", server.Calls("")[0].Auth)
}
@@ -197,3 +205,89 @@ func TestConcurrentPosts(t *testing.T) {
seen[message.TS] = true
}
}
+
+func TestReadMethodsAcceptJSONAndForm(t *testing.T) {
+ for _, tc := range []struct {
+ method string
+ body map[string]string
+ want string
+ }{
+ {"users.lookupByEmail", map[string]string{"email": "alice+bonus@example.com"}, `{"ok":true,"user":{"id":"U1"}}`},
+ {"users.info", map[string]string{"user": "U1"}, `{"ok":true,"user":{"id":"U1","is_bot":false,"deleted":false,"profile":{"email":"alice+bonus@example.com"}}}`},
+ {"users.info", map[string]string{"user": "UBOT"}, `{"ok":true,"user":{"id":"UBOT","is_bot":true,"deleted":false,"profile":{"email":"bot@example.com"}}}`},
+ {"chat.getPermalink", map[string]string{"channel": "C1", "message_ts": "1700000000.000123"}, `{"ok":true,"channel":"C1","permalink":"https://example.slack.com/archives/C1/p1700000000000123"}`},
+ {"conversations.list", map[string]string{"types": "public_channel", "exclude_archived": "true", "limit": "200"}, `{"ok":true,"channels":[{"id":"C1","name":"thanks","is_member":true}],"response_metadata":{"next_cursor":""}}`},
+ } {
+ for _, encoding := range []string{"application/json", "application/x-www-form-urlencoded"} {
+ t.Run(tc.method+"/"+tc.body["user"]+"/"+encoding, func(t *testing.T) {
+ server := slacktest.New(t)
+ server.AddUser("alice+bonus@example.com", "U1")
+ server.AddBot("bot@example.com", "UBOT")
+ server.AddChannel("C1", "thanks", true)
+ var body string
+ if encoding == "application/json" {
+ data, err := json.Marshal(tc.body)
+ require.NoError(t, err)
+ body = string(data)
+ } else {
+ form := url.Values{}
+ for key, value := range tc.body {
+ form.Set(key, value)
+ }
+ body = form.Encode()
+ }
+ resp, err := http.Post(server.URL+"/"+tc.method, encoding+"; charset=utf-8", strings.NewReader(body))
+ require.NoError(t, err)
+ defer resp.Body.Close()
+ require.Equal(t, http.StatusOK, resp.StatusCode)
+ data, err := io.ReadAll(resp.Body)
+ require.NoError(t, err)
+ require.JSONEq(t, tc.want, string(data))
+ calls := server.Calls(tc.method)
+ require.Len(t, calls, 1)
+ for key, value := range tc.body {
+ require.Equal(t, value, calls[0].Body[key])
+ }
+ })
+ }
+ }
+}
+
+func TestPermalinkForIncomingMessages(t *testing.T) {
+ server := slacktest.New(t)
+ server.AddChannel("C1", "thanks", true)
+ client := clientFor(t, server)
+ link, err := client.Permalink(t.Context(), "C1", "1700000000.000123")
+ require.NoError(t, err)
+ require.Equal(t, "https://example.slack.com/archives/C1/p1700000000000123", link)
+ require.Empty(t, server.Messages())
+ _, err = client.Permalink(t.Context(), "missing", "1700000000.000123")
+ assertCode(t, err, "channel_not_found")
+ _, err = client.Permalink(t.Context(), "C1", "")
+ assertCode(t, err, "message_not_found")
+ server.Fail("chat.getPermalink", "ratelimited")
+ _, err = client.Permalink(t.Context(), "C1", "1700000000.000123")
+ require.True(t, slack.IsRateLimited(err))
+}
+
+func TestFormBlocksAndViews(t *testing.T) {
+ server := slacktest.New(t)
+ server.AddChannel("C1", "thanks", true)
+ blocks := `[{"type":"section","text":{"type":"plain_text","text":"thanks & cheers"}}]`
+ form := url.Values{"channel": {"C1"}, "text": {"thanks"}, "thread_ts": {"1699999999.000001"}, "blocks": {blocks}}
+ resp, err := http.PostForm(server.URL+"/chat.postMessage", form)
+ require.NoError(t, err)
+ defer resp.Body.Close()
+ require.Equal(t, http.StatusOK, resp.StatusCode)
+ messages := server.Messages()
+ require.Len(t, messages, 1)
+ require.JSONEq(t, blocks, string(messages[0].Blocks))
+ require.Equal(t, "1699999999.000001", messages[0].ThreadTS)
+ view := `{"type":"modal","blocks":[]}`
+ resp, err = http.PostForm(server.URL+"/views.open", url.Values{"trigger_id": {"T1"}, "view": {view}})
+ require.NoError(t, err)
+ defer resp.Body.Close()
+ require.Equal(t, http.StatusOK, resp.StatusCode)
+ require.Len(t, server.Views(), 1)
+ require.JSONEq(t, view, string(server.Views()[0]))
+}
diff --git a/cmd/server/internal/slackinbound/commands.go b/cmd/server/internal/slackinbound/commands.go
index 6affe27..7c20b87 100644
--- a/cmd/server/internal/slackinbound/commands.go
+++ b/cmd/server/internal/slackinbound/commands.go
@@ -69,19 +69,20 @@ func (h *handler) command(w http.ResponseWriter, r *http.Request, locale domain.
}
type ephemeralResponse struct {
- ResponseType string `json:"response_type"`
- Text string `json:"text"`
+ ResponseType string `json:"response_type"`
+ Text string `json:"text"`
+ ReplaceOriginal bool `json:"replace_original,omitempty"`
}
func (h *handler) commandReply(w http.ResponseWriter, r *http.Request, responseURL, text string) {
- if err := h.respond(r.Context(), responseURL, text); err != nil {
+ if err := h.respond(r.Context(), responseURL, ephemeralResponse{ResponseType: "ephemeral", Text: text}); err != nil {
http.Error(w, "Slack response unavailable", http.StatusBadGateway)
return
}
w.WriteHeader(http.StatusOK)
}
-func (h *handler) respond(ctx context.Context, rawURL, text string) error {
+func (h *handler) respond(ctx context.Context, rawURL string, message ephemeralResponse) error {
endpoint, err := url.Parse(rawURL)
// response_url is a capability supplied inside Slack's signed body, not
// an administrator-configurable webhook. Keep its egress on Slack hosts.
@@ -89,7 +90,7 @@ func (h *handler) respond(ctx context.Context, rawURL, text string) error {
(endpoint.Hostname() != "hooks.slack.com" && endpoint.Hostname() != "hooks.slack-gov.com") {
return fmt.Errorf("invalid Slack response URL")
}
- body, err := json.Marshal(ephemeralResponse{ResponseType: "ephemeral", Text: text})
+ body, err := json.Marshal(message)
if err != nil {
return err
}
diff --git a/cmd/server/internal/slackinbound/events.go b/cmd/server/internal/slackinbound/events.go
new file mode 100644
index 0000000..475aa53
--- /dev/null
+++ b/cmd/server/internal/slackinbound/events.go
@@ -0,0 +1,296 @@
+package slackinbound
+
+import (
+ "context"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "mime"
+ "net/http"
+ "strings"
+
+ "github.com/appthrust/peerbonus/cmd/server/internal/domain"
+ "github.com/appthrust/peerbonus/cmd/server/internal/slack"
+ "github.com/appthrust/peerbonus/cmd/server/internal/store"
+)
+
+type eventEnvelope struct {
+ Type string `json:"type"`
+ Challenge string `json:"challenge"`
+ TeamID string `json:"team_id"`
+ Event slackEvent `json:"event"`
+}
+
+type slackEvent struct {
+ Type string `json:"type"`
+ User string `json:"user"`
+ BotID string `json:"bot_id"`
+ Subtype string `json:"subtype"`
+ Text string `json:"text"`
+ Channel string `json:"channel"`
+ TS string `json:"ts"`
+ ThreadTS string `json:"thread_ts"`
+ Reaction string `json:"reaction"`
+ ItemUser string `json:"item_user"`
+ Item struct {
+ Type string `json:"type"`
+ Channel string `json:"channel"`
+ TS string `json:"ts"`
+ } `json:"item"`
+}
+
+type eventResponse struct {
+ http.ResponseWriter
+ status int
+}
+
+func (w *eventResponse) WriteHeader(status int) {
+ w.status = status
+ w.ResponseWriter.WriteHeader(status)
+}
+
+func (h *handler) events(w http.ResponseWriter, r *http.Request, integration domain.SlackIntegration, body []byte) {
+ mediaType, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
+ if err != nil || mediaType != "application/json" {
+ http.Error(w, "Expected JSON body", http.StatusUnsupportedMediaType)
+ return
+ }
+ var envelope eventEnvelope
+ if err := json.Unmarshal(body, &envelope); err != nil {
+ http.Error(w, "Invalid event", http.StatusBadRequest)
+ return
+ }
+ if envelope.Type == "url_verification" {
+ writeJSON(w, struct {
+ Challenge string `json:"challenge"`
+ }{Challenge: envelope.Challenge})
+ return
+ }
+ if envelope.Type != "event_callback" {
+ return
+ }
+ if envelope.TeamID == "" || envelope.TeamID != integration.Workspace.TeamID {
+ http.Error(w, "Workspace mismatch", http.StatusForbidden)
+ return
+ }
+ if !integration.GiveInConversation {
+ return
+ }
+ event := envelope.Event
+ if event.User == "" || event.User == integration.Workspace.BotUserID || event.BotID != "" || event.Subtype != "" {
+ return
+ }
+ key := r.Header.Get("X-Slack-Request-Timestamp") + ":" + r.Header.Get("X-Slack-Signature")
+ if h.replays.seen(key, h.now(), true) {
+ return
+ }
+ switch event.Type {
+ case "app_mention":
+ if event.Channel != "" && event.TS != "" {
+ h.mention(w, r, integration, event)
+ }
+ case "reaction_added":
+ if event.Item.Type == "message" && event.Item.Channel != "" && event.Item.TS != "" {
+ h.reaction(w, r, integration, event)
+ }
+ }
+}
+
+func eventThread(event slackEvent) string {
+ if event.ThreadTS != "" {
+ return event.ThreadTS
+ }
+ return event.TS
+}
+
+func (h *handler) conversationEphemeral(w http.ResponseWriter, r *http.Request, channel, user, thread string, message slack.Message, committed bool) {
+ message.ThreadTS = thread
+ if err := h.slack.PostEphemeral(r.Context(), channel, user, message); err != nil && !committed {
+ http.Error(w, "Slack unavailable", http.StatusBadGateway)
+ }
+}
+
+func mentionFormat(locale domain.SlackLocale) string {
+ return localized(locale, "@Peer Bonus @相手 30 メッセージ の形式で贈ってください(相手は自分以外の 5 人まで)。", "Use @Peer Bonus @recipient 30 message (up to 5 recipients, excluding yourself).")
+}
+
+func (h *handler) mention(w http.ResponseWriter, r *http.Request, integration domain.SlackIntegration, event slackEvent) {
+ locale := integration.Locale
+ reply := func(text string) {
+ h.conversationEphemeral(w, r, event.Channel, event.User, eventThread(event), slack.Message{Text: text}, false)
+ }
+ sender, err := h.member(r.Context(), event.User)
+ if memberMissing(err) {
+ reply(h.guidance(locale))
+ return
+ }
+ if err != nil {
+ http.Error(w, "Member unavailable", http.StatusServiceUnavailable)
+ return
+ }
+ recipients, points, message := parseMention(event.Text, integration.Workspace.BotUserID)
+ if len(recipients) == 0 || len(recipients) > domain.SlackMaxMentionRecipients || message == "" {
+ reply(mentionFormat(locale))
+ return
+ }
+ ids := make([]string, 0, len(recipients))
+ for _, user := range recipients {
+ if user == event.User {
+ reply(mentionFormat(locale))
+ return
+ }
+ member, err := h.member(r.Context(), user)
+ if memberMissing(err) {
+ reply(fmt.Sprintf(localized(locale, "<@%s> が見つかりません。まず Web で Peer Bonus を一度開いてもらってください。", "<@%s> is not a member. Ask them to open Peer Bonus in the browser first."), user))
+ return
+ }
+ if err != nil {
+ http.Error(w, "Member unavailable", http.StatusServiceUnavailable)
+ return
+ }
+ if member.ID == sender.ID {
+ reply(mentionFormat(locale))
+ return
+ }
+ ids = append(ids, member.ID)
+ }
+ if points == nil {
+ h.promptGive(w, r, integration, event, sender.ID, ids, recipients, message)
+ return
+ }
+ _, replayed, err := h.store.CreateSlackPosts(r.Context(), store.CreateSlackPostsInput{
+ SenderID: sender.ID, RecipientIDs: ids, Points: *points, Message: message, Now: h.now(),
+ Source: h.giveSource(r.Context(), event.Channel, event.TS, ""),
+ })
+ if err != nil {
+ if _, text := postError(err, locale); text != "" {
+ reply(text)
+ } else {
+ http.Error(w, "Unable to give points", http.StatusServiceUnavailable)
+ }
+ return
+ }
+ if !replayed {
+ h.successReply(r.Context(), integration, event.Channel, eventThread(event), giveReplyText(event.User, slackMentions(recipients), *points))
+ }
+}
+
+func (h *handler) giveSource(ctx context.Context, channel, ts, emoji string) domain.SlackGiveSource {
+ source := domain.SlackGiveSource{ChannelID: channel, MessageTS: ts, Emoji: emoji}
+ if link, err := h.slack.Permalink(ctx, channel, ts); err == nil && link != "" {
+ source.Permalink = &link
+ }
+ return source
+}
+
+func slackMentions(users []string) string {
+ mentions := make([]string, len(users))
+ for i, user := range users {
+ mentions[i] = "<@" + user + ">"
+ }
+ return strings.Join(mentions, " ")
+}
+
+func giveReplyText(sender, recipients string, points int) string {
+ return fmt.Sprintf("🎉 <@%s> → %s %d pt", sender, recipients, points)
+}
+
+func (h *handler) successReply(ctx context.Context, integration domain.SlackIntegration, channel, thread, text string) {
+ if integration.AnnouncePosts && integration.AnnounceChannel != nil && integration.AnnounceChannel.ID == channel {
+ return
+ }
+ // The ledger has committed. A reply failure must not retry the give.
+ _, _ = h.slack.PostMessage(ctx, channel, slack.Message{Text: text, ThreadTS: thread})
+}
+
+func (h *handler) reaction(w http.ResponseWriter, r *http.Request, integration domain.SlackIntegration, event slackEvent) {
+ emoji := domain.NormalizeSlackEmoji(event.Reaction)
+ var rule *domain.SlackReactionRule
+ for i := range integration.ReactionRules {
+ if integration.ReactionRules[i].Emoji == emoji {
+ rule = &integration.ReactionRules[i]
+ break
+ }
+ }
+ if rule == nil || event.ItemUser == "" || event.ItemUser == event.User {
+ return
+ }
+ channel, thread := event.Item.Channel, event.Item.TS
+ locale := integration.Locale
+ reply := func(text string, committed bool) {
+ h.conversationEphemeral(w, r, channel, event.User, thread, slack.Message{Text: text}, committed)
+ }
+ var postID string
+ if event.ItemUser == integration.Workspace.BotUserID {
+ var err error
+ postID, err = h.store.PostIDBySlackAnnounce(r.Context(), channel, thread)
+ if errors.Is(err, domain.ErrNotFound) {
+ return
+ }
+ if err != nil {
+ http.Error(w, "Post unavailable", http.StatusServiceUnavailable)
+ return
+ }
+ }
+ sender, err := h.member(r.Context(), event.User)
+ if memberMissing(err) {
+ reply(h.guidance(locale), false)
+ return
+ }
+ if err != nil {
+ http.Error(w, "Member unavailable", http.StatusServiceUnavailable)
+ return
+ }
+ if postID != "" {
+ _, _, replayed, err := h.store.CreateSlackClap(r.Context(), store.CreateSlackClapInput{
+ PostID: postID, MemberID: sender.ID, Now: h.now(),
+ Source: domain.SlackGiveSource{ChannelID: channel, MessageTS: thread, Emoji: rule.Emoji},
+ })
+ if err != nil {
+ if text := clapError(err, locale); text != "" {
+ reply(text, false)
+ } else {
+ http.Error(w, "Unable to clap", http.StatusServiceUnavailable)
+ }
+ return
+ }
+ if !replayed {
+ if remaining, err := h.store.GiveRemaining(r.Context(), sender.ID, h.now()); err == nil {
+ reply(fmt.Sprintf(localized(locale, "拍手しました(残り %d pt)", "Clapped (%d pt remaining)."), remaining), true)
+ }
+ }
+ return
+ }
+ recipient, err := h.member(r.Context(), event.ItemUser)
+ if memberMissing(err) {
+ reply(fmt.Sprintf(localized(locale, "<@%s> が見つかりません。まず Web で Peer Bonus を一度開いてもらってください。", "<@%s> is not a member. Ask them to open Peer Bonus in the browser first."), event.ItemUser), false)
+ return
+ }
+ if err != nil {
+ http.Error(w, "Member unavailable", http.StatusServiceUnavailable)
+ return
+ }
+ if recipient.ID == sender.ID {
+ return
+ }
+ var values []string
+ if rule.ValueKey != nil {
+ values = []string{*rule.ValueKey}
+ }
+ _, replayed, err := h.store.CreateSlackPosts(r.Context(), store.CreateSlackPostsInput{
+ SenderID: sender.ID, RecipientIDs: []string{recipient.ID}, Points: rule.Points, Values: values, Now: h.now(),
+ Message: fmt.Sprintf(localized(locale, ":%s: Slack のメッセージへのリアクション", ":%s: Reaction to a Slack message"), rule.Emoji),
+ Source: h.giveSource(r.Context(), channel, thread, rule.Emoji),
+ })
+ if err != nil {
+ if _, text := postError(err, locale); text != "" {
+ reply(text, false)
+ } else {
+ http.Error(w, "Unable to give points", http.StatusServiceUnavailable)
+ }
+ return
+ }
+ if !replayed {
+ h.successReply(r.Context(), integration, channel, thread, giveReplyText(event.User, slackMentions([]string{event.ItemUser}), rule.Points))
+ }
+}
diff --git a/cmd/server/internal/slackinbound/events_test.go b/cmd/server/internal/slackinbound/events_test.go
new file mode 100644
index 0000000..0210210
--- /dev/null
+++ b/cmd/server/internal/slackinbound/events_test.go
@@ -0,0 +1,508 @@
+package slackinbound
+
+import (
+ "context"
+ "encoding/json"
+ "errors"
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "testing"
+ "time"
+
+ "github.com/appthrust/peerbonus/cmd/server/internal/domain"
+ "github.com/appthrust/peerbonus/cmd/server/internal/slack"
+ "github.com/appthrust/peerbonus/cmd/server/internal/slackinbound/slackinboundtest"
+ "github.com/appthrust/peerbonus/cmd/server/internal/store"
+ "github.com/stretchr/testify/require"
+)
+
+func (s *fakeStore) LinkMemberSlackUser(_ context.Context, memberID, userID string, _ time.Time) error {
+ s.links = append(s.links, memberID+":"+userID)
+ return s.linkErr
+}
+func (s *fakeStore) CreateSlackPosts(_ context.Context, in store.CreateSlackPostsInput) ([]domain.Post, bool, error) {
+ s.slackPosts = append(s.slackPosts, in)
+ posts := make([]domain.Post, len(in.RecipientIDs))
+ for i, id := range in.RecipientIDs {
+ posts[i] = domain.Post{ID: "post-" + id, Points: in.Points, Message: in.Message}
+ for _, member := range s.slackMembers {
+ if member.ID == id {
+ posts[i].Recipient = member
+ }
+ }
+ }
+ return posts, s.replayed, s.postErr
+}
+func (s *fakeStore) CreateSlackClap(_ context.Context, in store.CreateSlackClapInput) (domain.Clap, domain.Post, bool, error) {
+ s.slackClaps = append(s.slackClaps, in)
+ return domain.Clap{ID: "clap"}, domain.Post{ID: in.PostID}, s.replayed, s.clapErr
+}
+func (s *fakeStore) PostIDBySlackAnnounce(_ context.Context, channel, ts string) (string, error) {
+ s.announceLookups = append(s.announceLookups, channel+":"+ts)
+ return s.announcePost, s.announceErr
+}
+func (s *fakeStore) CreateSlackPendingGive(_ context.Context, in domain.SlackPendingGive, now time.Time) (domain.SlackPendingGive, bool, error) {
+ s.pendingCreates = append(s.pendingCreates, in)
+ if s.pending.ID != "" {
+ return s.pending, false, s.pendingCreateErr
+ }
+ in.ID, in.ExpiresAt = "pending-1", now.Add(domain.SlackPendingGiveTTL)
+ s.pending = in
+ return in, true, s.pendingCreateErr
+}
+func (s *fakeStore) SlackPendingGive(_ context.Context, id string, now time.Time) (domain.SlackPendingGive, error) {
+ s.pendingReads = append(s.pendingReads, id)
+ if s.pendingErr != nil {
+ return domain.SlackPendingGive{}, s.pendingErr
+ }
+ if s.pending.ID != id || !now.Before(s.pending.ExpiresAt) {
+ return domain.SlackPendingGive{}, domain.ErrSlackPendingGiveGone
+ }
+ return s.pending, nil
+}
+func (s *fakeStore) DeleteSlackPendingGive(_ context.Context, id, senderID string) error {
+ s.pendingDeletes = append(s.pendingDeletes, id+":"+senderID)
+ return s.pendingDeleteErr
+}
+func (s *fakeSlack) UserInfo(_ context.Context, user string) (slack.User, error) {
+ s.userInfoCalls = append(s.userInfoCalls, user)
+ if s.userInfoErr != nil {
+ return slack.User{}, s.userInfoErr
+ }
+ if info, ok := s.userInfo[user]; ok {
+ return info, nil
+ }
+ return slack.User{}, slack.ErrUserNotFound
+}
+func (s *fakeSlack) Permalink(_ context.Context, channel, ts string) (string, error) {
+ s.permalinkCalls = append(s.permalinkCalls, channel+":"+ts)
+ return s.permalink, s.permalinkErr
+}
+func (s *fakeSlack) PostMessage(_ context.Context, channel string, message slack.Message) (string, error) {
+ s.postChannels = append(s.postChannels, channel)
+ s.posted = append(s.posted, message)
+ return "reply-ts", s.postErr
+}
+
+func conversationFixture() (*fakeStore, *fakeSlack, Options) {
+ s, client, o := fixture()
+ s.integration.GiveFromSlack = false
+ s.integration.GiveInConversation = true
+ s.integration.Workspace.BotUserID = "UBOT"
+ s.integration.MentionPointChoices = []int{10, 30, 50}
+ s.integration.ReactionRules = []domain.SlackReactionRule{{Emoji: "pb-10", Points: 10, ValueKey: new("care")}}
+ s.slackMembers = map[string]domain.Member{
+ "U123": {ID: "sender", SlackUserID: new("U123")},
+ "U456": {ID: "recipient", SlackUserID: new("U456")},
+ "U789": {ID: "recipient-2", SlackUserID: new("U789")},
+ }
+ client.permalink = "https://workspace.slack.com/archives/C123/p123"
+ return s, client, o
+}
+
+func mentionEvent() eventEnvelope {
+ return eventEnvelope{Type: "event_callback", TeamID: "T123", Event: slackEvent{
+ Type: "app_mention", User: "U123", Channel: "C123", TS: "123.456", Text: "<@UBOT> <@U456> 30 Thanks for helping",
+ }}
+}
+
+func reactionEvent() eventEnvelope {
+ p := eventEnvelope{Type: "event_callback", TeamID: "T123", Event: slackEvent{
+ Type: "reaction_added", User: "U123", Reaction: "pb-10", ItemUser: "U456",
+ }}
+ p.Event.Item.Type, p.Event.Item.Channel, p.Event.Item.TS = "message", "C123", "123.456"
+ return p
+}
+
+func eventRequest(t *testing.T, envelope eventEnvelope) *http.Request {
+ t.Helper()
+ body, err := json.Marshal(envelope)
+ require.NoError(t, err)
+ return slackinboundtest.SignedJSONRequest(testSecret, testNow, "/slack/events", body)
+}
+
+func serveEvent(t *testing.T, h http.Handler, envelope eventEnvelope) *httptest.ResponseRecorder {
+ t.Helper()
+ w := httptest.NewRecorder()
+ h.ServeHTTP(w, eventRequest(t, envelope))
+ return w
+}
+
+func assertNoConversationWork(t *testing.T, s *fakeStore, client *fakeSlack) {
+ t.Helper()
+ require.Empty(t, s.memberLookups)
+ require.Empty(t, s.emailLookups)
+ require.Empty(t, s.slackPosts)
+ require.Empty(t, s.slackClaps)
+ require.Empty(t, s.pendingCreates)
+ require.Empty(t, s.announceLookups)
+ require.Empty(t, s.remainingMember)
+ require.Empty(t, client.userInfoCalls)
+ require.Empty(t, client.permalinkCalls)
+ require.Empty(t, client.messages)
+ require.Empty(t, client.posted)
+ require.Empty(t, client.view)
+}
+
+func TestConversationEventGates(t *testing.T) {
+ t.Run("challenge while disabled and retried", func(t *testing.T) {
+ s, client, o := conversationFixture()
+ s.integration.GiveInConversation = false
+ h := New(o)
+ for range 2 {
+ w := serveEvent(t, h, eventEnvelope{Type: "url_verification", Challenge: "verify-me"})
+ require.Equal(t, http.StatusOK, w.Code)
+ require.JSONEq(t, `{"challenge":"verify-me"}`, w.Body.String())
+ }
+ assertNoConversationWork(t, s, client)
+ })
+ for _, name := range []string{"disabled", "wrong team", "bot user", "bot id", "subtype", "unknown event", "unknown emoji", "self reaction", "empty recipient", "non-message reaction"} {
+ t.Run(name, func(t *testing.T) {
+ s, client, o := conversationFixture()
+ p := mentionEvent()
+ status := http.StatusOK
+ switch name {
+ case "disabled":
+ s.integration.GiveInConversation = false
+ case "wrong team":
+ p.TeamID = "Tother"
+ s.integration.GiveInConversation = false
+ status = http.StatusForbidden
+ case "bot user":
+ p.Event.User = "UBOT"
+ case "bot id":
+ p.Event.BotID = "B123"
+ case "subtype":
+ p.Event.Subtype = "message_changed"
+ case "unknown event":
+ p.Event.Type = "message"
+ case "unknown emoji":
+ p = reactionEvent()
+ p.Event.Reaction = "heart"
+ case "self reaction":
+ p = reactionEvent()
+ p.Event.ItemUser = p.Event.User
+ case "empty recipient":
+ p = reactionEvent()
+ p.Event.ItemUser = ""
+ case "non-message reaction":
+ p = reactionEvent()
+ p.Event.Item.Type = "file"
+ }
+ w := serveEvent(t, New(o), p)
+ require.Equal(t, status, w.Code)
+ if status == http.StatusOK {
+ require.Empty(t, w.Body.String())
+ }
+ assertNoConversationWork(t, s, client)
+ })
+ }
+ for _, name := range []string{"secret", "store", "client", "workspace"} {
+ t.Run("missing "+name, func(t *testing.T) {
+ s, _, o := conversationFixture()
+ switch name {
+ case "secret":
+ o.SigningSecret = ""
+ case "store":
+ o.Store = nil
+ case "client":
+ o.Slack = nil
+ case "workspace":
+ s.integration.Workspace = nil
+ }
+ r := eventRequest(t, mentionEvent())
+ r.Body = unreadBody{t}
+ w := httptest.NewRecorder()
+ New(o).ServeHTTP(w, r)
+ require.Equal(t, http.StatusNotFound, w.Code)
+ })
+ }
+}
+
+func TestConversationEventHTTPBoundary(t *testing.T) {
+ for _, name := range []string{"bad signature", "oversized", "wrong media", "invalid json", "method"} {
+ t.Run(name, func(t *testing.T) {
+ s, client, o := conversationFixture()
+ r := eventRequest(t, mentionEvent())
+ status := http.StatusUnauthorized
+ switch name {
+ case "bad signature":
+ r.Header.Set("X-Slack-Signature", "v0="+strings.Repeat("0", 64))
+ case "oversized":
+ r = slackinboundtest.SignedJSONRequest(testSecret, testNow, "/slack/events", []byte(strings.Repeat("x", maxBodyBytes+1)))
+ case "wrong media":
+ r.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+ status = http.StatusUnsupportedMediaType
+ case "invalid json":
+ r = slackinboundtest.SignedJSONRequest(testSecret, testNow, "/slack/events", []byte("{"))
+ status = http.StatusBadRequest
+ case "method":
+ r.Method = http.MethodGet
+ status = http.StatusMethodNotAllowed
+ }
+ w := httptest.NewRecorder()
+ New(o).ServeHTTP(w, r)
+ require.Equal(t, status, w.Code)
+ assertNoConversationWork(t, s, client)
+ })
+ }
+}
+
+func TestConversationMentionWritesAndReplies(t *testing.T) {
+ for _, name := range []string{"new thread", "existing thread", "announce channel", "different announce channel", "announcements disabled", "permalink failure", "reply failure", "multiple recipients", "durable replay"} {
+ t.Run(name, func(t *testing.T) {
+ s, client, o := conversationFixture()
+ p := mentionEvent()
+ thread := p.Event.TS
+ switch name {
+ case "existing thread":
+ p.Event.ThreadTS = "100.000"
+ thread = p.Event.ThreadTS
+ case "announce channel":
+ s.integration.AnnouncePosts = true
+ s.integration.AnnounceChannel = &domain.SlackChannel{ID: "C123"}
+ case "different announce channel":
+ s.integration.AnnouncePosts = true
+ s.integration.AnnounceChannel = &domain.SlackChannel{ID: "Cother"}
+ case "announcements disabled":
+ s.integration.AnnounceChannel = &domain.SlackChannel{ID: "C123"}
+ case "permalink failure":
+ client.permalinkErr = errors.New("unavailable")
+ case "reply failure":
+ client.postErr = errors.New("unavailable")
+ case "multiple recipients":
+ p.Event.Text += " <@U789>"
+ case "durable replay":
+ s.replayed = true
+ }
+ h := New(o)
+ w := serveEvent(t, h, p)
+ require.Equal(t, http.StatusOK, w.Code)
+ require.Empty(t, w.Body.String())
+ require.Len(t, s.slackPosts, 1)
+ in := s.slackPosts[0]
+ require.Equal(t, "sender", in.SenderID)
+ require.Equal(t, 30, in.Points)
+ require.Equal(t, "Thanks for helping", in.Message)
+ require.Equal(t, testNow, in.Now)
+ require.Equal(t, "C123", in.Source.ChannelID)
+ require.Equal(t, p.Event.TS, in.Source.MessageTS)
+ require.Empty(t, in.Source.Emoji)
+ require.Empty(t, in.PendingID)
+ if name == "permalink failure" {
+ require.Nil(t, in.Source.Permalink)
+ } else {
+ require.Equal(t, client.permalink, *in.Source.Permalink)
+ }
+ if name == "multiple recipients" {
+ require.Equal(t, []string{"recipient", "recipient-2"}, in.RecipientIDs)
+ } else {
+ require.Equal(t, []string{"recipient"}, in.RecipientIDs)
+ }
+ if name == "announce channel" || name == "durable replay" {
+ require.Empty(t, client.posted)
+ } else {
+ require.Len(t, client.posted, 1)
+ require.Equal(t, thread, client.posted[0].ThreadTS)
+ text := "🎉 <@U123> → <@U456> 30 pt"
+ if name == "multiple recipients" {
+ text = "🎉 <@U123> → <@U456> <@U789> 30 pt"
+ }
+ require.Equal(t, text, client.posted[0].Text)
+ }
+ replies := len(client.posted)
+ w = serveEvent(t, h, p)
+ require.Equal(t, http.StatusOK, w.Code)
+ require.Empty(t, w.Body.String())
+ require.Len(t, s.slackPosts, 1)
+ require.Len(t, client.posted, replies)
+ require.Empty(t, client.messages)
+ })
+ }
+}
+
+func TestConversationMentionBusinessErrors(t *testing.T) {
+ for _, name := range []string{"sender missing", "no recipient", "no message", "too many recipients", "self", "recipient missing", "insufficient", "closed", "validation"} {
+ t.Run(name, func(t *testing.T) {
+ s, client, o := conversationFixture()
+ p := mentionEvent()
+ want := "Use @Peer Bonus"
+ switch name {
+ case "sender missing":
+ delete(s.slackMembers, "U123")
+ want = "Open Peer Bonus"
+ case "no recipient":
+ p.Event.Text = "<@UBOT> 30 Thanks"
+ case "no message":
+ p.Event.Text = "<@UBOT> <@U456> 30"
+ case "too many recipients":
+ p.Event.Text += " <@U1> <@U2> <@U3> <@U4> <@U5>"
+ case "self":
+ p.Event.Text = "<@UBOT> <@U123> 30 Thanks"
+ case "recipient missing":
+ delete(s.slackMembers, "U456")
+ want = "<@U456> is not a member"
+ case "insufficient":
+ s.postErr = &domain.InsufficientPointsError{Remaining: 2, Required: 30}
+ want = "2 pt remaining"
+ case "closed":
+ s.postErr = domain.ErrPeriodClosed
+ want = "period is closed"
+ case "validation":
+ s.postErr = &domain.ValidationError{Field: "points", Msg: "Too many points"}
+ want = "Too many points"
+ }
+ w := serveEvent(t, New(o), p)
+ require.Equal(t, http.StatusOK, w.Code)
+ require.Empty(t, w.Body.String())
+ require.Len(t, client.messages, 1)
+ require.Contains(t, client.messages[0].Text, want)
+ require.Equal(t, p.Event.TS, client.messages[0].ThreadTS)
+ require.Equal(t, p.Event.User, client.user)
+ require.Empty(t, client.posted)
+ if s.postErr == nil {
+ require.Empty(t, s.slackPosts)
+ }
+ })
+ }
+}
+
+func TestConversationMemberResolution(t *testing.T) {
+ for _, name := range []string{"linked", "bot", "deleted", "empty email", "missing member", "slack error", "link error"} {
+ t.Run(name, func(t *testing.T) {
+ s, client, o := conversationFixture()
+ delete(s.slackMembers, "U123")
+ user := slack.User{ID: "U123", Email: "verified@example.test"}
+ s.emailMember = domain.Member{ID: "sender"}
+ status := http.StatusOK
+ switch name {
+ case "bot":
+ user.IsBot = true
+ case "deleted":
+ user.Deleted = true
+ case "empty email":
+ user.Email = ""
+ case "missing member":
+ s.emailErr = domain.ErrNotFound
+ case "slack error":
+ client.userInfoErr = errors.New("unavailable")
+ status = http.StatusServiceUnavailable
+ case "link error":
+ s.linkErr = errors.New("unavailable")
+ status = http.StatusServiceUnavailable
+ }
+ client.userInfo = map[string]slack.User{"U123": user}
+ w := serveEvent(t, New(o), mentionEvent())
+ require.Equal(t, status, w.Code)
+ require.Equal(t, []string{"U123"}, client.userInfoCalls)
+ if name == "linked" {
+ require.Equal(t, []string{"verified@example.test"}, s.emailLookups)
+ require.Equal(t, []string{"sender:U123"}, s.links)
+ require.Len(t, s.slackPosts, 1)
+ } else {
+ require.Empty(t, s.slackPosts)
+ }
+ if name == "bot" || name == "deleted" || name == "empty email" {
+ require.Empty(t, s.emailLookups)
+ require.Empty(t, s.links)
+ }
+ })
+ }
+}
+
+func TestConversationTransientFailureCanRetry(t *testing.T) {
+ for _, name := range []string{"store", "ephemeral"} {
+ t.Run(name, func(t *testing.T) {
+ s, client, o := conversationFixture()
+ p := mentionEvent()
+ if name == "store" {
+ s.postErr = errors.New("sensitive database detail")
+ } else {
+ p.Event.Text = "<@UBOT>"
+ client.ephemeralErr = errors.New("Slack unavailable")
+ }
+ h := New(o)
+ w := serveEvent(t, h, p)
+ require.GreaterOrEqual(t, w.Code, 500)
+ require.NotContains(t, w.Body.String(), "sensitive")
+ s.postErr, client.ephemeralErr = nil, nil
+ w = serveEvent(t, h, p)
+ require.Equal(t, http.StatusOK, w.Code)
+ if name == "store" {
+ require.Len(t, s.slackPosts, 2)
+ require.Len(t, client.posted, 1)
+ } else {
+ require.Len(t, client.messages, 2)
+ }
+ })
+ }
+}
+
+func TestConversationReactionGiveAndAnnounceClap(t *testing.T) {
+ for _, name := range []string{"give", "normalized", "announce", "unrelated bot message", "clap replay", "clap domain error", "clap transient", "clap reply failure", "clap balance failure"} {
+ t.Run(name, func(t *testing.T) {
+ s, client, o := conversationFixture()
+ p := reactionEvent()
+ if strings.HasPrefix(name, "clap") || name == "announce" || name == "unrelated bot message" {
+ p.Event.ItemUser = "UBOT"
+ s.announcePost = "announced-post"
+ }
+ switch name {
+ case "normalized":
+ p.Event.Reaction = ":PB-10::skin-tone-3:"
+ case "unrelated bot message":
+ s.announceErr = domain.ErrNotFound
+ case "clap replay":
+ s.replayed = true
+ case "clap domain error":
+ s.clapErr = domain.ErrOwnPost
+ case "clap transient":
+ s.clapErr = errors.New("unavailable")
+ case "clap reply failure":
+ client.ephemeralErr = errors.New("unavailable")
+ case "clap balance failure":
+ s.remainingErr = errors.New("unavailable")
+ }
+ w := serveEvent(t, New(o), p)
+ if name == "clap transient" {
+ require.Equal(t, http.StatusServiceUnavailable, w.Code)
+ return
+ }
+ require.Equal(t, http.StatusOK, w.Code)
+ require.Empty(t, w.Body.String())
+ if name == "give" || name == "normalized" {
+ require.Len(t, s.slackPosts, 1)
+ in := s.slackPosts[0]
+ require.Equal(t, 10, in.Points)
+ require.Equal(t, []string{"recipient"}, in.RecipientIDs)
+ require.Equal(t, []string{"care"}, in.Values)
+ require.Equal(t, ":pb-10: Reaction to a Slack message", in.Message)
+ require.Equal(t, domain.SlackGiveSource{ChannelID: "C123", MessageTS: "123.456", Emoji: "pb-10", Permalink: &client.permalink}, in.Source)
+ require.Len(t, client.posted, 1)
+ require.Equal(t, "123.456", client.posted[0].ThreadTS)
+ } else {
+ require.Empty(t, s.slackPosts)
+ require.Empty(t, client.posted)
+ if name == "unrelated bot message" {
+ require.Empty(t, s.memberLookups)
+ require.Empty(t, s.slackClaps)
+ require.Empty(t, client.messages)
+ return
+ }
+ require.Equal(t, []store.CreateSlackClapInput{{PostID: "announced-post", MemberID: "sender", Now: testNow, Source: domain.SlackGiveSource{ChannelID: "C123", MessageTS: "123.456", Emoji: "pb-10"}}}, s.slackClaps)
+ if name == "clap replay" || name == "clap balance failure" {
+ require.Empty(t, client.messages)
+ } else {
+ require.Len(t, client.messages, 1)
+ }
+ if name == "announce" {
+ require.Equal(t, "Clapped (398 pt remaining).", client.messages[0].Text)
+ }
+ if name == "clap domain error" {
+ require.Contains(t, client.messages[0].Text, "cannot clap")
+ }
+ }
+ })
+ }
+}
diff --git a/cmd/server/internal/slackinbound/handler.go b/cmd/server/internal/slackinbound/handler.go
index 19de0ea..0e491e8 100644
--- a/cmd/server/internal/slackinbound/handler.go
+++ b/cmd/server/internal/slackinbound/handler.go
@@ -1,6 +1,6 @@
-// Package slackinbound handles signed Slack commands, interactions, and options.
-// It reuses the application's ledger writes; Slack request replay protection is
-// process-local, while view/action idempotency is persisted by the store.
+// Package slackinbound handles signed Slack commands, interactions, options, and
+// conversation events. Ledger writes persist event idempotency; the signature
+// replay cache suppresses duplicate requests and releases failed event attempts.
package slackinbound
import (
@@ -29,6 +29,13 @@ type Store interface {
SearchMembers(context.Context, string, string, int) ([]domain.Member, error)
CreatePost(context.Context, store.CreatePostInput) (domain.Post, bool, error)
CreateClap(context.Context, store.CreateClapInput) (domain.Clap, domain.Post, bool, error)
+ CreateSlackPosts(context.Context, store.CreateSlackPostsInput) ([]domain.Post, bool, error)
+ CreateSlackClap(context.Context, store.CreateSlackClapInput) (domain.Clap, domain.Post, bool, error)
+ PostIDBySlackAnnounce(context.Context, string, string) (string, error)
+ CreateSlackPendingGive(context.Context, domain.SlackPendingGive, time.Time) (domain.SlackPendingGive, bool, error)
+ SlackPendingGive(context.Context, string, time.Time) (domain.SlackPendingGive, error)
+ DeleteSlackPendingGive(context.Context, string, string) error
+ LinkMemberSlackUser(context.Context, string, string, time.Time) error
Program(context.Context) (domain.Program, error)
CurrentPeriod(context.Context, time.Time) (domain.Period, error)
GiveRemaining(context.Context, string, time.Time) (int, error)
@@ -38,6 +45,9 @@ type Store interface {
type Slack interface {
OpenView(context.Context, string, json.RawMessage) error
PostEphemeral(context.Context, string, string, slack.Message) error
+ PostMessage(context.Context, string, slack.Message) (string, error)
+ UserInfo(context.Context, string) (slack.User, error)
+ Permalink(context.Context, string, string) (string, error)
}
type Options struct {
@@ -61,10 +71,9 @@ type handler struct {
replays replaySet
}
-// New serves POST /slack/{commands,interactions,options}, without OIDC. The
-// feature gate runs before reading any body; enabled requests are limited to
-// 64 KiB and authenticated against the exact raw form body. Every operation
-// shares a 2.5 second context, including synchronous views.open.
+// New serves POST /slack/{commands,interactions,options,events}, without OIDC.
+// Gates run before reading the body; requests are limited to 64 KiB and signed
+// over the exact raw form or JSON body. Each request shares a 2.5 second budget.
func New(o Options) http.Handler {
if o.Now == nil {
o.Now = time.Now
@@ -94,12 +103,22 @@ func (h *handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
http.Error(w, "Slack integration unavailable", http.StatusServiceUnavailable)
return
}
- if !integration.GiveFromSlack || integration.Workspace == nil {
+ if integration.Workspace == nil {
http.NotFound(w, r)
return
}
switch r.URL.Path {
- case "/slack/commands", "/slack/interactions", "/slack/options":
+ case "/slack/commands", "/slack/options":
+ if !integration.GiveFromSlack {
+ http.NotFound(w, r)
+ return
+ }
+ case "/slack/interactions":
+ if !integration.GiveFromSlack && !integration.GiveInConversation {
+ http.NotFound(w, r)
+ return
+ }
+ case "/slack/events":
default:
http.NotFound(w, r)
return
@@ -114,6 +133,16 @@ func (h *handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
http.Error(w, "Unauthorized", http.StatusUnauthorized)
return
}
+ if r.URL.Path == "/slack/events" {
+ response := &eventResponse{ResponseWriter: w}
+ defer func() {
+ if response.status >= 500 {
+ h.replays.forget(r.Header.Get("X-Slack-Request-Timestamp") + ":" + r.Header.Get("X-Slack-Signature"))
+ }
+ }()
+ h.events(response, r, integration, body)
+ return
+ }
mediaType, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
if err != nil || mediaType != "application/x-www-form-urlencoded" {
http.Error(w, "Expected form body", http.StatusUnsupportedMediaType)
@@ -144,7 +173,7 @@ func (h *handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
if r.URL.Path == "/slack/options" {
h.options(w, r, payload)
} else {
- h.interact(w, r, integration.Locale, payload)
+ h.interact(w, r, integration, payload)
}
}
@@ -157,9 +186,26 @@ func (h *handler) member(ctx context.Context, userID string) (domain.Member, err
if userID == "" {
return domain.Member{}, domain.ErrNotFound
}
- // Neither command user_name nor user-supplied email establishes identity.
- // The outbound worker owns the Slack-user cache; no users.info scope exists.
- return h.store.MemberBySlackUser(ctx, userID)
+ // Only Slack's authenticated users.info email may establish a cache miss.
+ member, err := h.store.MemberBySlackUser(ctx, userID)
+ if !memberMissing(err) {
+ return member, err
+ }
+ user, err := h.slack.UserInfo(ctx, userID)
+ if errors.Is(err, slack.ErrUserNotFound) || (err == nil && (user.IsBot || user.Deleted || user.Email == "")) {
+ return domain.Member{}, domain.ErrNotFound
+ }
+ if err != nil {
+ return domain.Member{}, err
+ }
+ member, err = h.store.MemberByEmail(ctx, user.Email)
+ if err != nil {
+ return domain.Member{}, err
+ }
+ if err := h.store.LinkMemberSlackUser(ctx, member.ID, userID, h.now()); err != nil {
+ return domain.Member{}, err
+ }
+ return member, nil
}
func writeJSON(w http.ResponseWriter, body any) {
diff --git a/cmd/server/internal/slackinbound/handler_test.go b/cmd/server/internal/slackinbound/handler_test.go
index 8e3e6f4..131bfd8 100644
--- a/cmd/server/internal/slackinbound/handler_test.go
+++ b/cmd/server/internal/slackinbound/handler_test.go
@@ -27,23 +27,43 @@ const testSecret = "inbound-test-secret"
var testNow = time.Date(2026, 10, 20, 12, 0, 0, 0, time.UTC)
type fakeStore struct {
- integration domain.SlackIntegration
- integrationErr error
- member domain.Member
- memberErr error
- memberLookups []string
- program domain.Program
- period domain.Period
- remaining int
- remainingMember string
- remainingNow time.Time
- posts []store.CreatePostInput
- postErr error
- claps []store.CreateClapInput
- clapErr error
- searchQ, searchExclude string
- searchLimit int
- members []domain.Member
+ integration domain.SlackIntegration
+ integrationErr error
+ member domain.Member
+ memberErr error
+ memberLookups []string
+ program domain.Program
+ period domain.Period
+ remaining int
+ remainingMember string
+ remainingNow time.Time
+ posts []store.CreatePostInput
+ postErr error
+ claps []store.CreateClapInput
+ clapErr error
+ searchQ, searchExclude string
+ searchLimit int
+ members []domain.Member
+ slackMembers map[string]domain.Member
+ emailMember domain.Member
+ emailErr error
+ emailLookups []string
+ links []string
+ linkErr error
+ slackPosts []store.CreateSlackPostsInput
+ slackClaps []store.CreateSlackClapInput
+ replayed bool
+ pending domain.SlackPendingGive
+ pendingCreates []domain.SlackPendingGive
+ pendingReads []string
+ pendingErr error
+ pendingCreateErr error
+ pendingDeletes []string
+ pendingDeleteErr error
+ announcePost string
+ announceErr error
+ announceLookups []string
+ periodErr, remainingErr error
}
func (s *fakeStore) SlackIntegration(context.Context) (domain.SlackIntegration, error) {
@@ -51,10 +71,18 @@ func (s *fakeStore) SlackIntegration(context.Context) (domain.SlackIntegration,
}
func (s *fakeStore) MemberBySlackUser(_ context.Context, user string) (domain.Member, error) {
s.memberLookups = append(s.memberLookups, user)
+ if s.slackMembers != nil {
+ member, ok := s.slackMembers[user]
+ if !ok {
+ return domain.Member{}, domain.ErrNotFound
+ }
+ return member, nil
+ }
return s.member, s.memberErr
}
-func (s *fakeStore) MemberByEmail(context.Context, string) (domain.Member, error) {
- panic("an inbound email must never establish identity")
+func (s *fakeStore) MemberByEmail(_ context.Context, email string) (domain.Member, error) {
+ s.emailLookups = append(s.emailLookups, email)
+ return s.emailMember, s.emailErr
}
func (s *fakeStore) MemberByID(context.Context, string) (domain.Member, error) {
panic("cached Slack identity already supplies the member")
@@ -73,20 +101,29 @@ func (s *fakeStore) CreateClap(_ context.Context, in store.CreateClapInput) (dom
}
func (s *fakeStore) Program(context.Context) (domain.Program, error) { return s.program, nil }
func (s *fakeStore) CurrentPeriod(context.Context, time.Time) (domain.Period, error) {
- return s.period, nil
+ return s.period, s.periodErr
}
func (s *fakeStore) GiveRemaining(_ context.Context, member string, now time.Time) (int, error) {
s.remainingMember, s.remainingNow = member, now
- return s.remaining, nil
+ return s.remaining, s.remainingErr
}
type fakeSlack struct {
- trigger string
- view json.RawMessage
- deadline time.Time
- openErr error
- channel, user string
- messages []slack.Message
+ trigger string
+ view json.RawMessage
+ deadline time.Time
+ openErr error
+ channel, user string
+ messages []slack.Message
+ userInfo map[string]slack.User
+ userInfoErr error
+ userInfoCalls []string
+ posted []slack.Message
+ postChannels []string
+ postErr, ephemeralErr error
+ permalink string
+ permalinkErr error
+ permalinkCalls []string
}
func (s *fakeSlack) OpenView(ctx context.Context, trigger string, view json.RawMessage) error {
@@ -97,7 +134,7 @@ func (s *fakeSlack) OpenView(ctx context.Context, trigger string, view json.RawM
func (s *fakeSlack) PostEphemeral(_ context.Context, channel, user string, message slack.Message) error {
s.channel, s.user = channel, user
s.messages = append(s.messages, message)
- return nil
+ return s.ephemeralErr
}
type roundTripFunc func(*http.Request) (*http.Response, error)
diff --git a/cmd/server/internal/slackinbound/http_test.go b/cmd/server/internal/slackinbound/http_test.go
index 5db356a..53f2fbd 100644
--- a/cmd/server/internal/slackinbound/http_test.go
+++ b/cmd/server/internal/slackinbound/http_test.go
@@ -37,7 +37,7 @@ func TestFormAndRouteBoundary(t *testing.T) {
status int
}{
{"method", "/slack/commands", "GET", "application/x-www-form-urlencoded", "", 405},
- {"unknown path", "/slack/events", "POST", "application/x-www-form-urlencoded", "", 404},
+ {"unknown path", "/slack/unknown", "POST", "application/x-www-form-urlencoded", "", 404},
{"json", "/slack/commands", "POST", "application/json", `{}`, 415},
{"bad form", "/slack/commands", "POST", "application/x-www-form-urlencoded", "%XX", 400},
{"bad payload", "/slack/interactions", "POST", "application/x-www-form-urlencoded", "payload=%7B", 400},
diff --git a/cmd/server/internal/slackinbound/interactions.go b/cmd/server/internal/slackinbound/interactions.go
index 2d55df0..0fae238 100644
--- a/cmd/server/internal/slackinbound/interactions.go
+++ b/cmd/server/internal/slackinbound/interactions.go
@@ -17,14 +17,15 @@ type slackID struct {
}
type interaction struct {
- Type string `json:"type"`
- Team slackID `json:"team"`
- Enterprise slackID `json:"enterprise"`
- User slackID `json:"user"`
- Channel slackID `json:"channel"`
- TriggerID string `json:"trigger_id"`
- Value string `json:"value"`
- Actions []struct {
+ Type string `json:"type"`
+ Team slackID `json:"team"`
+ Enterprise slackID `json:"enterprise"`
+ User slackID `json:"user"`
+ Channel slackID `json:"channel"`
+ TriggerID string `json:"trigger_id"`
+ Value string `json:"value"`
+ ResponseURL string `json:"response_url"`
+ Actions []struct {
ActionID string `json:"action_id"`
Value string `json:"value"`
} `json:"actions"`
@@ -43,11 +44,26 @@ type actionValue struct {
SelectedOptions []selectOption `json:"selected_options"`
}
-func (h *handler) interact(w http.ResponseWriter, r *http.Request, locale domain.SlackLocale, payload interaction) {
+func (h *handler) interact(w http.ResponseWriter, r *http.Request, integration domain.SlackIntegration, payload interaction) {
+ locale := integration.Locale
if payload.Type != "view_submission" && payload.Type != "block_actions" {
http.Error(w, "Unsupported interaction", http.StatusBadRequest)
return
}
+ if payload.Type == "block_actions" {
+ for _, action := range payload.Actions {
+ if action.ActionID == "peerbonus_give_points" || action.ActionID == "peerbonus_give_cancel" {
+ if integration.GiveInConversation {
+ h.pendingAction(w, r, integration, payload, action.ActionID, action.Value)
+ }
+ return
+ }
+ }
+ }
+ if !integration.GiveFromSlack {
+ w.WriteHeader(http.StatusOK)
+ return
+ }
member, err := h.member(r.Context(), payload.User.ID)
if memberMissing(err) {
if payload.Type == "view_submission" {
@@ -172,18 +188,8 @@ func (h *handler) clap(w http.ResponseWriter, r *http.Request, locale domain.Sla
IdempotencyKey: "slack:action:" + payload.TriggerID,
})
if err != nil {
- var insufficient *domain.InsufficientPointsError
- var text string
- switch {
- case errors.Is(err, domain.ErrOwnPost):
- text = localized(locale, "自分が贈った・受け取った投稿には拍手できません。", "You cannot clap a post you sent or received.")
- case errors.As(err, &insufficient):
- text = fmt.Sprintf(localized(locale, "ポイントが足りません(残り %d pt)。", "Not enough points (%d pt remaining)."), insufficient.Remaining)
- case errors.Is(err, domain.ErrPeriodClosed):
- text = localized(locale, "この期間は締められているため拍手できません。", "This period is closed; you cannot clap this post.")
- case errors.Is(err, domain.ErrNotFound):
- text = localized(locale, "投稿が見つかりません。", "This post is no longer available.")
- default:
+ text := clapError(err, locale)
+ if text == "" {
http.Error(w, "Unable to clap", http.StatusServiceUnavailable)
return
}
@@ -202,6 +208,22 @@ func (h *handler) clap(w http.ResponseWriter, r *http.Request, locale domain.Sla
w.WriteHeader(http.StatusOK)
}
+func clapError(err error, locale domain.SlackLocale) string {
+ var insufficient *domain.InsufficientPointsError
+ switch {
+ case errors.Is(err, domain.ErrOwnPost):
+ return localized(locale, "自分が贈った・受け取った投稿には拍手できません。", "You cannot clap a post you sent or received.")
+ case errors.As(err, &insufficient):
+ return fmt.Sprintf(localized(locale, "ポイントが足りません(残り %d pt)。", "Not enough points (%d pt remaining)."), insufficient.Remaining)
+ case errors.Is(err, domain.ErrPeriodClosed):
+ return localized(locale, "この期間は締められているため拍手できません。", "This period is closed; you cannot clap this post.")
+ case errors.Is(err, domain.ErrNotFound):
+ return localized(locale, "投稿が見つかりません。", "This post is no longer available.")
+ default:
+ return ""
+ }
+}
+
func (h *handler) ephemeral(w http.ResponseWriter, r *http.Request, payload interaction, text string) {
if payload.Channel.ID == "" || payload.User.ID == "" {
http.Error(w, "Missing ephemeral recipient", http.StatusBadRequest)
diff --git a/cmd/server/internal/slackinbound/mention.go b/cmd/server/internal/slackinbound/mention.go
new file mode 100644
index 0000000..07b79c5
--- /dev/null
+++ b/cmd/server/internal/slackinbound/mention.go
@@ -0,0 +1,50 @@
+package slackinbound
+
+import (
+ "regexp"
+ "slices"
+ "strconv"
+ "strings"
+)
+
+var (
+ mentionToken = regexp.MustCompile(`^<@([UW][A-Z0-9]+)(?:\|[^>]*)?>$`)
+ slackMarkup = regexp.MustCompile(`<[^>]*>`)
+ pointToken = regexp.MustCompile(`^([0-9]+)(?:pts?|ポイント)?$`)
+ slackEscapes = strings.NewReplacer("&", "&", "<", "<", ">", ">")
+)
+
+func parseMention(text, botUserID string) (recipients []string, points *int, message string) {
+ var parts []string
+ appendText := func(text string) {
+ for _, token := range strings.Fields(text) {
+ if match := pointToken.FindStringSubmatch(token); points == nil && match != nil {
+ // Atoi saturates on overflow; the store rejects that out-of-range amount.
+ amount, _ := strconv.Atoi(match[1])
+ points = &amount
+ } else {
+ parts = append(parts, token)
+ }
+ }
+ }
+ start := 0
+ for _, span := range slackMarkup.FindAllStringIndex(text, -1) {
+ appendText(text[start:span[0]])
+ token := text[span[0]:span[1]]
+ if match := mentionToken.FindStringSubmatch(token); match != nil {
+ if match[1] != botUserID && !slices.Contains(recipients, match[1]) {
+ recipients = append(recipients, match[1])
+ }
+ } else {
+ link := token[1 : len(token)-1]
+ if _, label, ok := strings.Cut(link, "|"); ok {
+ link = label
+ }
+ parts = append(parts, link)
+ }
+ start = span[1]
+ }
+ appendText(text[start:])
+ message = strings.Join(strings.Fields(slackEscapes.Replace(strings.Join(parts, " "))), " ")
+ return
+}
diff --git a/cmd/server/internal/slackinbound/mention_test.go b/cmd/server/internal/slackinbound/mention_test.go
new file mode 100644
index 0000000..6314531
--- /dev/null
+++ b/cmd/server/internal/slackinbound/mention_test.go
@@ -0,0 +1,39 @@
+package slackinbound
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/require"
+)
+
+func TestParseMention(t *testing.T) {
+ for _, tc := range []struct {
+ name, text string
+ recipients []string
+ points *int
+ message string
+ }{
+ {"ordinary", "<@UBOT> <@U1> 30 Thanks", []string{"U1"}, new(30), "Thanks"},
+ {"order insensitive", "Thanks 30pt <@U1|Alice> <@UBOT>", []string{"U1"}, new(30), "Thanks"},
+ {"distinct in order", "<@U2> <@U1> <@U2|Bob> <@UBOT> 10pts Thanks", []string{"U2", "U1"}, new(10), "Thanks"},
+ {"Japanese suffix", "<@UBOT> <@U1> 50ポイント ありがとう", []string{"U1"}, new(50), "ありがとう"},
+ {"no points", "<@UBOT> <@U1> Thank you", []string{"U1"}, nil, "Thank you"},
+ {"word digits", "<@U1> v30 task123 30ptx 123 Thanks", []string{"U1"}, nil, "v30 task123 30ptx 123 Thanks"},
+ {"first integer only", "<@U1> 10 Thanks for 30 reviews", []string{"U1"}, new(10), "Thanks for 30 reviews"},
+ {"escapes and whitespace", "<@UBOT>\n<@U1> 30\tA & B <3 >2", []string{"U1"}, new(30), "A & B <3 >2"},
+ {"links", "<@U1> 30 Read and ", []string{"U1"}, new(30), "Read the guide and https://example.test/b"},
+ {"link label is not points", "<@U1> Thanks", []string{"U1"}, nil, "30 Thanks"},
+ {"bot only", "<@UBOT> 30 Thanks", nil, new(30), "Thanks"},
+ {"mention adjacency", "<@UBOT><@U1>30 Thanks", []string{"U1"}, new(30), "Thanks"},
+ {"escaped mention is text", "<@U1> <@U2> Thanks", []string{"U1"}, nil, "<@U2> Thanks"},
+ {"decimal is not integer", "<@U1> 3.5 Thanks", []string{"U1"}, nil, "3.5 Thanks"},
+ {"empty", "", nil, nil, ""},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ recipients, points, message := parseMention(tc.text, "UBOT")
+ require.Equal(t, tc.recipients, recipients)
+ require.Equal(t, tc.points, points)
+ require.Equal(t, tc.message, message)
+ })
+ }
+}
diff --git a/cmd/server/internal/slackinbound/pending.go b/cmd/server/internal/slackinbound/pending.go
new file mode 100644
index 0000000..c064133
--- /dev/null
+++ b/cmd/server/internal/slackinbound/pending.go
@@ -0,0 +1,170 @@
+package slackinbound
+
+import (
+ "encoding/json"
+ "errors"
+ "fmt"
+ "net/http"
+ "strconv"
+ "strings"
+
+ "github.com/appthrust/peerbonus/cmd/server/internal/domain"
+ "github.com/appthrust/peerbonus/cmd/server/internal/slack"
+ "github.com/appthrust/peerbonus/cmd/server/internal/store"
+)
+
+var mrkdwnEscaper = strings.NewReplacer("&", "&", "<", "<", ">", ">")
+
+type giveButton struct {
+ Type string `json:"type"`
+ Text plainText `json:"text"`
+ ActionID string `json:"action_id"`
+ Value string `json:"value"`
+}
+
+type giveBlock struct {
+ Type string `json:"type"`
+ Text *plainText `json:"text,omitempty"`
+ Elements []giveButton `json:"elements,omitempty"`
+}
+
+func (h *handler) promptGive(w http.ResponseWriter, r *http.Request, integration domain.SlackIntegration, event slackEvent, senderID string, recipientIDs, recipients []string, message string) {
+ remaining, err := h.store.GiveRemaining(r.Context(), senderID, h.now())
+ if err != nil {
+ http.Error(w, "Balance unavailable", http.StatusServiceUnavailable)
+ return
+ }
+ period, err := h.store.CurrentPeriod(r.Context(), h.now())
+ if err != nil {
+ http.Error(w, "Period unavailable", http.StatusServiceUnavailable)
+ return
+ }
+ thread := eventThread(event)
+ pending, _, err := h.store.CreateSlackPendingGive(r.Context(), domain.SlackPendingGive{
+ ChannelID: event.Channel, MessageTS: event.TS, ThreadTS: &thread,
+ SenderID: senderID, RecipientIDs: recipientIDs, Message: message,
+ }, h.now())
+ if err != nil {
+ http.Error(w, "Pending give unavailable", http.StatusServiceUnavailable)
+ return
+ }
+ buttons := make([]giveButton, 0, len(integration.MentionPointChoices)+1)
+ for _, points := range integration.MentionPointChoices {
+ if points > 0 && points <= period.MaxPointsPerPost && points <= remaining/len(recipientIDs) {
+ buttons = append(buttons, giveButton{Type: "button", Text: plain(fmt.Sprintf("%d pt", points)),
+ ActionID: "peerbonus_give_points", Value: pending.ID + ":" + strconv.Itoa(points)})
+ }
+ }
+ locale := integration.Locale
+ if len(buttons) == 0 {
+ h.conversationEphemeral(w, r, event.Channel, event.User, thread, slack.Message{Text: fmt.Sprintf(localized(locale,
+ "贈れる候補がありません(残り %d pt)。", "No available point choices (%d pt remaining)."), remaining)}, false)
+ return
+ }
+ text := fmt.Sprintf(localized(locale, "%s に何 pt 贈りますか?(残り %d pt)", "How many points would you like to give %s? (%d pt remaining)"), slackMentions(recipients), remaining)
+ buttons = append(buttons, giveButton{Type: "button", Text: plain(localized(locale, "やめる", "Cancel")),
+ ActionID: "peerbonus_give_cancel", Value: pending.ID})
+ blocks, _ := json.Marshal([]giveBlock{
+ {Type: "section", Text: &plainText{Type: "mrkdwn", Text: text}},
+ {Type: "actions", Elements: buttons},
+ })
+ h.conversationEphemeral(w, r, event.Channel, event.User, thread, slack.Message{Text: text, Blocks: blocks}, false)
+}
+
+func pendingGone(locale domain.SlackLocale) string {
+ return localized(locale, "もう一度メンションしてください。", "Please mention Peer Bonus again.")
+}
+
+func (h *handler) pendingAction(w http.ResponseWriter, r *http.Request, integration domain.SlackIntegration, payload interaction, actionID, value string) {
+ response := &eventResponse{ResponseWriter: w}
+ w = response
+ defer func() {
+ if response.status >= 500 {
+ h.replays.forget(r.Header.Get("X-Slack-Request-Timestamp") + ":" + r.Header.Get("X-Slack-Signature"))
+ }
+ }()
+ reply := func(text string, committed bool) {
+ err := h.respond(r.Context(), payload.ResponseURL, ephemeralResponse{ResponseType: "ephemeral", Text: text, ReplaceOriginal: true})
+ if err != nil && !committed {
+ http.Error(w, "Slack response unavailable", http.StatusBadGateway)
+ }
+ }
+ locale := integration.Locale
+ member, err := h.member(r.Context(), payload.User.ID)
+ if memberMissing(err) {
+ reply(h.guidance(locale), false)
+ return
+ }
+ if err != nil {
+ http.Error(w, "Member unavailable", http.StatusServiceUnavailable)
+ return
+ }
+ pendingID := value
+ points := 0
+ if actionID == "peerbonus_give_points" {
+ var amount string
+ pendingID, amount, _ = strings.Cut(value, ":")
+ points, err = strconv.Atoi(amount)
+ if err != nil || points <= 0 {
+ reply(pendingGone(locale), false)
+ return
+ }
+ }
+ pending, err := h.store.SlackPendingGive(r.Context(), pendingID, h.now())
+ if errors.Is(err, domain.ErrSlackPendingGiveGone) {
+ reply(pendingGone(locale), false)
+ return
+ }
+ if err != nil {
+ http.Error(w, "Pending give unavailable", http.StatusServiceUnavailable)
+ return
+ }
+ if pending.SenderID != member.ID {
+ reply(localized(locale, "贈る本人だけが操作できます。", "Only the sender can choose or cancel this give."), false)
+ return
+ }
+ if actionID == "peerbonus_give_cancel" {
+ err := h.store.DeleteSlackPendingGive(r.Context(), pending.ID, member.ID)
+ if errors.Is(err, domain.ErrSlackPendingGiveGone) {
+ reply(pendingGone(locale), false)
+ } else if err != nil {
+ http.Error(w, "Pending give unavailable", http.StatusServiceUnavailable)
+ } else {
+ reply(localized(locale, "キャンセルしました。", "Cancelled."), true)
+ }
+ return
+ }
+ posts, replayed, err := h.store.CreateSlackPosts(r.Context(), store.CreateSlackPostsInput{
+ SenderID: member.ID, RecipientIDs: pending.RecipientIDs, Points: points, Message: pending.Message,
+ Now: h.now(), PendingID: pending.ID, Source: h.giveSource(r.Context(), pending.ChannelID, pending.MessageTS, ""),
+ })
+ if errors.Is(err, domain.ErrSlackPendingGiveGone) {
+ reply(pendingGone(locale), false)
+ return
+ }
+ if err != nil {
+ if _, text := postError(err, locale); text != "" {
+ reply(text, false)
+ } else {
+ http.Error(w, "Unable to give points", http.StatusServiceUnavailable)
+ }
+ return
+ }
+ if replayed {
+ return
+ }
+ thread := pending.MessageTS
+ if pending.ThreadTS != nil && *pending.ThreadTS != "" {
+ thread = *pending.ThreadTS
+ }
+ recipients := make([]string, len(posts))
+ for i, post := range posts {
+ if post.Recipient.SlackUserID != nil {
+ recipients[i] = "<@" + *post.Recipient.SlackUserID + ">"
+ } else {
+ recipients[i] = mrkdwnEscaper.Replace(post.Recipient.DisplayName)
+ }
+ }
+ h.successReply(r.Context(), integration, pending.ChannelID, thread, giveReplyText(payload.User.ID, strings.Join(recipients, " "), points))
+ reply(localized(locale, "ポイントを贈りました。", "Points given."), true)
+}
diff --git a/cmd/server/internal/slackinbound/pending_test.go b/cmd/server/internal/slackinbound/pending_test.go
new file mode 100644
index 0000000..58fd87a
--- /dev/null
+++ b/cmd/server/internal/slackinbound/pending_test.go
@@ -0,0 +1,264 @@
+package slackinbound
+
+import (
+ "encoding/json"
+ "errors"
+ "net/http"
+ "strconv"
+ "testing"
+ "time"
+
+ "github.com/appthrust/peerbonus/cmd/server/internal/domain"
+ "github.com/stretchr/testify/require"
+)
+
+func TestConversationPendingPrompt(t *testing.T) {
+ for _, name := range []string{"affordable", "per-post maximum", "multiple recipients", "no affordable choice", "existing thread", "reused pending", "Japanese"} {
+ t.Run(name, func(t *testing.T) {
+ s, client, o := conversationFixture()
+ p := mentionEvent()
+ p.Event.Text = "<@UBOT> <@U456> Thanks for helping"
+ s.remaining = 40
+ want := []int{10, 30}
+ thread := p.Event.TS
+ switch name {
+ case "per-post maximum":
+ s.period.MaxPointsPerPost = 20
+ want = []int{10}
+ case "multiple recipients":
+ p.Event.Text += " <@U789>"
+ want = []int{10}
+ case "no affordable choice":
+ s.remaining = 9
+ want = nil
+ case "existing thread":
+ p.Event.ThreadTS = "100.000"
+ thread = p.Event.ThreadTS
+ case "reused pending":
+ s.pending = domain.SlackPendingGive{ID: "existing-pending"}
+ case "Japanese":
+ s.integration.Locale = domain.SlackLocaleJA
+ }
+ w := serveEvent(t, New(o), p)
+ require.Equal(t, http.StatusOK, w.Code)
+ require.Empty(t, w.Body.String())
+ require.Empty(t, s.slackPosts)
+ require.Empty(t, client.posted)
+ require.Empty(t, client.permalinkCalls)
+ require.Len(t, s.pendingCreates, 1)
+ in := s.pendingCreates[0]
+ require.Equal(t, "sender", in.SenderID)
+ require.Equal(t, "Thanks for helping", in.Message)
+ require.Equal(t, "C123", in.ChannelID)
+ require.Equal(t, p.Event.TS, in.MessageTS)
+ require.Equal(t, thread, *in.ThreadTS)
+ if name == "multiple recipients" {
+ require.Equal(t, []string{"recipient", "recipient-2"}, in.RecipientIDs)
+ } else {
+ require.Equal(t, []string{"recipient"}, in.RecipientIDs)
+ }
+ require.Len(t, client.messages, 1)
+ require.Equal(t, thread, client.messages[0].ThreadTS)
+ if name == "no affordable choice" {
+ require.Empty(t, client.messages[0].Blocks)
+ require.Contains(t, client.messages[0].Text, "9 pt remaining")
+ return
+ }
+ var blocks []giveBlock
+ require.NoError(t, json.Unmarshal(client.messages[0].Blocks, &blocks))
+ require.Len(t, blocks, 2)
+ require.Equal(t, "section", blocks[0].Type)
+ require.Equal(t, "mrkdwn", blocks[0].Text.Type)
+ require.Contains(t, blocks[0].Text.Text, "<@U456>")
+ if name == "Japanese" {
+ require.Contains(t, blocks[0].Text.Text, "に何 pt 贈りますか?(残り 40 pt)")
+ }
+ require.Equal(t, "actions", blocks[1].Type)
+ require.Len(t, blocks[1].Elements, len(want)+1)
+ for i, amount := range want {
+ button := blocks[1].Elements[i]
+ require.Equal(t, "button", button.Type)
+ require.Equal(t, "plain_text", button.Text.Type)
+ require.Equal(t, "peerbonus_give_points", button.ActionID)
+ require.Equal(t, s.pending.ID+":"+strconv.Itoa(amount), button.Value)
+ }
+ cancel := blocks[1].Elements[len(want)]
+ require.Equal(t, "peerbonus_give_cancel", cancel.ActionID)
+ require.Equal(t, s.pending.ID, cancel.Value)
+ })
+ }
+}
+
+func pendingPayload(t *testing.T) interaction {
+ p := clapPayload(t)
+ p.Actions[0].ActionID, p.Actions[0].Value = "peerbonus_give_points", "pending-1:30"
+ p.ResponseURL = "https://hooks.slack.com/commands/test"
+ return p
+}
+
+func pendingFixture() domain.SlackPendingGive {
+ return domain.SlackPendingGive{ID: "pending-1", ChannelID: "C123", MessageTS: "123.456", ThreadTS: new("100.000"),
+ SenderID: "sender", RecipientIDs: []string{"recipient"}, Message: "Thanks", ExpiresAt: testNow.Add(time.Hour)}
+}
+
+func TestConversationPendingActions(t *testing.T) {
+ for _, name := range []string{"give", "cancel", "other member", "expired", "missing", "consumed during give", "insufficient", "replayed", "bad amount", "announce channel", "cancel raced"} {
+ t.Run(name, func(t *testing.T) {
+ s, client, o := conversationFixture()
+ s.pending = pendingFixture()
+ p := pendingPayload(t)
+ messages := captureResponse(t, &o)
+ want := "Points given."
+ switch name {
+ case "cancel":
+ p.Actions[0].ActionID, p.Actions[0].Value = "peerbonus_give_cancel", s.pending.ID
+ want = "Cancelled."
+ case "other member":
+ p.User.ID = "U789"
+ want = "Only the sender"
+ case "expired":
+ s.pending.ExpiresAt = testNow
+ want = "mention Peer Bonus again"
+ case "missing":
+ s.pending.ID = "different"
+ want = "mention Peer Bonus again"
+ case "consumed during give":
+ s.postErr = domain.ErrSlackPendingGiveGone
+ want = "mention Peer Bonus again"
+ case "insufficient":
+ s.postErr = &domain.InsufficientPointsError{Remaining: 1, Required: 30}
+ want = "1 pt remaining"
+ case "replayed":
+ s.replayed = true
+ case "bad amount":
+ p.Actions[0].Value = "pending-1:thirty"
+ want = "mention Peer Bonus again"
+ case "announce channel":
+ s.integration.AnnouncePosts = true
+ s.integration.AnnounceChannel = &domain.SlackChannel{ID: "C123"}
+ case "cancel raced":
+ p.Actions[0].ActionID, p.Actions[0].Value = "peerbonus_give_cancel", s.pending.ID
+ s.pendingDeleteErr = domain.ErrSlackPendingGiveGone
+ want = "mention Peer Bonus again"
+ }
+ w := serve(New(o), "/slack/interactions", interactionForm(t, p))
+ require.Equal(t, http.StatusOK, w.Code)
+ require.Empty(t, w.Body.String())
+ if name == "replayed" {
+ require.Empty(t, *messages)
+ require.Empty(t, client.posted)
+ return
+ }
+ require.Len(t, *messages, 1)
+ require.True(t, (*messages)[0].ReplaceOriginal)
+ require.Equal(t, "ephemeral", (*messages)[0].ResponseType)
+ require.Contains(t, (*messages)[0].Text, want)
+ if name == "give" || name == "announce channel" {
+ require.Len(t, s.slackPosts, 1)
+ in := s.slackPosts[0]
+ require.Equal(t, "pending-1", in.PendingID)
+ require.Equal(t, "sender", in.SenderID)
+ require.Equal(t, []string{"recipient"}, in.RecipientIDs)
+ require.Equal(t, 30, in.Points)
+ require.Equal(t, "Thanks", in.Message)
+ require.Equal(t, "C123", in.Source.ChannelID)
+ require.Equal(t, "123.456", in.Source.MessageTS)
+ require.Equal(t, client.permalink, *in.Source.Permalink)
+ if name == "give" {
+ require.Len(t, client.posted, 1)
+ require.Equal(t, "100.000", client.posted[0].ThreadTS)
+ require.Equal(t, "🎉 <@U123> → <@U456> 30 pt", client.posted[0].Text)
+ } else {
+ require.Empty(t, client.posted)
+ }
+ } else {
+ require.Empty(t, client.posted)
+ if s.postErr == nil {
+ require.Empty(t, s.slackPosts)
+ }
+ }
+ if name == "cancel" || name == "cancel raced" {
+ require.Equal(t, []string{"pending-1:sender"}, s.pendingDeletes)
+ } else {
+ require.Empty(t, s.pendingDeletes)
+ }
+ })
+ }
+}
+
+func TestConversationPendingTransientAndReplyFailures(t *testing.T) {
+ for _, name := range []string{"load", "write", "response after write", "response before write", "prompt store", "prompt Slack"} {
+ t.Run(name, func(t *testing.T) {
+ s, client, o := conversationFixture()
+ s.pending = pendingFixture()
+ p := pendingPayload(t)
+ captureResponse(t, &o)
+ switch name {
+ case "load":
+ s.pendingErr = errors.New("database unavailable")
+ case "write":
+ s.postErr = errors.New("database unavailable")
+ case "response before write":
+ s.pending.ExpiresAt = testNow
+ case "prompt store":
+ s.pendingCreateErr = errors.New("database unavailable")
+ case "prompt Slack":
+ client.ephemeralErr = errors.New("Slack unavailable")
+ }
+ if name == "response after write" || name == "response before write" {
+ o.HTTPClient = &http.Client{Transport: roundTripFunc(func(*http.Request) (*http.Response, error) { return nil, errors.New("unavailable") })}
+ }
+ h := New(o)
+ var wCode int
+ if name == "prompt store" || name == "prompt Slack" {
+ e := mentionEvent()
+ e.Event.Text = "<@UBOT> <@U456> Thanks"
+ wCode = serveEvent(t, h, e).Code
+ } else {
+ wCode = serve(h, "/slack/interactions", interactionForm(t, p)).Code
+ }
+ if name == "response after write" {
+ require.Equal(t, http.StatusOK, wCode)
+ require.Len(t, s.slackPosts, 1)
+ return
+ }
+ require.GreaterOrEqual(t, wCode, 500)
+ if name == "write" {
+ s.postErr = nil
+ require.Equal(t, http.StatusOK, serve(h, "/slack/interactions", interactionForm(t, p)).Code)
+ require.Len(t, s.slackPosts, 2)
+ }
+ })
+ }
+}
+
+func TestConversationInteractionFlagSeparation(t *testing.T) {
+ for _, name := range []string{"command", "options", "clap", "submission", "points off", "cancel off"} {
+ t.Run(name, func(t *testing.T) {
+ s, client, o := conversationFixture()
+ path, payload, status := "/slack/interactions", clapPayload(t), http.StatusOK
+ switch name {
+ case "command":
+ path = "/slack/commands"
+ status = http.StatusNotFound
+ case "options":
+ path = "/slack/options"
+ status = http.StatusNotFound
+ case "submission":
+ payload = submission()
+ case "points off", "cancel off":
+ s.integration.GiveFromSlack, s.integration.GiveInConversation = true, false
+ payload = pendingPayload(t)
+ if name == "cancel off" {
+ payload.Actions[0].ActionID = "peerbonus_give_cancel"
+ }
+ }
+ w := serve(New(o), path, interactionForm(t, payload))
+ require.Equal(t, status, w.Code)
+ assertNoConversationWork(t, s, client)
+ require.Empty(t, s.posts)
+ require.Empty(t, s.claps)
+ require.Empty(t, s.pendingReads)
+ })
+ }
+}
diff --git a/cmd/server/internal/slackinbound/signature.go b/cmd/server/internal/slackinbound/signature.go
index b579f06..c8e2859 100644
--- a/cmd/server/internal/slackinbound/signature.go
+++ b/cmd/server/internal/slackinbound/signature.go
@@ -45,6 +45,12 @@ func (s *replaySet) seen(key string, now time.Time, record bool) bool {
return false
}
+func (s *replaySet) forget(key string) {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+ delete(s.entries, key)
+}
+
func (h *handler) verify(w http.ResponseWriter, r *http.Request, now time.Time) ([]byte, bool) {
timestamp := r.Header.Get("X-Slack-Request-Timestamp")
seconds, err := strconv.ParseInt(timestamp, 10, 64)
@@ -60,7 +66,7 @@ func (h *handler) verify(w http.ResponseWriter, r *http.Request, now time.Time)
return nil, false
}
key := timestamp + ":" + signature
- if h.replays.seen(key, now, false) || r.ContentLength > maxBodyBytes {
+ if (r.URL.Path != "/slack/events" && h.replays.seen(key, now, false)) || r.ContentLength > maxBodyBytes {
return nil, false
}
body, err := io.ReadAll(http.MaxBytesReader(w, r.Body, maxBodyBytes))
@@ -74,9 +80,9 @@ func (h *handler) verify(w http.ResponseWriter, r *http.Request, now time.Time)
if !hmac.Equal([]byte(signature), []byte(expected)) {
return nil, false
}
- // Check and insert atomically after authentication, so concurrent copies
- // cannot both enter the ledger path or open two views.
- if h.replays.seen(key, now, true) {
+ // Events claim their replay key after parsing, so challenge retries still
+ // return the challenge and duplicate callbacks receive an acknowledgement.
+ if r.URL.Path != "/slack/events" && h.replays.seen(key, now, true) {
return nil, false
}
return body, true
diff --git a/cmd/server/internal/slackinbound/slackinboundtest/signature.go b/cmd/server/internal/slackinbound/slackinboundtest/signature.go
index f956a68..8f053b7 100644
--- a/cmd/server/internal/slackinbound/slackinboundtest/signature.go
+++ b/cmd/server/internal/slackinbound/slackinboundtest/signature.go
@@ -2,10 +2,13 @@
package slackinboundtest
import (
+ "bytes"
"crypto/hmac"
"crypto/sha256"
"encoding/hex"
"io"
+ "net/http"
+ "net/http/httptest"
"strconv"
"time"
)
@@ -19,3 +22,12 @@ func SignRequest(secret string, ts time.Time, body []byte) (sigHeader string) {
_, _ = mac.Write(body)
return "v0=" + hex.EncodeToString(mac.Sum(nil))
}
+
+// SignedJSONRequest creates an Events API request signed over the exact JSON.
+func SignedJSONRequest(secret string, ts time.Time, path string, body []byte) *http.Request {
+ r := httptest.NewRequest(http.MethodPost, path, bytes.NewReader(body))
+ r.Header.Set("Content-Type", "application/json")
+ r.Header.Set("X-Slack-Request-Timestamp", strconv.FormatInt(ts.Unix(), 10))
+ r.Header.Set("X-Slack-Signature", SignRequest(secret, ts, body))
+ return r
+}
diff --git a/cmd/server/internal/store/posts.go b/cmd/server/internal/store/posts.go
index 16987c2..dbc8a64 100644
--- a/cmd/server/internal/store/posts.go
+++ b/cmd/server/internal/store/posts.go
@@ -16,7 +16,8 @@ const postColumns = `p.id,p.period_key,p.month_key,p.points,p.message,p.value_ke
s.id,s.person_id,s.subject,s.display_name,s.email,s.last_seen_at,s.avatar_version,
r.id,r.person_id,r.subject,r.display_name,r.email,r.last_seen_at,r.avatar_version,
(SELECT count(*) FROM claps c WHERE c.post_id=p.id AND c.member_id=$1),
- newest_clappers.members`
+ newest_clappers.members,
+ (SELECT g.permalink FROM slack_gives g WHERE g.post_id=p.id AND g.clap_id IS NULL)`
const postJoins = ` FROM posts p JOIN members s ON s.id=p.sender_id JOIN members r ON r.id=p.recipient_id
CROSS JOIN LATERAL (
@@ -32,10 +33,10 @@ const postSelect = `SELECT ` + postColumns + postJoins
func scanPost(row scanner, extra ...any) (out domain.Post, err error) {
var clappers []byte
- destinations := make([]any, 0, 24+len(extra))
+ destinations := make([]any, 0, 25+len(extra))
destinations = append(destinations, &out.ID, &out.PeriodKey, &out.MonthKey, &out.Points, &out.Message, pq.Array(&out.Values), &out.ClapCount, &out.CreatedAt,
&out.Sender.ID, &out.Sender.PersonID, &out.Sender.Subject, &out.Sender.DisplayName, &out.Sender.Email, &out.Sender.LastSeenAt, &out.Sender.AvatarVersion,
- &out.Recipient.ID, &out.Recipient.PersonID, &out.Recipient.Subject, &out.Recipient.DisplayName, &out.Recipient.Email, &out.Recipient.LastSeenAt, &out.Recipient.AvatarVersion, &out.ClappedByMe, &clappers)
+ &out.Recipient.ID, &out.Recipient.PersonID, &out.Recipient.Subject, &out.Recipient.DisplayName, &out.Recipient.Email, &out.Recipient.LastSeenAt, &out.Recipient.AvatarVersion, &out.ClappedByMe, &clappers, &out.SlackPermalink)
err = row.Scan(append(destinations, extra...)...)
out.Clappers = []domain.Member{}
if err != nil {
diff --git a/cmd/server/internal/store/slack.go b/cmd/server/internal/store/slack.go
index 49bee5f..f9207fc 100644
--- a/cmd/server/internal/store/slack.go
+++ b/cmd/server/internal/store/slack.go
@@ -7,6 +7,7 @@ import (
"time"
"github.com/appthrust/peerbonus/cmd/server/internal/domain"
+ "github.com/lib/pq"
)
// SlackSettingsPatch distinguishes an unchanged channel from an explicitly cleared one.
@@ -14,6 +15,9 @@ type SlackSettingsPatch struct {
AnnounceChannel **domain.SlackChannel
AnnouncePosts, DMRecipientOnPost, GiveFromSlack *bool
Locale *domain.SlackLocale
+ GiveInConversation *bool
+ MentionPointChoices *[]int
+ ReactionRules *[]domain.SlackReactionRule
}
func (s *Store) SlackIntegration(ctx context.Context) (out domain.SlackIntegration, err error) {
@@ -24,12 +28,13 @@ func (s *Store) SlackIntegration(ctx context.Context) (out domain.SlackIntegrati
func (tx *Tx) slackIntegration() (out domain.SlackIntegration, err error) {
var teamID, teamName, botUserID, enterpriseID, verifiedBy, channelID, channelName sql.NullString
var verifiedAt sql.NullTime
+ var choices pq.Int64Array
err = tx.SQL.QueryRowContext(tx.Context, `SELECT team_id,team_name,bot_user_id,enterprise_id,verified_at,verified_by,
announce_channel_id,announce_channel_name,announce_posts,dm_recipient_on_post,give_from_slack,locale,
- last_error_code,last_error_at,updated_at FROM slack_integration WHERE id=1`).Scan(
+ give_in_conversation,mention_point_choices,last_error_code,last_error_at,updated_at FROM slack_integration WHERE id=1`).Scan(
&teamID, &teamName, &botUserID, &enterpriseID, &verifiedAt, &verifiedBy,
&channelID, &channelName, &out.AnnouncePosts, &out.DMRecipientOnPost, &out.GiveFromSlack, &out.Locale,
- &out.LastErrorCode, &out.LastErrorAt, &out.UpdatedAt)
+ &out.GiveInConversation, &choices, &out.LastErrorCode, &out.LastErrorAt, &out.UpdatedAt)
if err != nil {
return
}
@@ -39,7 +44,24 @@ func (tx *Tx) slackIntegration() (out domain.SlackIntegration, err error) {
if channelID.Valid {
out.AnnounceChannel = &domain.SlackChannel{ID: channelID.String, Name: channelName.String}
}
- return
+ out.MentionPointChoices = make([]int, len(choices))
+ for i, choice := range choices {
+ out.MentionPointChoices[i] = int(choice)
+ }
+ out.ReactionRules = []domain.SlackReactionRule{}
+ rows, err := tx.SQL.QueryContext(tx.Context, `SELECT emoji,points,value_key FROM slack_reaction_rules ORDER BY position`)
+ if err != nil {
+ return out, err
+ }
+ defer rows.Close()
+ for rows.Next() {
+ var rule domain.SlackReactionRule
+ if err := rows.Scan(&rule.Emoji, &rule.Points, &rule.ValueKey); err != nil {
+ return out, err
+ }
+ out.ReactionRules = append(out.ReactionRules, rule)
+ }
+ return out, rows.Err()
}
func (s *Store) UpdateSlackSettings(ctx context.Context, patch SlackSettingsPatch, now time.Time) (out domain.SlackIntegration, err error) {
@@ -63,13 +85,31 @@ func (s *Store) UpdateSlackSettings(ctx context.Context, patch SlackSettingsPatc
if patch.Locale != nil {
current.Locale = *patch.Locale
}
+ if patch.GiveInConversation != nil {
+ current.GiveInConversation = *patch.GiveInConversation
+ }
+ if patch.MentionPointChoices != nil {
+ current.MentionPointChoices = *patch.MentionPointChoices
+ }
+ if patch.ReactionRules != nil {
+ if err := tx.Exec(`DELETE FROM slack_reaction_rules`); err != nil {
+ return err
+ }
+ for i, rule := range *patch.ReactionRules {
+ if err := tx.Exec(`INSERT INTO slack_reaction_rules (emoji,points,value_key,position) VALUES ($1,$2,$3,$4)`, rule.Emoji, rule.Points, rule.ValueKey, i); err != nil {
+ return err
+ }
+ }
+ }
var channelID, channelName *string
if current.AnnounceChannel != nil {
channelID, channelName = ¤t.AnnounceChannel.ID, ¤t.AnnounceChannel.Name
}
if err := tx.Exec(`UPDATE slack_integration SET announce_channel_id=$1,announce_channel_name=$2,
- announce_posts=$3,dm_recipient_on_post=$4,give_from_slack=$5,locale=$6,updated_at=$7 WHERE id=1`,
- channelID, channelName, current.AnnouncePosts, current.DMRecipientOnPost, current.GiveFromSlack, current.Locale, now); err != nil {
+ announce_posts=$3,dm_recipient_on_post=$4,give_from_slack=$5,locale=$6,updated_at=$7,
+ give_in_conversation=$8,mention_point_choices=$9 WHERE id=1`,
+ channelID, channelName, current.AnnouncePosts, current.DMRecipientOnPost, current.GiveFromSlack, current.Locale, now,
+ current.GiveInConversation, pq.Array(current.MentionPointChoices)); err != nil {
return err
}
out, err = tx.slackIntegration()
@@ -94,6 +134,9 @@ func (s *Store) FixSlackWorkspace(ctx context.Context, ws domain.SlackWorkspace,
if err := tx.Exec(`UPDATE slack_integration SET announce_channel_id=NULL,announce_channel_name=NULL WHERE id=1`); err != nil {
return err
}
+ if err := tx.Exec(`DELETE FROM slack_pending_gives`); err != nil {
+ return err
+ }
}
if err := tx.Exec(`UPDATE slack_integration SET team_id=$1,team_name=$2,bot_user_id=$3,enterprise_id=NULLIF($4,''),
verified_at=$5,verified_by=NULLIF($6,''),last_error_code=NULL,last_error_at=NULL,updated_at=$5 WHERE id=1`,
diff --git a/cmd/server/internal/store/slack_give.go b/cmd/server/internal/store/slack_give.go
new file mode 100644
index 0000000..50d0416
--- /dev/null
+++ b/cmd/server/internal/store/slack_give.go
@@ -0,0 +1,206 @@
+package store
+
+import (
+ "context"
+ "database/sql"
+ "errors"
+ "slices"
+ "time"
+
+ "github.com/appthrust/peerbonus/cmd/server/internal/domain"
+ "github.com/lib/pq"
+ "github.com/oklog/ulid/v2"
+)
+
+type CreateSlackPostsInput struct {
+ SenderID string
+ RecipientIDs []string
+ Points int
+ Message string
+ Values []string
+ Now time.Time
+ Source domain.SlackGiveSource
+ PendingID string
+}
+
+type CreateSlackClapInput struct {
+ PostID, MemberID string
+ Now time.Time
+ Source domain.SlackGiveSource
+}
+
+// CreateSlackPosts atomically gives to all recipients using the web ledger path.
+// Any existing give for the source and sender replays the entire original batch,
+// even if the requested recipients changed. Replay never consumes a pending give.
+func (s *Store) CreateSlackPosts(ctx context.Context, in CreateSlackPostsInput) (posts []domain.Post, replayed bool, err error) {
+ err = s.Do(ctx, true, func(tx *Tx) error {
+ posts, err = tx.slackGivenPosts(in.Source, in.SenderID)
+ if err != nil {
+ return err
+ }
+ if len(posts) > 0 {
+ replayed = true
+ return nil
+ }
+ if in.PendingID != "" {
+ var id string
+ err := tx.SQL.QueryRowContext(ctx, `DELETE FROM slack_pending_gives WHERE id=$1 AND sender_id=$2 AND expires_at>$3 RETURNING id`, in.PendingID, in.SenderID, in.Now).Scan(&id)
+ if errors.Is(err, sql.ErrNoRows) {
+ return domain.ErrSlackPendingGiveGone
+ }
+ if err != nil {
+ return err
+ }
+ }
+ if len(in.RecipientIDs) < 1 || len(in.RecipientIDs) > domain.SlackMaxMentionRecipients {
+ return &domain.ValidationError{Field: "recipientIds", Msg: "must contain 1 to 5 recipients"}
+ }
+ for i, id := range in.RecipientIDs {
+ if slices.Contains(in.RecipientIDs[:i], id) {
+ return &domain.ValidationError{Field: "recipientIds", Msg: "must be distinct"}
+ }
+ }
+ ids, err := tx.writePosts(in.SenderID, in.RecipientIDs, in.Points, in.Message, in.Values, in.Now, true)
+ if err != nil {
+ return err
+ }
+ posts = make([]domain.Post, len(ids))
+ for i, id := range ids {
+ if err := tx.rememberSlackGive(in.Source, in.SenderID, in.RecipientIDs[i], id, nil, in.Now); err != nil {
+ return err
+ }
+ posts[i], err = tx.post(id, in.SenderID, false)
+ if err != nil {
+ return err
+ }
+ }
+ return nil
+ })
+ return
+}
+
+func (tx *Tx) slackGivenPosts(source domain.SlackGiveSource, senderID string) ([]domain.Post, error) {
+ rows, err := tx.SQL.QueryContext(tx.Context, postSelect+`JOIN slack_gives g ON g.post_id=p.id
+ WHERE g.channel_id=$2 AND g.message_ts=$3 AND g.sender_id=$1 AND g.emoji=$4 ORDER BY g.created_at,p.id`, senderID, source.ChannelID, source.MessageTS, source.Emoji)
+ if err != nil {
+ return nil, err
+ }
+ defer rows.Close()
+ posts := []domain.Post{}
+ for rows.Next() {
+ post, err := scanPost(rows)
+ if err != nil {
+ return nil, err
+ }
+ posts = append(posts, post)
+ }
+ return posts, rows.Err()
+}
+
+// CreateSlackClap uses the same validation, ledger and outbox as a web clap,
+// but its replay record is permanent rather than an expiring idempotency key.
+func (s *Store) CreateSlackClap(ctx context.Context, in CreateSlackClapInput) (clap domain.Clap, post domain.Post, replayed bool, err error) {
+ err = s.Do(ctx, true, func(tx *Tx) error {
+ var postID string
+ var clapID *string
+ err := tx.SQL.QueryRowContext(ctx, `SELECT post_id,clap_id FROM slack_gives
+ WHERE channel_id=$1 AND message_ts=$2 AND sender_id=$3 AND emoji=$4
+ AND recipient_id=(SELECT recipient_id FROM posts WHERE id=$5)`, in.Source.ChannelID, in.Source.MessageTS, in.MemberID, in.Source.Emoji, in.PostID).Scan(&postID, &clapID)
+ if err == nil {
+ if clapID == nil || postID != in.PostID {
+ return &domain.ValidationError{Field: "source", Msg: "already used for a different action"}
+ }
+ clap, err = tx.clap(*clapID)
+ if err != nil {
+ return err
+ }
+ post, err = tx.post(postID, in.MemberID, true)
+ replayed = true
+ return err
+ }
+ if !errors.Is(err, sql.ErrNoRows) {
+ return err
+ }
+ clap, post, err = tx.writeClap(CreateClapInput{PostID: in.PostID, MemberID: in.MemberID, Now: in.Now})
+ if err != nil {
+ return err
+ }
+ return tx.rememberSlackGive(in.Source, in.MemberID, post.Recipient.ID, post.ID, &clap.ID, in.Now)
+ })
+ return
+}
+
+func (tx *Tx) rememberSlackGive(source domain.SlackGiveSource, senderID, recipientID, postID string, clapID *string, now time.Time) error {
+ return tx.Exec(`INSERT INTO slack_gives (channel_id,message_ts,sender_id,recipient_id,emoji,post_id,clap_id,permalink,created_at)
+ VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9)`, source.ChannelID, source.MessageTS, senderID, recipientID, source.Emoji, postID, clapID, source.Permalink, now)
+}
+
+func (s *Store) PostIDBySlackAnnounce(ctx context.Context, channelID, messageTS string) (id string, err error) {
+ err = s.Do(ctx, false, func(tx *Tx) error {
+ return tx.SQL.QueryRowContext(ctx, `SELECT post_id FROM slack_deliveries WHERE channel_id=$1 AND message_ts=$2 AND kind='post_announce' AND state='sent' ORDER BY id DESC LIMIT 1`, channelID, messageTS).Scan(&id)
+ })
+ return
+}
+
+const slackPendingGiveColumns = `id,channel_id,message_ts,thread_ts,sender_id,recipient_ids,message,expires_at`
+
+func scanSlackPendingGive(row scanner) (out domain.SlackPendingGive, err error) {
+ err = row.Scan(&out.ID, &out.ChannelID, &out.MessageTS, &out.ThreadTS, &out.SenderID, pq.Array(&out.RecipientIDs), &out.Message, &out.ExpiresAt)
+ return
+}
+
+// CreateSlackPendingGive preserves the first unexpired mention at a channel/ts.
+// It also prunes expired prompts; IDs and expiry are assigned by the store.
+func (s *Store) CreateSlackPendingGive(ctx context.Context, in domain.SlackPendingGive, now time.Time) (out domain.SlackPendingGive, created bool, err error) {
+ err = s.Do(ctx, true, func(tx *Tx) error {
+ if err := tx.Exec(`DELETE FROM slack_pending_gives WHERE expires_at<=$1`, now); err != nil {
+ return err
+ }
+ out, err = scanSlackPendingGive(tx.SQL.QueryRowContext(ctx, `SELECT `+slackPendingGiveColumns+` FROM slack_pending_gives WHERE channel_id=$1 AND message_ts=$2`, in.ChannelID, in.MessageTS))
+ if err == nil {
+ return nil
+ }
+ if !errors.Is(err, sql.ErrNoRows) {
+ return err
+ }
+ out, err = scanSlackPendingGive(tx.SQL.QueryRowContext(ctx, `INSERT INTO slack_pending_gives (`+slackPendingGiveColumns+`)
+ VALUES ($1,$2,$3,$4,$5,$6,$7,$8) RETURNING `+slackPendingGiveColumns, ulid.Make().String(), in.ChannelID, in.MessageTS, in.ThreadTS, in.SenderID, pq.Array(in.RecipientIDs), in.Message, now.Add(domain.SlackPendingGiveTTL)))
+ created = err == nil
+ return err
+ })
+ return
+}
+
+func (s *Store) SlackPendingGive(ctx context.Context, id string, now time.Time) (out domain.SlackPendingGive, err error) {
+ err = s.Do(ctx, false, func(tx *Tx) error {
+ out, err = scanSlackPendingGive(tx.SQL.QueryRowContext(ctx, `SELECT `+slackPendingGiveColumns+` FROM slack_pending_gives WHERE id=$1 AND expires_at>$2`, id, now))
+ if errors.Is(err, sql.ErrNoRows) {
+ return domain.ErrSlackPendingGiveGone
+ }
+ return err
+ })
+ return
+}
+
+func (s *Store) DeleteSlackPendingGive(ctx context.Context, id, senderID string) error {
+ return s.Do(ctx, true, func(tx *Tx) error {
+ var deleted string
+ err := tx.SQL.QueryRowContext(ctx, `DELETE FROM slack_pending_gives WHERE id=$1 AND sender_id=$2 RETURNING id`, id, senderID).Scan(&deleted)
+ if errors.Is(err, sql.ErrNoRows) {
+ return domain.ErrSlackPendingGiveGone
+ }
+ return err
+ })
+}
+
+func (s *Store) LinkMemberSlackUser(ctx context.Context, memberID, slackUserID string, now time.Time) error {
+ return s.Do(ctx, true, func(tx *Tx) error {
+ if _, err := tx.member(memberID); err != nil {
+ return err
+ }
+ if err := tx.Exec(`UPDATE members SET slack_user_id=NULL,slack_lookup_at=NULL WHERE slack_user_id=$1 AND id<>$2`, slackUserID, memberID); err != nil {
+ return err
+ }
+ return tx.Exec(`UPDATE members SET slack_user_id=$2,slack_lookup_at=$3 WHERE id=$1`, memberID, slackUserID, now)
+ })
+}
diff --git a/cmd/server/internal/store/slack_give_test.go b/cmd/server/internal/store/slack_give_test.go
new file mode 100644
index 0000000..37d0949
--- /dev/null
+++ b/cmd/server/internal/store/slack_give_test.go
@@ -0,0 +1,329 @@
+package store
+
+import (
+ "sync"
+ "testing"
+ "time"
+
+ "github.com/appthrust/peerbonus/cmd/server/internal/domain"
+ "github.com/oklog/ulid/v2"
+ "github.com/stretchr/testify/require"
+)
+
+func TestSlackConversationPostsReplayAndPermalink(t *testing.T) {
+ db, members := fixture(t)
+ connectSlack(t, db)
+ in := CreateSlackPostsInput{SenderID: members[0].ID, RecipientIDs: []string{members[1].ID, members[2].ID}, Points: 30, Message: " Thanks! ", Values: []string{"thanks"}, Now: october,
+ Source: domain.SlackGiveSource{ChannelID: "C1", MessageTS: "123.001", Permalink: new("https://example.slack.com/archives/C1/p123001")}}
+ posts, replayed, err := db.CreateSlackPosts(t.Context(), in)
+ require.NoError(t, err)
+ require.False(t, replayed)
+ require.Len(t, posts, 2)
+ for i, post := range posts {
+ require.Equal(t, in.RecipientIDs[i], post.Recipient.ID)
+ require.Equal(t, 30, post.Points)
+ require.Equal(t, "Thanks!", post.Message)
+ require.Equal(t, []string{"thanks"}, post.Values)
+ require.Equal(t, in.Source.Permalink, post.SlackPermalink)
+ read, err := db.PostByID(t.Context(), post.ID, members[0].ID)
+ require.NoError(t, err)
+ require.Equal(t, in.Source.Permalink, read.SlackPermalink)
+ }
+ require.Equal(t, 4, count(t, db, `SELECT count(*) FROM ledger`))
+ require.Equal(t, 4, count(t, db, `SELECT count(*) FROM slack_deliveries`))
+ require.Equal(t, 2, count(t, db, `SELECT count(*) FROM slack_gives`))
+ require.Zero(t, count(t, db, `SELECT count(*) FROM idempotency_keys`))
+ listed, _, err := db.ListPosts(t.Context(), PostFilter{}, members[0].ID)
+ require.NoError(t, err)
+ require.Len(t, listed, 2)
+ for _, post := range listed {
+ require.Equal(t, in.Source.Permalink, post.SlackPermalink)
+ }
+ inbox, _, _, err := db.ListInbox(t.Context(), members[1].ID, 20, "")
+ require.NoError(t, err)
+ require.Len(t, inbox, 1)
+ require.Equal(t, in.Source.Permalink, inbox[0].Post.SlackPermalink)
+
+ in.Now = october.Add(48 * time.Hour)
+ in.Points, in.Message = -1, ""
+ same, replayed, err := db.CreateSlackPosts(t.Context(), in)
+ require.NoError(t, err)
+ require.True(t, replayed)
+ require.Equal(t, posts, same)
+ in.RecipientIDs = []string{members[1].ID}
+ same, replayed, err = db.CreateSlackPosts(t.Context(), in)
+ require.NoError(t, err)
+ require.True(t, replayed)
+ require.Equal(t, posts, same, "a subset must replay the entire original give")
+ in.RecipientIDs = []string{"another-recipient"}
+ same, replayed, err = db.CreateSlackPosts(t.Context(), in)
+ require.NoError(t, err)
+ require.True(t, replayed)
+ require.Equal(t, posts, same, "changed recipients must never add another give")
+ require.Equal(t, 4, count(t, db, `SELECT count(*) FROM ledger`))
+ require.Equal(t, 4, count(t, db, `SELECT count(*) FROM slack_deliveries`))
+}
+
+func TestSlackConversationPostsAtomicValidation(t *testing.T) {
+ for _, reason := range []string{"balance", "missing recipient", "self", "duplicate", "empty", "too many", "points", "message"} {
+ t.Run(reason, func(t *testing.T) {
+ db, members := fixture(t)
+ connectSlack(t, db)
+ _, err := db.UpdateProgram(t.Context(), domain.ProgramPatch{WeeklyAllowance: new(120)}, october, members[0].ID)
+ require.NoError(t, err)
+ in := CreateSlackPostsInput{SenderID: members[0].ID, RecipientIDs: []string{members[1].ID, members[2].ID}, Points: 30, Message: "Thanks", Now: october, Source: domain.SlackGiveSource{ChannelID: "C1", MessageTS: "123.001"}}
+ switch reason {
+ case "balance":
+ in.Points = 100
+ case "missing recipient":
+ in.RecipientIDs[1] = "missing"
+ case "self":
+ in.RecipientIDs[1] = members[0].ID
+ case "duplicate":
+ in.RecipientIDs[1] = members[1].ID
+ case "empty":
+ in.RecipientIDs = nil
+ case "too many":
+ in.RecipientIDs = []string{"a", "b", "c", "d", "e", "f"}
+ case "points":
+ in.Points = 121
+ case "message":
+ in.Message = " "
+ }
+ _, replayed, err := db.CreateSlackPosts(t.Context(), in)
+ require.Error(t, err)
+ require.False(t, replayed)
+ switch reason {
+ case "balance":
+ var insufficient *domain.InsufficientPointsError
+ require.ErrorAs(t, err, &insufficient)
+ require.Equal(t, 120, insufficient.Remaining)
+ require.Equal(t, 200, insufficient.Required)
+ case "missing recipient":
+ require.ErrorIs(t, err, domain.ErrRecipientNotFound)
+ case "self":
+ require.ErrorIs(t, err, domain.ErrSelfTarget)
+ default:
+ var invalid *domain.ValidationError
+ require.ErrorAs(t, err, &invalid)
+ }
+ for _, table := range []string{"posts", "ledger", "periods", "slack_gives", "slack_deliveries", "idempotency_keys"} {
+ require.Zero(t, count(t, db, `SELECT count(*) FROM `+table), table)
+ }
+ })
+ }
+}
+
+func TestSlackConversationPendingLifecycle(t *testing.T) {
+ db, members := fixture(t)
+ in := domain.SlackPendingGive{ChannelID: "C1", MessageTS: "123.001", ThreadTS: new("123.000"), SenderID: members[0].ID, RecipientIDs: []string{members[1].ID, members[2].ID}, Message: "Thanks"}
+ pending, created, err := db.CreateSlackPendingGive(t.Context(), in, october)
+ require.NoError(t, err)
+ require.True(t, created)
+ _, err = ulid.ParseStrict(pending.ID)
+ require.NoError(t, err)
+ require.True(t, pending.ExpiresAt.Equal(october.Add(domain.SlackPendingGiveTTL)))
+ read, err := db.SlackPendingGive(t.Context(), pending.ID, october)
+ require.NoError(t, err)
+ require.Equal(t, pending, read)
+ in.Message = "Changed"
+ same, created, err := db.CreateSlackPendingGive(t.Context(), in, october.Add(time.Hour))
+ require.NoError(t, err)
+ require.False(t, created)
+ require.Equal(t, pending, same)
+ require.ErrorIs(t, db.DeleteSlackPendingGive(t.Context(), pending.ID, members[1].ID), domain.ErrSlackPendingGiveGone)
+ _, err = db.SlackPendingGive(t.Context(), pending.ID, pending.ExpiresAt)
+ require.ErrorIs(t, err, domain.ErrSlackPendingGiveGone)
+ in.MessageTS = "124.001"
+ _, created, err = db.CreateSlackPendingGive(t.Context(), in, pending.ExpiresAt)
+ require.NoError(t, err)
+ require.True(t, created)
+ require.Zero(t, count(t, db, `SELECT count(*) FROM slack_pending_gives WHERE id=$1`, pending.ID), "creation prunes expired rows")
+ require.ErrorIs(t, db.DeleteSlackPendingGive(t.Context(), pending.ID, members[0].ID), domain.ErrSlackPendingGiveGone)
+ fresh, created, err := db.CreateSlackPendingGive(t.Context(), domain.SlackPendingGive{ChannelID: "C1", MessageTS: "125.001", SenderID: members[0].ID, RecipientIDs: in.RecipientIDs, Message: "Cancel"}, pending.ExpiresAt)
+ require.NoError(t, err)
+ require.True(t, created)
+ require.NoError(t, db.DeleteSlackPendingGive(t.Context(), fresh.ID, members[0].ID))
+ require.ErrorIs(t, db.DeleteSlackPendingGive(t.Context(), fresh.ID, members[0].ID), domain.ErrSlackPendingGiveGone)
+}
+
+func TestSlackConversationPendingConsumption(t *testing.T) {
+ db, members := fixture(t)
+ pending, _, err := db.CreateSlackPendingGive(t.Context(), domain.SlackPendingGive{ChannelID: "C1", MessageTS: "123.001", SenderID: members[0].ID, RecipientIDs: []string{members[1].ID, members[2].ID}, Message: "Thanks"}, october)
+ require.NoError(t, err)
+ in := CreateSlackPostsInput{SenderID: members[0].ID, RecipientIDs: pending.RecipientIDs, Points: 30, Message: pending.Message, Now: october, PendingID: pending.ID, Source: domain.SlackGiveSource{ChannelID: pending.ChannelID, MessageTS: pending.MessageTS}}
+ wrongSender := in
+ wrongSender.SenderID = members[1].ID
+ _, _, err = db.CreateSlackPosts(t.Context(), wrongSender)
+ require.ErrorIs(t, err, domain.ErrSlackPendingGiveGone)
+ expired := in
+ expired.Now = pending.ExpiresAt
+ _, _, err = db.CreateSlackPosts(t.Context(), expired)
+ require.ErrorIs(t, err, domain.ErrSlackPendingGiveGone)
+ invalid := in
+ invalid.Points = 121
+ _, _, err = db.CreateSlackPosts(t.Context(), invalid)
+ require.Error(t, err)
+ _, err = db.SlackPendingGive(t.Context(), pending.ID, october)
+ require.NoError(t, err, "failed give rolls back consumption")
+ require.Zero(t, count(t, db, `SELECT count(*) FROM ledger`))
+
+ type result struct {
+ posts []domain.Post
+ replayed bool
+ err error
+ }
+ results := make(chan result, 2)
+ var wg sync.WaitGroup
+ for range 2 {
+ wg.Go(func() {
+ posts, replayed, err := db.CreateSlackPosts(t.Context(), in)
+ results <- result{posts, replayed, err}
+ })
+ }
+ wg.Wait()
+ close(results)
+ replays := 0
+ var posts []domain.Post
+ for result := range results {
+ require.NoError(t, result.err)
+ if posts == nil {
+ posts = result.posts
+ } else {
+ require.Equal(t, posts, result.posts)
+ }
+ if result.replayed {
+ replays++
+ }
+ }
+ require.Equal(t, 1, replays)
+ require.Zero(t, count(t, db, `SELECT count(*) FROM slack_pending_gives`))
+ require.Equal(t, 4, count(t, db, `SELECT count(*) FROM ledger`))
+ _, err = db.SlackPendingGive(t.Context(), pending.ID, october)
+ require.ErrorIs(t, err, domain.ErrSlackPendingGiveGone)
+ in.Source.MessageTS = "another-source"
+ _, _, err = db.CreateSlackPosts(t.Context(), in)
+ require.ErrorIs(t, err, domain.ErrSlackPendingGiveGone, "a used pending give cannot authorize another source")
+ in.PendingID = "missing"
+ _, _, err = db.CreateSlackPosts(t.Context(), in)
+ require.ErrorIs(t, err, domain.ErrSlackPendingGiveGone)
+}
+
+func TestSlackConversationSettingsAndRemovedValue(t *testing.T) {
+ db, members := fixture(t)
+ initial, err := db.SlackIntegration(t.Context())
+ require.NoError(t, err)
+ require.False(t, initial.GiveInConversation)
+ require.Equal(t, []int{10, 30, 50}, initial.MentionPointChoices)
+ require.Equal(t, []domain.SlackReactionRule{}, initial.ReactionRules)
+ rules := []domain.SlackReactionRule{{Emoji: "z-thanks", Points: 30, ValueKey: new("thanks")}, {Emoji: "a-care", Points: 10}}
+ choices := []int{50, 10, 30}
+ settings, err := db.UpdateSlackSettings(t.Context(), SlackSettingsPatch{GiveInConversation: new(true), MentionPointChoices: &choices, ReactionRules: &rules}, october)
+ require.NoError(t, err)
+ require.True(t, settings.GiveInConversation)
+ require.Equal(t, choices, settings.MentionPointChoices)
+ require.Equal(t, rules, settings.ReactionRules)
+ loaded, err := db.SlackIntegration(t.Context())
+ require.NoError(t, err)
+ require.Equal(t, settings, loaded)
+ unchanged, err := db.UpdateSlackSettings(t.Context(), SlackSettingsPatch{}, october)
+ require.NoError(t, err)
+ require.Equal(t, settings, unchanged)
+
+ _, err = db.UpdateProgram(t.Context(), domain.ProgramPatch{Values: new([]domain.Value{{Key: "teamwork", Label: "Teamwork"}})}, october, members[0].ID)
+ require.NoError(t, err)
+ posts, _, err := db.CreateSlackPosts(t.Context(), CreateSlackPostsInput{SenderID: members[0].ID, RecipientIDs: []string{members[1].ID}, Points: 30, Message: "Reaction", Values: []string{*rules[0].ValueKey, "teamwork"}, Now: october, Source: domain.SlackGiveSource{ChannelID: "C1", MessageTS: "123.001", Emoji: rules[0].Emoji}})
+ require.NoError(t, err)
+ require.Equal(t, []string{"teamwork"}, posts[0].Values)
+ _, _, err = db.CreatePost(t.Context(), CreatePostInput{SenderID: members[0].ID, RecipientID: members[1].ID, Points: 30, Message: "Web remains strict", Values: []string{"thanks"}, Now: october, IdempotencyKey: "web"})
+ require.ErrorIs(t, err, domain.ErrUnknownValue)
+ cleared, err := db.UpdateSlackSettings(t.Context(), SlackSettingsPatch{ReactionRules: new([]domain.SlackReactionRule{}), GiveInConversation: new(false)}, october)
+ require.NoError(t, err)
+ require.Empty(t, cleared.ReactionRules)
+ require.False(t, cleared.GiveInConversation)
+ require.Equal(t, choices, cleared.MentionPointChoices)
+}
+
+func TestSlackConversationLinkAndWorkspaceChange(t *testing.T) {
+ db, members := fixture(t)
+ connectSlack(t, db)
+ require.NoError(t, db.SetMemberSlackUser(t.Context(), members[0].ID, new("U1"), october))
+ later := october.Add(time.Hour)
+ require.NoError(t, db.LinkMemberSlackUser(t.Context(), members[1].ID, "U1", later))
+ old, err := db.MemberByID(t.Context(), members[0].ID)
+ require.NoError(t, err)
+ require.Nil(t, old.SlackUserID)
+ require.Nil(t, old.SlackLookupAt)
+ linked, err := db.MemberBySlackUser(t.Context(), "U1")
+ require.NoError(t, err)
+ require.Equal(t, members[1].ID, linked.ID)
+ require.True(t, linked.SlackLookupAt.Equal(later))
+ require.ErrorIs(t, db.LinkMemberSlackUser(t.Context(), "missing", "U1", later), domain.ErrNotFound)
+ linked, err = db.MemberBySlackUser(t.Context(), "U1")
+ require.NoError(t, err)
+ require.Equal(t, members[1].ID, linked.ID, "a missing target must not clear an existing link")
+ pending, _, err := db.CreateSlackPendingGive(t.Context(), domain.SlackPendingGive{ChannelID: "C1", MessageTS: "123.001", SenderID: members[0].ID, RecipientIDs: []string{members[1].ID}, Message: "Thanks"}, october)
+ require.NoError(t, err)
+ _, err = db.FixSlackWorkspace(t.Context(), domain.SlackWorkspace{TeamID: "T1", BotUserID: "UBOT"}, true, later)
+ require.NoError(t, err)
+ _, err = db.SlackPendingGive(t.Context(), pending.ID, later)
+ require.NoError(t, err)
+ _, err = db.FixSlackWorkspace(t.Context(), domain.SlackWorkspace{TeamID: "T2", BotUserID: "UBOT2"}, false, later)
+ require.ErrorIs(t, err, domain.ErrSlackTeamChanged)
+ _, err = db.SlackPendingGive(t.Context(), pending.ID, later)
+ require.NoError(t, err)
+ _, err = db.FixSlackWorkspace(t.Context(), domain.SlackWorkspace{TeamID: "T2", BotUserID: "UBOT2"}, true, later)
+ require.NoError(t, err)
+ _, err = db.SlackPendingGive(t.Context(), pending.ID, later)
+ require.ErrorIs(t, err, domain.ErrSlackPendingGiveGone)
+}
+
+func TestSlackConversationClapAndAnnounce(t *testing.T) {
+ db, members := fixture(t)
+ connectSlack(t, db)
+ post := send(t, db, members[0], members[1], 30, october)
+ _, err := db.PostIDBySlackAnnounce(t.Context(), "C1", "123.001")
+ require.ErrorIs(t, err, domain.ErrNotFound)
+ deliveries, err := db.ClaimSlackDeliveries(t.Context(), october, 10, time.Minute)
+ require.NoError(t, err)
+ for _, delivery := range deliveries {
+ if delivery.Kind == domain.SlackDeliveryPostAnnounce {
+ require.NoError(t, db.MarkSlackDeliverySent(t.Context(), delivery.ID, "C1", "123.001", october))
+ } else {
+ require.NoError(t, db.MarkSlackDeliverySent(t.Context(), delivery.ID, "D1", "124.001", october))
+ }
+ }
+ id, err := db.PostIDBySlackAnnounce(t.Context(), "C1", "123.001")
+ require.NoError(t, err)
+ require.Equal(t, post.ID, id)
+ _, err = db.PostIDBySlackAnnounce(t.Context(), "D1", "124.001")
+ require.ErrorIs(t, err, domain.ErrNotFound)
+ in := CreateSlackClapInput{PostID: post.ID, MemberID: members[2].ID, Now: october, Source: domain.SlackGiveSource{ChannelID: "C1", MessageTS: "123.001", Emoji: "pb-10", Permalink: new("https://example.slack.com/clap")}}
+ first, updated, replayed, err := db.CreateSlackClap(t.Context(), in)
+ require.NoError(t, err)
+ require.False(t, replayed)
+ require.Equal(t, 1, updated.ClapCount)
+ require.Nil(t, updated.SlackPermalink, "clap source is not the original give's permalink")
+ require.Equal(t, 1, count(t, db, `SELECT count(*) FROM slack_gives WHERE clap_id=$1 AND recipient_id=$2`, first.ID, members[1].ID))
+ require.Equal(t, 5, count(t, db, `SELECT count(*) FROM ledger`))
+ require.Equal(t, 1, count(t, db, `SELECT count(*) FROM idempotency_keys`), "only the web post has an idempotency key")
+ require.Equal(t, 1, count(t, db, `SELECT count(*) FROM slack_deliveries WHERE kind='clap_update'`))
+ in.Now = october.Add(48 * time.Hour)
+ same, updated, replayed, err := db.CreateSlackClap(t.Context(), in)
+ require.NoError(t, err)
+ require.True(t, replayed)
+ require.Equal(t, first.ID, same.ID)
+ require.Equal(t, 1, updated.ClapCount)
+ require.Equal(t, 5, count(t, db, `SELECT count(*) FROM ledger`))
+ in.MemberID = members[0].ID
+ _, _, _, err = db.CreateSlackClap(t.Context(), in)
+ require.ErrorIs(t, err, domain.ErrOwnPost)
+ in.MemberID = members[2].ID
+ require.NoError(t, db.DeletePost(t.Context(), post.ID, members[0].ID, october))
+ _, _, replayed, err = db.CreateSlackClap(t.Context(), in)
+ require.NoError(t, err)
+ require.True(t, replayed)
+ in.Source.Emoji = "pb-30"
+ _, _, _, err = db.CreateSlackClap(t.Context(), in)
+ require.ErrorIs(t, err, domain.ErrNotFound)
+}
diff --git a/cmd/server/internal/store/writes.go b/cmd/server/internal/store/writes.go
index b483f8e..d00c15b 100644
--- a/cmd/server/internal/store/writes.go
+++ b/cmd/server/internal/store/writes.go
@@ -44,70 +44,110 @@ func (tx *Tx) createPost(in CreatePostInput) (domain.Post, bool, error) {
post, err := tx.post(postID, in.SenderID, true)
return post, true, err
}
- if in.SenderID == in.RecipientID {
- return domain.Post{}, false, domain.ErrSelfTarget
+ ids, err := tx.writePosts(in.SenderID, []string{in.RecipientID}, in.Points, in.Message, in.Values, in.Now, false)
+ if err != nil {
+ return domain.Post{}, false, err
}
- if _, err := tx.member(in.SenderID); err != nil {
+ if err := tx.remember(in.SenderID, in.IdempotencyKey, ids[0], nil, in.Now); err != nil {
return domain.Post{}, false, err
}
- if _, err := tx.member(in.RecipientID); err != nil {
- if errors.Is(err, sql.ErrNoRows) {
- err = domain.ErrRecipientNotFound
+ post, err := tx.post(ids[0], in.SenderID, false)
+ return post, false, err
+}
+
+// writePosts owns validation, the ledger and the outbox for both web and Slack gives.
+// Its caller owns replay and records the appropriate idempotency key in the same tx.
+func (tx *Tx) writePosts(senderID string, recipientIDs []string, points int, message string, values []string, now time.Time, dropUnknownValues bool) ([]string, error) {
+ for _, recipientID := range recipientIDs {
+ if senderID == recipientID {
+ return nil, domain.ErrSelfTarget
+ }
+ }
+ if _, err := tx.member(senderID); err != nil {
+ return nil, err
+ }
+ for _, recipientID := range recipientIDs {
+ if _, err := tx.member(recipientID); err != nil {
+ if errors.Is(err, sql.ErrNoRows) {
+ err = domain.ErrRecipientNotFound
+ }
+ return nil, err
}
- return domain.Post{}, false, err
}
program, err := tx.program()
if err != nil {
- return domain.Post{}, false, err
+ return nil, err
}
- period, err := tx.period(program, in.Now, true)
+ period, err := tx.period(program, now, true)
if err != nil {
- return domain.Post{}, false, err
+ return nil, err
}
- if err := domain.ValidatePoints(in.Points, period.MaxPointsPerPost); err != nil {
- return domain.Post{}, false, err
+ if err := domain.ValidatePoints(points, period.MaxPointsPerPost); err != nil {
+ return nil, err
}
- message, err := domain.ValidateMessage(in.Message)
+ message, err = domain.ValidateMessage(message)
if err != nil {
- return domain.Post{}, false, err
+ return nil, err
+ }
+ if dropUnknownValues {
+ var filtered []string
+ for i, key := range values {
+ known := false
+ for _, value := range program.Values {
+ if value.Key == key {
+ known = true
+ break
+ }
+ }
+ if !known && filtered == nil {
+ filtered = make([]string, i, len(values))
+ copy(filtered, values[:i])
+ } else if known && filtered != nil {
+ filtered = append(filtered, key)
+ }
+ }
+ if filtered != nil {
+ values = filtered
+ }
}
- if err := domain.ValidateValues(in.Values, program); err != nil {
- return domain.Post{}, false, err
+ if err := domain.ValidateValues(values, program); err != nil {
+ return nil, err
}
loc, err := time.LoadLocation(program.TimeZone)
if err != nil {
- return domain.Post{}, false, err
+ return nil, err
}
- month := domain.MonthKeyFor(in.Now, loc)
+ month := domain.MonthKeyFor(now, loc)
if err := tx.requireOpen(month); err != nil {
- return domain.Post{}, false, err
+ return nil, err
}
- remaining, err := tx.remaining(in.SenderID, period)
+ remaining, err := tx.remaining(senderID, period)
if err != nil {
- return domain.Post{}, false, err
+ return nil, err
}
- if remaining < in.Points {
- return domain.Post{}, false, &domain.InsufficientPointsError{Remaining: remaining, Required: in.Points}
+ total := points * len(recipientIDs)
+ if remaining < total {
+ return nil, &domain.InsufficientPointsError{Remaining: remaining, Required: total}
}
- postID = ulid.Make().String()
- if in.Values == nil {
- in.Values = []string{}
- }
- if err := tx.Exec(`INSERT INTO posts (id,period_key,month_key,sender_id,recipient_id,points,message,value_keys,created_at) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9)`, postID, period.Key, month, in.SenderID, in.RecipientID, in.Points, message, pq.Array(in.Values), in.Now); err != nil {
- return domain.Post{}, false, err
+ if values == nil {
+ values = []string{}
}
- if err := tx.Exec(`INSERT INTO ledger (member_id,period_key,month_key,account,delta,kind,post_id,created_at) VALUES
- ($1,$3,$4,'give',-$5::integer,'send',$6,$7), ($2,$3,$4,'receive',$5::integer,'receive',$6,$7)`, in.SenderID, in.RecipientID, period.Key, month, in.Points, postID, in.Now); err != nil {
- return domain.Post{}, false, err
- }
- if err := tx.remember(in.SenderID, in.IdempotencyKey, postID, nil, in.Now); err != nil {
- return domain.Post{}, false, err
- }
- if err := tx.enqueueSlackPost(postID, in.RecipientID, in.Now); err != nil {
- return domain.Post{}, false, err
+ ids := make([]string, len(recipientIDs))
+ for i, recipientID := range recipientIDs {
+ id := ulid.Make().String()
+ if err := tx.Exec(`INSERT INTO posts (id,period_key,month_key,sender_id,recipient_id,points,message,value_keys,created_at) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9)`, id, period.Key, month, senderID, recipientID, points, message, pq.Array(values), now); err != nil {
+ return nil, err
+ }
+ if err := tx.Exec(`INSERT INTO ledger (member_id,period_key,month_key,account,delta,kind,post_id,created_at) VALUES
+ ($1,$3,$4,'give',-$5::integer,'send',$6,$7), ($2,$3,$4,'receive',$5::integer,'receive',$6,$7)`, senderID, recipientID, period.Key, month, points, id, now); err != nil {
+ return nil, err
+ }
+ if err := tx.enqueueSlackPost(id, recipientID, now); err != nil {
+ return nil, err
+ }
+ ids[i] = id
}
- post, err := tx.post(postID, in.SenderID, false)
- return post, false, err
+ return ids, nil
}
func (s *Store) CreateClap(ctx context.Context, in CreateClapInput) (clap domain.Clap, post domain.Post, replayed bool, err error) {
err = s.Do(ctx, true, func(tx *Tx) error { clap, post, replayed, err = tx.createClap(in); return err })
@@ -129,65 +169,73 @@ func (tx *Tx) createClap(in CreateClapInput) (domain.Clap, domain.Post, bool, er
post, err := tx.post(postID, in.MemberID, true)
return clap, post, true, err
}
- post, err := tx.post(in.PostID, in.MemberID, false)
+ clap, post, err := tx.writeClap(in)
if err != nil {
return domain.Clap{}, domain.Post{}, false, err
}
+ if err := tx.remember(in.MemberID, in.IdempotencyKey, post.ID, &clap.ID, in.Now); err != nil {
+ return domain.Clap{}, domain.Post{}, false, err
+ }
+ return clap, post, false, nil
+}
+
+func (tx *Tx) writeClap(in CreateClapInput) (domain.Clap, domain.Post, error) {
+ post, err := tx.post(in.PostID, in.MemberID, false)
+ if err != nil {
+ return domain.Clap{}, domain.Post{}, err
+ }
if post.Sender.ID == in.MemberID || post.Recipient.ID == in.MemberID {
- return domain.Clap{}, domain.Post{}, false, domain.ErrOwnPost
+ return domain.Clap{}, domain.Post{}, domain.ErrOwnPost
}
if _, err := tx.member(in.MemberID); err != nil {
- return domain.Clap{}, domain.Post{}, false, err
+ return domain.Clap{}, domain.Post{}, err
}
program, err := tx.program()
if err != nil {
- return domain.Clap{}, domain.Post{}, false, err
+ return domain.Clap{}, domain.Post{}, err
}
loc, err := time.LoadLocation(program.TimeZone)
if err != nil {
- return domain.Clap{}, domain.Post{}, false, err
+ return domain.Clap{}, domain.Post{}, err
}
month := domain.MonthKeyFor(in.Now, loc)
if err := tx.requireOpen(post.MonthKey); err != nil {
- return domain.Clap{}, domain.Post{}, false, err
+ return domain.Clap{}, domain.Post{}, err
}
if err := tx.requireOpen(month); err != nil {
- return domain.Clap{}, domain.Post{}, false, err
+ return domain.Clap{}, domain.Post{}, err
}
period, err := tx.period(program, in.Now, true)
if err != nil {
- return domain.Clap{}, domain.Post{}, false, err
+ return domain.Clap{}, domain.Post{}, err
}
remaining, err := tx.remaining(in.MemberID, period)
if err != nil {
- return domain.Clap{}, domain.Post{}, false, err
+ return domain.Clap{}, domain.Post{}, err
}
if remaining < domain.ClapCost {
- return domain.Clap{}, domain.Post{}, false, &domain.InsufficientPointsError{Remaining: remaining, Required: domain.ClapCost}
+ return domain.Clap{}, domain.Post{}, &domain.InsufficientPointsError{Remaining: remaining, Required: domain.ClapCost}
}
id := ulid.Make().String()
if err := tx.Exec(`INSERT INTO claps (id,post_id,member_id,period_key,month_key,idempotency_key,created_at) VALUES ($1,$2,$3,$4,$5,$6,$7)`, id, in.PostID, in.MemberID, period.Key, month, in.IdempotencyKey, in.Now); err != nil {
- return domain.Clap{}, domain.Post{}, false, err
+ return domain.Clap{}, domain.Post{}, err
}
if err := tx.Exec(`INSERT INTO ledger (member_id,period_key,month_key,account,delta,kind,post_id,clap_id,created_at) VALUES
($1,$4,$5,'give',-2,'clap_give',$6,$7,$8), ($2,$4,$5,'receive',1,'clap_sender',$6,$7,$8), ($3,$4,$5,'receive',1,'clap_recipient',$6,$7,$8)`, in.MemberID, post.Sender.ID, post.Recipient.ID, period.Key, month, post.ID, id, in.Now); err != nil {
- return domain.Clap{}, domain.Post{}, false, err
+ return domain.Clap{}, domain.Post{}, err
}
if err := tx.Exec(`UPDATE posts SET clap_count=clap_count+1 WHERE id=$1`, post.ID); err != nil {
- return domain.Clap{}, domain.Post{}, false, err
- }
- if err := tx.remember(in.MemberID, in.IdempotencyKey, post.ID, &id, in.Now); err != nil {
- return domain.Clap{}, domain.Post{}, false, err
+ return domain.Clap{}, domain.Post{}, err
}
if err := tx.enqueueSlackClap(post.ID, id, in.Now); err != nil {
- return domain.Clap{}, domain.Post{}, false, err
+ return domain.Clap{}, domain.Post{}, err
}
clap, err := tx.clap(id)
if err != nil {
- return domain.Clap{}, domain.Post{}, false, err
+ return domain.Clap{}, domain.Post{}, err
}
post, err = tx.post(post.ID, in.MemberID, false)
- return clap, post, false, err
+ return clap, post, err
}
func (s *Store) DeletePost(ctx context.Context, id, adminMemberID string, now time.Time) error {
return s.Do(ctx, true, func(tx *Tx) error {
diff --git a/cmd/server/peerbonus.go b/cmd/server/peerbonus.go
index c60dc91..713f99b 100644
--- a/cmd/server/peerbonus.go
+++ b/cmd/server/peerbonus.go
@@ -107,7 +107,7 @@ func peerbonusHandler(upstreamURL, projectID string) (*pending.Handler, *pending
inbound.Swap(slackinbound.New(slackinbound.Options{Store: database, Slack: client, SigningSecret: secret, PublicURL: publicURL, Now: time.Now}))
closer = &peerbonusStore{Store: database, workerDone: workerDone}
}
- peerbonus.Swap(api.New(database, auth, platform, links, directoryPublicURL, api.SlackOptions{Client: client, SigningSecretConfigured: secret != ""}))
+ peerbonus.Swap(api.New(database, auth, platform, links, directoryPublicURL, api.SlackOptions{Client: client, SigningSecretConfigured: secret != "", PlatformAPIURL: upstreamURL}))
return closer, nil
})
return peerbonus, inbound, stop, nil
diff --git a/web/src/api/peerbonus.test.ts b/web/src/api/peerbonus.test.ts
index d9341f7..97056e5 100644
--- a/web/src/api/peerbonus.test.ts
+++ b/web/src/api/peerbonus.test.ts
@@ -185,6 +185,7 @@ describe('query cache helpers', () => {
clapPoints: 0,
clappedByMe: 0,
clappers: [],
+ slackPermalink: null,
period: '2026-W43',
month: '2026-10',
createdAt: '2026-10-19T00:00:00Z',
diff --git a/web/src/api/peerbonus.ts b/web/src/api/peerbonus.ts
index 26e29e7..4c9a3d4 100644
--- a/web/src/api/peerbonus.ts
+++ b/web/src/api/peerbonus.ts
@@ -48,7 +48,10 @@ export type Program = {
}
/** Program plus the money settings only an admin reads. `pointUnitValue` is a decimal string. */
export type ProgramAdmin = Program & { pointUnitValue: string; currency: string }
-/** `clappedByMe`: how many times the caller clapped this post. `clappers`: the newest three who clapped. */
+/**
+ * `clappedByMe`: how many times the caller clapped this post. `clappers`: the newest three who clapped.
+ * `slackPermalink`: the Slack message it was given from (a mention or a reaction), else null.
+ */
export type Post = {
id: string
sender: Member
@@ -60,6 +63,7 @@ export type Post = {
clapPoints: number
clappedByMe: number
clappers: Member[]
+ slackPermalink: string | null
period: string
month: string
createdAt: string
@@ -230,12 +234,21 @@ export type SlackLocale = 'ja' | 'en'
export type SlackChannelRef = { id: string; name: string }
/** A public channel; `isMember`: the bot is in it (only then can it post there). */
export type SlackChannel = SlackChannelRef & { isMember: boolean }
+/** One reaction emoji that gives points (`emoji`: the bare name, no colons); `valueKey` is an optional Program value. */
+export type SlackReactionRule = { emoji: string; points: number; valueKey: string | null }
+/**
+ * `giveInConversation`: mentions of the bot and the `reactionRules` emoji give points.
+ * `mentionPointChoices`: the amounts (1–5) the bot offers when a mention omits points.
+ */
export type SlackSettings = {
announceChannel: SlackChannelRef | null
announcePosts: boolean
dmRecipientOnPost: boolean
giveFromSlack: boolean
locale: SlackLocale
+ giveInConversation: boolean
+ mentionPointChoices: number[]
+ reactionRules: SlackReactionRule[]
}
/** The Slack inbound endpoint the platform projected (Phase B); `url` is null until it is ready. */
export type SlackInbound = { url: string | null; ready: boolean; reason: string | null }
@@ -262,7 +275,7 @@ export type SlackDelivery = {
createdAt: string
sentAt: string | null
}
-/** `announceChannelId: null` stops announcing to any channel. */
+/** `announceChannelId: null` stops announcing to any channel. `reactionRules` replaces every rule (order kept). */
export type SlackSettingsPatch = Partial> & { announceChannelId?: string | null }
/** The two workspaces of a refused verify (409 `slack_team_changed`). */
export type SlackTeamChange = { current: { teamId: string; teamName: string }; token: { teamId: string; teamName: string } }
@@ -394,8 +407,9 @@ export interface PeerbonusApi {
slack: {
get(): Promise
/**
- * 400 `invalid_request` (unknown channel, `announcePosts` without a channel), 409 `slack_not_connected`,
- * 409 `slack_signing_secret_missing` (`giveFromSlack: true` without the signing secret).
+ * 400 `invalid_request` (unknown channel, `announcePosts` without a channel, a bad point choice or reaction rule),
+ * 400 `unknown_value` (a rule's value is not in the Program), 409 `slack_not_connected`, 409 `slack_signing_secret_missing`
+ * (`giveFromSlack` or `giveInConversation` true without the signing secret).
*/
update(patch: SlackSettingsPatch): Promise
/**
diff --git a/web/src/copy/posts.ts b/web/src/copy/posts.ts
index d1cef42..1cd2b0f 100644
--- a/web/src/copy/posts.ts
+++ b/web/src/copy/posts.ts
@@ -98,6 +98,7 @@ export const postMessages = defineDashboardMessages({
'peerbonus.post.points': { defaultMessage: '+{points} pt', translations: { ja: '+{points} pt' } },
'peerbonus.post.values': { defaultMessage: 'Values of this post', translations: { ja: 'この投稿のバリュー' } },
'peerbonus.post.open': { defaultMessage: 'Open post', translations: { ja: '投稿を開く' } },
+ 'peerbonus.post.slackOriginal': { defaultMessage: 'Original Slack message', translations: { ja: 'Slack の元メッセージ' } },
'peerbonus.post.actions': { defaultMessage: 'Post actions', translations: { ja: '投稿の操作' } },
'peerbonus.post.clappedBy': { defaultMessage: 'Clapped by {names}', translations: { ja: '拍手した人: {names}' } },
'peerbonus.post.clappedByMore': { defaultMessage: 'Clapped by {names} and {count} more claps', translations: { ja: '拍手した人: {names} ほか {count} 件' } },
diff --git a/web/src/copy/slack.ts b/web/src/copy/slack.ts
index 3d419f3..33e7492 100644
--- a/web/src/copy/slack.ts
+++ b/web/src/copy/slack.ts
@@ -1,6 +1,7 @@
// Slack integration wording (`/admin/slack`): connection state, the setup
-// guide, delivery settings, the inbound endpoint (Phase B) and the delivery
-// log. Product names (Slack, Dashboard, manifest, bot token) stay in English.
+// guide, delivery settings, giving in a conversation (mentions and reaction
+// emoji), the inbound endpoint (Phase B) and the delivery log. Product names
+// (Slack, Dashboard, manifest, bot token) stay in English.
import { defineDashboardMessages } from '@appthrust/platform-dashboard-i18n'
export const slackMessages = defineDashboardMessages({
@@ -182,11 +183,81 @@ export const slackMessages = defineDashboardMessages({
},
'peerbonus.slack.testSent': { defaultMessage: 'Test message sent to #{channel}.', translations: { ja: '#{channel} にテストメッセージを送りました。' } },
+ // Give in conversation (mentions and reaction emoji)
+ 'peerbonus.slack.conversation.title': { defaultMessage: 'Give in conversation', translations: { ja: '会話の中で贈る' } },
+ 'peerbonus.slack.conversation.lead': {
+ defaultMessage: 'Give points without leaving a Slack conversation: mention Peer Bonus, or react with an emoji chosen below.',
+ translations: { ja: 'Slack の会話から、メンションか絵文字で pt を贈れます。' },
+ },
+ 'peerbonus.slack.conversation.toggle': { defaultMessage: 'Give with mentions and emoji', translations: { ja: 'メンションと絵文字で贈る' } },
+ 'peerbonus.slack.conversation.toggleHint': {
+ defaultMessage: 'Mentions of @Peer Bonus and the emoji below give points.',
+ translations: { ja: '@Peer Bonus へのメンションと、下の絵文字で贈れます。' },
+ },
+ 'peerbonus.slack.conversation.noInbound': {
+ defaultMessage: 'Slack has no URL to send to yet: the platform has not published the request URL.',
+ translations: { ja: 'Slack からのリクエスト URL がまだないため、使えません。' },
+ },
+ 'peerbonus.slack.conversation.choices': { defaultMessage: 'Point choices', translations: { ja: 'pt の候補' } },
+ 'peerbonus.slack.conversation.choicesHint': {
+ defaultMessage: 'When a mention has no points, the bot offers these as buttons. Up to {limit}, each 1–{max} pt.',
+ translations: { ja: 'pt を書かないメンションに、bot がボタンで出します。{limit} 個まで、各 1〜{max} pt。' },
+ },
+ 'peerbonus.slack.conversation.choice': { defaultMessage: 'Choice {index}', translations: { ja: '候補 {index}' } },
+ 'peerbonus.slack.conversation.addChoice': { defaultMessage: 'Add', translations: { ja: '追加' } },
+ 'peerbonus.slack.conversation.removeChoice': { defaultMessage: 'Remove choice {index}', translations: { ja: '候補 {index} を外す' } },
+ 'peerbonus.slack.conversation.rules': { defaultMessage: 'Reaction emoji', translations: { ja: '絵文字' } },
+ 'peerbonus.slack.conversation.rulesHint': {
+ defaultMessage: 'Reacting to someone’s message with one of these gives them its points. Add custom emoji in Slack first.',
+ translations: { ja: '相手のメッセージにこの絵文字を付けると、その pt を贈ります。カスタム絵文字は先に Slack で追加します。' },
+ },
+ 'peerbonus.slack.conversation.rulesEmpty': { defaultMessage: 'No emoji yet. Mentions work without them.', translations: { ja: 'まだありません。メンションだけでも贈れます。' } },
+ 'peerbonus.slack.conversation.rule': { defaultMessage: 'Emoji {index}', translations: { ja: '絵文字 {index}' } },
+ 'peerbonus.slack.conversation.emoji': { defaultMessage: 'Emoji name', translations: { ja: '絵文字の名前' } },
+ 'peerbonus.slack.conversation.points': { defaultMessage: 'Points per reaction', translations: { ja: 'pt' } },
+ 'peerbonus.slack.conversation.value': { defaultMessage: 'Value', translations: { ja: 'バリュー' } },
+ 'peerbonus.slack.conversation.noValue': { defaultMessage: 'None', translations: { ja: 'なし' } },
+ 'peerbonus.slack.conversation.removedValue': { defaultMessage: '#{key} (removed)', translations: { ja: '#{key}(削除済み)' } },
+ 'peerbonus.slack.conversation.addRule': { defaultMessage: 'Add emoji', translations: { ja: '絵文字を追加' } },
+ 'peerbonus.slack.conversation.removeRule': { defaultMessage: 'Remove emoji {index}', translations: { ja: '絵文字 {index} を削除' } },
+ 'peerbonus.slack.conversation.rulesCount': { defaultMessage: '{count} of {max} emoji', translations: { ja: '{count} / {max}' } },
+ 'peerbonus.slack.conversation.everyday': {
+ defaultMessage: 'People react with :{emoji}: every day, so points may be given by accident.',
+ translations: { ja: ':{emoji}: は普段よく使われるため、うっかり贈られることがあります。' },
+ },
+ 'peerbonus.slack.conversation.error.pointsRange': { defaultMessage: 'Enter 1 to {max}.', translations: { ja: '1〜{max} で入力してください。' } },
+ 'peerbonus.slack.conversation.error.choiceDuplicate': { defaultMessage: 'Already a choice.', translations: { ja: 'すでにあります。' } },
+ 'peerbonus.slack.conversation.error.emojiRequired': { defaultMessage: 'Enter the emoji name.', translations: { ja: '絵文字の名前を入力してください。' } },
+ 'peerbonus.slack.conversation.error.emojiInvalid': {
+ defaultMessage: 'Enter only the name, without spaces (e.g. pb-10).',
+ translations: { ja: 'スペースなしで名前だけを入力してください(例: pb-10)。' },
+ },
+ 'peerbonus.slack.conversation.error.emojiDuplicate': { defaultMessage: 'This emoji is already listed.', translations: { ja: 'この絵文字はすでにあります。' } },
+ 'peerbonus.slack.conversation.error.valueUnknown': {
+ defaultMessage: 'This value was removed from the program. Choose another.',
+ translations: { ja: 'このバリューは削除されました。選び直してください。' },
+ },
+ 'peerbonus.slack.conversation.help': { defaultMessage: 'How to use', translations: { ja: '使い方' } },
+ 'peerbonus.slack.conversation.helpMention': { defaultMessage: 'Mention the bot and the person, then points and a message:', translations: { ja: 'メンションで贈る:' } },
+ 'peerbonus.slack.conversation.helpExample': { defaultMessage: '@Peer Bonus @person 30 message', translations: { ja: '@Peer Bonus @相手 30 メッセージ' } },
+ 'peerbonus.slack.conversation.helpAsk': {
+ defaultMessage: 'Leave out the points and the bot asks how many, visible only to you.',
+ translations: { ja: 'pt を省くと、bot が本人にだけ見えるボタンで聞きます。' },
+ },
+ 'peerbonus.slack.conversation.helpInvite': {
+ defaultMessage: 'It works only in channels Peer Bonus is in: run /invite @Peer Bonus there.',
+ translations: { ja: '使うチャンネルで /invite @Peer Bonus してください。bot がいるチャンネルだけで使えます。' },
+ },
+ 'peerbonus.slack.conversation.helpReinstall': {
+ defaultMessage: 'First time: replace the app’s manifest with the one under Requests from Slack, then reinstall the app (it needs two more permissions).',
+ translations: { ja: '初めて使うときは、Slack アプリの manifest を「Slack からのリクエスト」のものに置き換え、アプリを再インストールしてください(権限が 2 つ増えます)。' },
+ },
+
// Inbound (Phase B)
'peerbonus.slack.inbound.title': { defaultMessage: 'Requests from Slack', translations: { ja: 'Slack からのリクエスト' } },
'peerbonus.slack.inbound.lead': {
- defaultMessage: 'Slack sends the /peerbonus command and button presses to this URL. The manifest below already points there.',
- translations: { ja: 'Slack は /peerbonus コマンドとボタン操作をこの URL に送ります。下の manifest は設定済みです。' },
+ defaultMessage: 'Slack sends the /peerbonus command, button presses, mentions and reactions to this URL. The manifest below already points there.',
+ translations: { ja: 'Slack は /peerbonus コマンド、ボタン操作、メンション、リアクションをこの URL に送ります。下の manifest は設定済みです。' },
},
'peerbonus.slack.inbound.url': { defaultMessage: 'Request URL', translations: { ja: 'リクエスト URL' } },
'peerbonus.slack.inbound.ready': { defaultMessage: 'Ready', translations: { ja: '受付中' } },
@@ -195,8 +266,8 @@ export const slackMessages = defineDashboardMessages({
'peerbonus.slack.inbound.reason': { defaultMessage: 'Reason: {reason}', translations: { ja: '理由: {reason}' } },
'peerbonus.slack.inbound.download': { defaultMessage: 'Download manifest with commands (JSON)', translations: { ja: 'コマンド付き manifest をダウンロード(JSON)' } },
'peerbonus.slack.inbound.downloadHint': {
- defaultMessage: 'In the Slack app’s settings, replace App Manifest with this file.',
- translations: { ja: 'Slack アプリの設定で、App Manifest をこのファイルの内容に置き換えます。' },
+ defaultMessage: 'In the Slack app’s settings, replace App Manifest with this file. When it adds permissions, reinstall the app to the workspace.',
+ translations: { ja: 'Slack アプリの設定で、App Manifest をこのファイルの内容に置き換えます。権限が増えたときは、アプリを再インストールしてください。' },
},
// Delivery log
diff --git a/web/src/dev/mock-admin.test.ts b/web/src/dev/mock-admin.test.ts
index 1ba93ef..4196f79 100644
--- a/web/src/dev/mock-admin.test.ts
+++ b/web/src/dev/mock-admin.test.ts
@@ -301,7 +301,16 @@ describe('admin mock: Slack', () => {
credential: { botToken: true, signingSecret: false },
state: 'configured',
workspace: null,
- settings: { announceChannel: null, announcePosts: false, dmRecipientOnPost: true, giveFromSlack: false, locale: 'ja' },
+ settings: {
+ announceChannel: null,
+ announcePosts: false,
+ dmRecipientOnPost: true,
+ giveFromSlack: false,
+ locale: 'ja',
+ giveInConversation: false,
+ mentionPointChoices: [10, 30, 50],
+ reactionRules: [],
+ },
inbound: null,
lastError: null,
deliveries: { pending: 0, failed24h: 0, sent24h: 0 },
@@ -322,7 +331,7 @@ describe('admin mock: Slack', () => {
await connect()
const { status, body } = await call('PATCH', '/admin/slack', { announceChannelId: 'C0GENERAL', announcePosts: true, locale: 'en' })
expect(status).toBe(200)
- expect(body.settings).toEqual({ announceChannel: { id: 'C0GENERAL', name: 'general' }, announcePosts: true, dmRecipientOnPost: true, giveFromSlack: false, locale: 'en' })
+ expect(body.settings).toMatchObject({ announceChannel: { id: 'C0GENERAL', name: 'general' }, announcePosts: true, dmRecipientOnPost: true, giveFromSlack: false, locale: 'en' })
expect((await slack()).settings).toEqual(body.settings)
expect((await call('PATCH', '/admin/slack', { announceChannelId: 'C0NOPE' })).status).toBe(400)
expect((await call('PATCH', '/admin/slack', { announceChannelId: null })).status).toBe(400)
@@ -333,6 +342,49 @@ describe('admin mock: Slack', () => {
expect((await call('PATCH', '/admin/slack', { giveFromSlack: true })).body.settings.giveFromSlack).toBe(true)
})
+ test('giving in a conversation: choices and rules persist (emoji normalized), checked against the Program; the switch needs the secret', async () => {
+ const patch = (body: unknown) => call('PATCH', '/admin/slack', body)
+ expect((await patch({ mentionPointChoices: [5] })).body.error).toBe('slack_not_connected')
+ await connect()
+ const rules = [
+ { emoji: ':PB-10:', points: 10, valueKey: null },
+ { emoji: 'pb-30::skin-tone-2', points: 30, valueKey: 'thanks' },
+ ]
+ const saved = await patch({ mentionPointChoices: [5, 20], reactionRules: rules })
+ expect(saved.status).toBe(200)
+ expect(saved.body.settings).toMatchObject({
+ mentionPointChoices: [5, 20],
+ reactionRules: [
+ { emoji: 'pb-10', points: 10, valueKey: null },
+ { emoji: 'pb-30', points: 30, valueKey: 'thanks' },
+ ],
+ })
+ expect((await slack()).settings).toEqual(saved.body.settings)
+ // A PATCH without the lists keeps them.
+ expect((await patch({ locale: 'en' })).body.settings.reactionRules).toHaveLength(2)
+
+ for (const [body, error] of [
+ [{ mentionPointChoices: [] }, 'invalid_request'],
+ [{ mentionPointChoices: [10, 20, 30, 40, 50, 60] }, 'invalid_request'],
+ [{ mentionPointChoices: [10, 10] }, 'invalid_request'],
+ [{ mentionPointChoices: [121] }, 'invalid_request'],
+ [{ reactionRules: [{ emoji: 'a b', points: 10, valueKey: null }] }, 'invalid_request'],
+ [{ reactionRules: [{ emoji: 'pb', points: 10, valueKey: null }, { emoji: ':pb:', points: 20, valueKey: null }] }, 'invalid_request'],
+ [{ reactionRules: [{ emoji: 'pb', points: 0, valueKey: null }] }, 'invalid_request'],
+ [{ reactionRules: Array.from({ length: 9 }, (_, index) => ({ emoji: `pb-${index}`, points: 10, valueKey: null })) }, 'invalid_request'],
+ [{ reactionRules: [{ emoji: 'pb', points: 10, valueKey: 'nope' }] }, 'unknown_value'],
+ [{ giveInConversation: true }, 'slack_signing_secret_missing'],
+ ] as const) {
+ const refused = await patch(body)
+ expect([JSON.stringify(body), refused.status, refused.body.error]).toEqual([JSON.stringify(body), error === 'slack_signing_secret_missing' ? 409 : 400, error])
+ }
+ // Nothing of a refused PATCH was applied.
+ expect((await slack()).settings).toMatchObject({ giveInConversation: false, mentionPointChoices: [5, 20] })
+ await call('POST', '/__mock/slack', { signingSecret: true })
+ expect((await patch({ giveInConversation: true })).body.settings.giveInConversation).toBe(true)
+ expect((await patch({ reactionRules: [] })).body.settings.reactionRules).toEqual([])
+ })
+
test('channels: prefix search with the bot membership, at most the limit', async () => {
const names = async (query: string) => ((await call('GET', `/admin/slack/channels${query}`)).body.items as SlackChannel[]).map((channel) => `${channel.name}:${channel.isMember}`)
expect(await names('?q=sal')).toEqual(['sales:false', 'sales-jp:false'])
diff --git a/web/src/dev/mock-admin.ts b/web/src/dev/mock-admin.ts
index 026c2a1..f6663b7 100644
--- a/web/src/dev/mock-admin.ts
+++ b/web/src/dev/mock-admin.ts
@@ -16,7 +16,9 @@
// - Slack (`/admin/slack*`, design slack-integration §5): starts `configured`
// (bot token set, workspace not verified, no signing secret, no inbound).
// Verify fixes the token's workspace (`Acme`); PATCH validates and
-// persists; a test message to a channel the bot is in records a sent
+// persists (giving in a conversation, design reaction-give §5: point
+// choices and reaction rules checked against the Program, emoji names
+// normalized); a test message to a channel the bot is in records a sent
// delivery (an announce of the newest post), one the bot is not in is 409
// `slack_bot_not_in_channel`. `POST /__mock/slack {botToken?, signingSecret?,
// team?: {teamId, teamName}, inbound?, invite?: channelId}` changes the
@@ -47,6 +49,7 @@ import type {
SlackDelivery,
SlackDeliveryState,
SlackInbound,
+ SlackReactionRule,
SlackSettings,
SlackState,
Statement,
@@ -344,7 +347,16 @@ function mockSlack(): MockSlack {
signingSecret: false,
token: { ...MOCK_SLACK_TEAM },
workspace: null,
- settings: { announceChannel: null, announcePosts: false, dmRecipientOnPost: true, giveFromSlack: false, locale: 'ja' },
+ settings: {
+ announceChannel: null,
+ announcePosts: false,
+ dmRecipientOnPost: true,
+ giveFromSlack: false,
+ locale: 'ja',
+ giveInConversation: false,
+ mentionPointChoices: [10, 30, 50],
+ reactionRules: [],
+ },
inbound: null,
lastError: null,
channels: MOCK_SLACK_CHANNELS.map((channel) => ({ ...channel })),
@@ -370,7 +382,12 @@ function slackJson(): SlackAdmin {
credential: { botToken: slack.botToken, signingSecret: slack.signingSecret },
state: slackState(slack),
workspace: slack.workspace && { ...slack.workspace },
- settings: { ...slack.settings, announceChannel: slack.settings.announceChannel && { ...slack.settings.announceChannel } },
+ settings: {
+ ...slack.settings,
+ announceChannel: slack.settings.announceChannel && { ...slack.settings.announceChannel },
+ mentionPointChoices: [...slack.settings.mentionPointChoices],
+ reactionRules: slack.settings.reactionRules.map((rule) => ({ ...rule })),
+ },
inbound: slack.inbound && { ...slack.inbound },
lastError: slack.lastError && { ...slack.lastError },
deliveries: {
@@ -383,15 +400,61 @@ function slackJson(): SlackAdmin {
const slackNotConnected = () => fail(409, 'slack_not_connected', 'Slack is not connected; verify the workspace first')
-/** PATCH /admin/slack: types, a known channel, then the state and secret gates; applies everything or nothing. */
+/** domain.SlackMaxPointChoices / SlackMaxReactionRules. */
+const MAX_POINT_CHOICES = 5
+const MAX_REACTION_RULES = 8
+
+/** domain.NormalizeSlackEmoji. */
+const normalizeEmoji = (name: string) => {
+ const bare = name.trim().toLowerCase()
+ const tone = bare.indexOf('::')
+ return (tone >= 0 ? bare.slice(0, tone) : bare).replace(/^:+|:+$/g, '')
+}
+
+/** domain.ValidateMentionPointChoices against the Program; the list or an error response. */
+function pointChoicesOf(input: unknown): number[] | Response {
+ const max = mockState().program.maxPointsPerPost
+ if (!Array.isArray(input) || input.length < 1 || input.length > MAX_POINT_CHOICES) return invalid(`mentionPointChoices must contain 1 to ${MAX_POINT_CHOICES} amounts`)
+ if (input.some((points, index) => !Number.isInteger(points) || points < 1 || points > max || input.indexOf(points) !== index)) {
+ return invalid('amounts must be unique and between 1 and the maximum per post')
+ }
+ return input as number[]
+}
+
+/** Emoji through domain.NormalizeSlackEmoji, then domain.ValidateSlackReactionRules against the Program. */
+function reactionRulesOf(input: unknown): SlackReactionRule[] | Response {
+ const program = mockState().program
+ if (!Array.isArray(input)) return invalid('reactionRules must be a list')
+ if (input.length > MAX_REACTION_RULES) return invalid(`reactionRules must contain at most ${MAX_REACTION_RULES} rules`)
+ const rules: SlackReactionRule[] = []
+ for (const item of input as unknown[]) {
+ const row = item as Record | null
+ const valueKey = row?.valueKey ?? null
+ if (typeof row?.emoji !== 'string' || !Number.isInteger(row.points) || (valueKey !== null && typeof valueKey !== 'string')) return invalid('each rule needs an emoji, points and an optional value key')
+ const emoji = normalizeEmoji(row.emoji)
+ if (emoji === '' || emoji.length > 100 || /[:\s]/.test(emoji)) return invalid('emoji must be a Slack emoji name without colons')
+ if (rules.some((rule) => rule.emoji === emoji)) return invalid('emoji must be unique')
+ const points = row.points as number
+ if (points < 1 || points > program.maxPointsPerPost) return invalid('points must be between 1 and the maximum per post')
+ if (valueKey !== null && !program.values.some((value) => value.key === valueKey)) return fail(400, 'unknown_value', 'A value is not defined by the program')
+ rules.push({ emoji, points, valueKey: valueKey as string | null })
+ }
+ return rules
+}
+
+/** PATCH /admin/slack: types, a known channel, the conversation lists, then the state and secret gates; applies everything or nothing. */
async function updateSlack(request: Request): Promise {
const slack = mockSlack()
const input = await readJson(request)
if (!input) return invalid('A JSON object is required')
- const { announceChannelId, announcePosts, dmRecipientOnPost, giveFromSlack, locale } = input
- for (const flag of [announcePosts, dmRecipientOnPost, giveFromSlack]) if (flag !== undefined && typeof flag !== 'boolean') return invalid('flags must be booleans')
+ const { announceChannelId, announcePosts, dmRecipientOnPost, giveFromSlack, locale, giveInConversation, mentionPointChoices, reactionRules } = input
+ for (const flag of [announcePosts, dmRecipientOnPost, giveFromSlack, giveInConversation]) if (flag !== undefined && typeof flag !== 'boolean') return invalid('flags must be booleans')
if (locale !== undefined && locale !== 'ja' && locale !== 'en') return invalid('locale must be ja or en')
if (announceChannelId !== undefined && announceChannelId !== null && typeof announceChannelId !== 'string') return invalid('announceChannelId must be a string or null')
+ const choices = mentionPointChoices === undefined ? slack.settings.mentionPointChoices : pointChoicesOf(mentionPointChoices)
+ if (choices instanceof Response) return choices
+ const rules = reactionRules === undefined ? slack.settings.reactionRules : reactionRulesOf(reactionRules)
+ if (rules instanceof Response) return rules
if (slackState(slack) !== 'connected') return slackNotConnected()
let channel = slack.settings.announceChannel
if (typeof announceChannelId === 'string') {
@@ -407,9 +470,14 @@ async function updateSlack(request: Request): Promise {
dmRecipientOnPost: (dmRecipientOnPost as boolean | undefined) ?? slack.settings.dmRecipientOnPost,
giveFromSlack: (giveFromSlack as boolean | undefined) ?? slack.settings.giveFromSlack,
locale: (locale as SlackSettings['locale'] | undefined) ?? slack.settings.locale,
+ giveInConversation: (giveInConversation as boolean | undefined) ?? slack.settings.giveInConversation,
+ mentionPointChoices: [...choices],
+ reactionRules: rules.map((rule) => ({ ...rule })),
}
if (next.announcePosts && !next.announceChannel) return invalid('announcePosts requires an announce channel')
- if (giveFromSlack === true && !slack.signingSecret) return fail(409, 'slack_signing_secret_missing', 'Set the Slack signing secret before giving from Slack')
+ if ((giveFromSlack === true || giveInConversation === true) && !slack.signingSecret) {
+ return fail(409, 'slack_signing_secret_missing', 'Set the Slack signing secret before giving from Slack')
+ }
slack.settings = next
return json(slackJson())
}
diff --git a/web/src/dev/mock-peerbonus.test.ts b/web/src/dev/mock-peerbonus.test.ts
index 87fda1e..f351197 100644
--- a/web/src/dev/mock-peerbonus.test.ts
+++ b/web/src/dev/mock-peerbonus.test.ts
@@ -89,7 +89,7 @@ describe('peerbonus mock contract', () => {
const sent = await send('sato', 30, { values: ['challenge', 'thanks'] }, 'once')
expect(sent.status).toBe(201)
const post = sent.body as Post
- expect(post).toMatchObject({ points: 30, values: ['challenge', 'thanks'], clapCount: 0, clappedByMe: 0, period: '2026-W43', month: '2026-10' })
+ expect(post).toMatchObject({ points: 30, values: ['challenge', 'thanks'], clapCount: 0, clappedByMe: 0, period: '2026-W43', month: '2026-10', slackPermalink: null })
expect(post.sender.id).toBe(MOCK_MEMBER_IDS.yamada)
expect(post.recipient.personId).toBe('p-sato')
expect((await me()).stats.period.remaining).toBe(before.stats.period.remaining - 30)
@@ -101,6 +101,14 @@ describe('peerbonus mock contract', () => {
expect((await me()).stats.period.remaining).toBe(before.stats.period.remaining - 30)
})
+ test('every seventh seeded post was given in Slack and carries its permalink', async () => {
+ const items = ((await call('GET', '/posts?limit=50')).body as PostPage).items
+ const linked = items.filter((post) => post.slackPermalink !== null)
+ expect(linked.length).toBeGreaterThan(0)
+ expect(linked.length).toBeLessThan(items.length)
+ for (const post of linked) expect(post.slackPermalink).toMatch(/^https:\/\/acme\.slack\.com\/archives\/C0KUDOS\/p\d+$/)
+ })
+
test('sending to a Directory-only person creates a pending member', async () => {
const post = (await send('kobayashi', 10)).body as Post
expect(post.recipient).toMatchObject({ personId: 'p-kobayashi', displayName: '小林 優', pending: true })
diff --git a/web/src/dev/mock-peerbonus.ts b/web/src/dev/mock-peerbonus.ts
index f432a44..9aa568d 100644
--- a/web/src/dev/mock-peerbonus.ts
+++ b/web/src/dev/mock-peerbonus.ts
@@ -11,7 +11,9 @@
// Watanabe to no group (the empty-team view).
// About fifty posts spread over the current and the two previous months (more
// than one timeline page), claps from uninvolved members, and the append-only
-// ledger both produce. Seeds are relative to the mock clock at reset time.
+// ledger both produce. Every seventh seeded post was given in Slack (a mention
+// in #kudos), so it links its Slack message. Seeds are relative to the mock
+// clock at reset time.
// The caller is 山田 (peerbonus admin) unless MOCK_ROLE is set to anything but
// Admin. `POST /__mock/caller {memberId, admin?}` switches the caller (default
// not admin); `POST /__mock/directory {up}` takes Directory down to exercise
@@ -48,6 +50,8 @@ export type MockPost = {
message: string
values: string[]
createdAt: string
+ /** The Slack message a give in a conversation came from; null for posts from the web. */
+ slackPermalink: string | null
deletedAt: string | null
deletedBy: string | null
reversed: boolean
@@ -254,6 +258,7 @@ function seed(): MockState {
if (recipient === sender) recipient = MOCK_MEMBER_IDS[names[(index * 5 + 2) % names.length]!]
const values = Array.from({ length: index % 4 }, (_, position) => VALUES[(index + position) % VALUES.length]!.key)
const post = writePost(sender, recipient, POINTS[index % POINTS.length]!, MESSAGES[index % MESSAGES.length]!, values, at)
+ if (index % 7 === 3) post.slackPermalink = `https://acme.slack.com/archives/C0KUDOS/p${Math.floor(at / 1000)}000100`
// Up to two uninvolved members clap an hour later (never after "now").
let clappers = 0
for (const [offset, name] of names.entries()) {
@@ -365,6 +370,7 @@ function writePost(senderId: string, recipientId: string, points: number, messag
message,
values,
createdAt,
+ slackPermalink: null,
deletedAt: null,
deletedBy: null,
reversed: false,
@@ -403,6 +409,7 @@ function postJson(post: MockPost): Post {
period: post.periodKey,
month: post.monthKey,
createdAt: post.createdAt,
+ slackPermalink: post.slackPermalink,
}
}
diff --git a/web/src/features/admin/slack/conversation-settings.tsx b/web/src/features/admin/slack/conversation-settings.tsx
new file mode 100644
index 0000000..0e01cb0
--- /dev/null
+++ b/web/src/features/admin/slack/conversation-settings.tsx
@@ -0,0 +1,383 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query'
+import { useBlocker } from '@tanstack/react-router'
+import { AlertTriangle, Lock, Plus, Save, Trash2, X } from 'lucide-react'
+import { useEffect, useId, useReducer, useRef, useState, type FormEvent } from 'react'
+import { peerbonusApi, type ProgramAdmin, type SlackAdmin, type SlackSettings } from '../../../api/peerbonus'
+import { useText } from '../../../i18n'
+import { Button, cn, controlClasses, Field, IconButton, Notice, TextInput } from '../../../ui'
+import { slackQuery, SLACK_KEY } from '../queries'
+import { Card, SwitchRow } from './parts'
+import { SlackActionError } from './slack-error'
+import { conversationBlocker } from './slack-state'
+import {
+ conversationDraftOf,
+ conversationPatchOf,
+ conversationReducer,
+ isEverydayEmoji,
+ MAX_POINT_CHOICES,
+ MAX_REACTION_RULES,
+ newRowId,
+ normalizeSlackEmoji,
+ validateConversation,
+ type ConversationAction,
+} from './slack-form'
+
+/**
+ * 会話の中で贈る (design reaction-give): the switch for mentions and reaction emoji, the point choices
+ * the bot offers when a mention omits points, the emoji → points rules, and how to use it. Saved
+ * together; locked until the workspace is connected. The switch needs the signing secret (the server
+ * refuses without it) and the inbound URL (Slack has nowhere to send events otherwise); turning it
+ * off stays possible. Row problems show once the field was left or a save was tried. A save replaces
+ * the settings; the form restarts from what the server stored (`key` by the caller).
+ */
+export function ConversationSettingsCard({
+ slack,
+ program,
+ justSaved,
+ onSaved,
+}: {
+ slack: SlackAdmin
+ program: ProgramAdmin
+ justSaved: boolean
+ onSaved: (settings: SlackSettings) => void
+}) {
+ const { t } = useText()
+ const client = useQueryClient()
+ const id = useId()
+ const [draft, dispatch] = useReducer(conversationReducer, slack.settings, conversationDraftOf)
+ const [saved, setSaved] = useState(justSaved)
+ const [attempted, setAttempted] = useState(false)
+ const [touched, setTouched] = useState([])
+ const rootRef = useRef(null)
+ // After add / remove, the new row (or the neighbour, or the add button) takes focus once it renders.
+ const focusNext = useRef(null)
+ useEffect(() => {
+ const target = focusNext.current
+ if (!target) return
+ focusNext.current = null
+ rootRef.current?.querySelector(`[data-focus="${CSS.escape(target)}"]`)?.focus()
+ })
+
+ const locked = slack.state !== 'connected'
+ const max = program.maxPointsPerPost
+ const problems = validateConversation(draft, { signingSecret: slack.credential.signingSecret, maxPointsPerPost: max, valueKeys: program.values.map((value) => value.key) })
+ const patch = conversationPatchOf(draft, slack.settings)
+ const dirty = Object.keys(patch).length > 0
+ const hasProblems = Object.keys(problems).length > 0
+ const shown = (field: string) => attempted || touched.includes(field)
+ const touch = (field: string) => setTouched((fields) => (fields.includes(field) ? fields : [...fields, field]))
+
+ const save = useMutation({
+ mutationFn: () => peerbonusApi.admin.slack.update(patch),
+ onSuccess: async (result) => {
+ onSaved(result.settings)
+ client.setQueryData(slackQuery.queryKey, result)
+ await client.invalidateQueries({ queryKey: SLACK_KEY })
+ },
+ })
+
+ useBlocker({
+ shouldBlockFn: () => dirty && !save.isPending && !window.confirm(t('peerbonus.admin.program.leave')),
+ enableBeforeUnload: () => dirty,
+ })
+
+ const edit = (action: ConversationAction) => {
+ dispatch(action)
+ setSaved(false)
+ if (save.isError) save.reset()
+ }
+ const submit = (event: FormEvent) => {
+ event.preventDefault()
+ setAttempted(true)
+ if (!dirty || hasProblems || locked) return
+ save.mutate()
+ }
+
+ const choiceErrors = Object.entries(problems.choices ?? {}).filter(([rowId]) => shown(`${rowId}-points`))
+ const choiceError = choiceErrors.some(([, problem]) => problem === 'range')
+ ? t('peerbonus.slack.conversation.error.pointsRange', { max })
+ : choiceErrors.length > 0
+ ? t('peerbonus.slack.conversation.error.choiceDuplicate')
+ : undefined
+ const blocker = conversationBlocker(slack)
+
+ return (
+
+
+
+ )
+}
diff --git a/web/src/features/admin/slack/manifest.test.ts b/web/src/features/admin/slack/manifest.test.ts
index 86e144d..9327173 100644
--- a/web/src/features/admin/slack/manifest.test.ts
+++ b/web/src/features/admin/slack/manifest.test.ts
@@ -15,16 +15,17 @@ describe('Slack app manifest (design §8)', () => {
expect(generateManifest({ inboundUrl: INBOUND, phaseB: false })).toEqual(generateManifest({ inboundUrl: null, phaseB: false }))
})
- test('Phase B: /peerbonus, interactivity and options load URL under the inbound endpoint, plus the commands scope', () => {
+ test('Phase B: /peerbonus, interactivity, options load URL and events under the inbound endpoint, plus their scopes', () => {
expect(generateManifest({ inboundUrl: `${INBOUND}/`, phaseB: true })).toEqual({
display_information: { name: 'Peer Bonus', description: 'Send points and thanks to colleagues from Slack.' },
features: {
bot_user: { display_name: 'Peer Bonus', always_online: true },
slash_commands: [{ command: '/peerbonus', url: `${INBOUND}/commands`, description: 'Send points and thanks', usage_hint: '[balance]' }],
},
- oauth_config: { scopes: { bot: ['chat:write', 'channels:read', 'users:read', 'users:read.email', 'im:write', 'commands'] } },
+ oauth_config: { scopes: { bot: ['chat:write', 'channels:read', 'users:read', 'users:read.email', 'im:write', 'commands', 'app_mentions:read', 'reactions:read'] } },
settings: {
interactivity: { is_enabled: true, request_url: `${INBOUND}/interactions`, message_menu_options_url: `${INBOUND}/options` },
+ event_subscriptions: { request_url: `${INBOUND}/events`, bot_events: ['app_mention', 'reaction_added'] },
org_deploy_enabled: false,
socket_mode_enabled: false,
},
@@ -42,5 +43,9 @@ describe('Slack app manifest (design §8)', () => {
expect(text.endsWith('}\n')).toBe(true)
expect(text).toContain('\n "display_information": {')
expect(decodeURIComponent(manifestHref(manifest).replace('data:application/json;charset=utf-8,', ''))).toBe(text)
+ // The download a Phase B admin gets names both events.
+ const phaseB = decodeURIComponent(manifestHref(generateManifest({ inboundUrl: INBOUND, phaseB: true })))
+ expect(phaseB).toContain('"app_mention"')
+ expect(phaseB).toContain('"reaction_added"')
})
})
diff --git a/web/src/features/admin/slack/manifest.ts b/web/src/features/admin/slack/manifest.ts
index c7c7a47..5ac8987 100644
--- a/web/src/features/admin/slack/manifest.ts
+++ b/web/src/features/admin/slack/manifest.ts
@@ -1,8 +1,9 @@
// The Slack app manifest an admin pastes into https://api.slack.com/apps
// (Create New App › From a manifest), design slack-integration §8, as JSON.
// Phase A (output only) has the bot and its scopes; Phase B adds the
-// `/peerbonus` command, interactivity and the options load URL, all pointing
-// at the Slack inbound endpoint the platform projected for this Project.
+// `/peerbonus` command, interactivity and the options load URL, and the
+// mention and reaction events (giving in a conversation), all pointing at the
+// Slack inbound endpoint the platform projected for this Project.
/** The bot's display name; the `/invite @Peer Bonus` hint names it too. */
export const SLACK_APP_NAME = 'Peer Bonus'
@@ -18,15 +19,17 @@ export type SlackManifest = {
oauth_config: { scopes: { bot: string[] } }
settings: {
interactivity?: { is_enabled: boolean; request_url: string; message_menu_options_url: string }
+ event_subscriptions?: { request_url: string; bot_events: string[] }
org_deploy_enabled: boolean
socket_mode_enabled: boolean
}
}
/**
- * The manifest for `phaseB` (Slack → Peer Bonus: command, modal, clap button) or Phase A (announcements
- * and DMs only). `inboundUrl` is the endpoint's base (`https://in.//`);
- * Phase B needs it, Phase A ignores it.
+ * The manifest for `phaseB` (Slack → Peer Bonus: command, modal, clap button, mentions and reaction
+ * emoji) or Phase A (announcements and DMs only). `inboundUrl` is the endpoint's base
+ * (`https://in.//`); Phase B needs it, Phase A ignores it. A Phase B
+ * manifest adds scopes, so a workspace that installed an earlier one has to reinstall the app.
*/
export function generateManifest({ inboundUrl, phaseB }: { inboundUrl: string | null; phaseB: boolean }): SlackManifest {
const manifest: SlackManifest = {
@@ -39,9 +42,10 @@ export function generateManifest({ inboundUrl, phaseB }: { inboundUrl: string |
if (!inboundUrl) throw new Error('a Phase B manifest needs the inbound URL')
const base = inboundUrl.replace(/\/+$/, '')
manifest.features.slash_commands = [{ command: '/peerbonus', url: `${base}/commands`, description: 'Send points and thanks', usage_hint: '[balance]' }]
- manifest.oauth_config.scopes.bot.push('commands')
+ manifest.oauth_config.scopes.bot.push('commands', 'app_mentions:read', 'reactions:read')
manifest.settings = {
interactivity: { is_enabled: true, request_url: `${base}/interactions`, message_menu_options_url: `${base}/options` },
+ event_subscriptions: { request_url: `${base}/events`, bot_events: ['app_mention', 'reaction_added'] },
...manifest.settings,
}
return manifest
diff --git a/web/src/features/admin/slack/slack-form.test.ts b/web/src/features/admin/slack/slack-form.test.ts
index e8ce33a..cd90256 100644
--- a/web/src/features/admin/slack/slack-form.test.ts
+++ b/web/src/features/admin/slack/slack-form.test.ts
@@ -1,8 +1,32 @@
import { describe, expect, test } from 'bun:test'
import type { SlackSettings } from '../../../api/peerbonus'
-import { slackDraftReducer, slackPatchOf, validateSlackDraft, type SlackDraftAction } from './slack-form'
+import {
+ conversationDraftOf,
+ conversationKey,
+ conversationPatchOf,
+ conversationReducer,
+ deliveryKey,
+ isEverydayEmoji,
+ newRowId,
+ normalizeSlackEmoji,
+ slackDraftReducer,
+ slackPatchOf,
+ validateConversation,
+ validateSlackDraft,
+ type ConversationAction,
+ type SlackDraftAction,
+} from './slack-form'
-const stored: SlackSettings = { announceChannel: null, announcePosts: false, dmRecipientOnPost: true, giveFromSlack: false, locale: 'ja' }
+const stored: SlackSettings = {
+ announceChannel: null,
+ announcePosts: false,
+ dmRecipientOnPost: true,
+ giveFromSlack: false,
+ locale: 'ja',
+ giveInConversation: false,
+ mentionPointChoices: [10, 30, 50],
+ reactionRules: [],
+}
const general = { id: 'C0GENERAL', name: 'general' }
const kudos = { id: 'C0KUDOS', name: 'kudos' }
@@ -45,3 +69,103 @@ describe('Slack settings form', () => {
expect(slackPatchOf(apply(saved, { type: 'channel', channel: { ...general } }), saved)).toEqual({})
})
})
+
+describe('give in conversation form', () => {
+ const program = { signingSecret: true, maxPointsPerPost: 120, valueKeys: ['thanks', 'teamwork'] }
+ const withRules: SlackSettings = {
+ ...stored,
+ reactionRules: [
+ { emoji: 'pb-10', points: 10, valueKey: null },
+ { emoji: 'pb-30', points: 30, valueKey: 'thanks' },
+ ],
+ }
+ const apply = (settings: SlackSettings, ...actions: ConversationAction[]) => actions.reduce(conversationReducer, conversationDraftOf(settings))
+
+ test('the stored settings are clean; the cards key on their own fields only', () => {
+ const draft = conversationDraftOf(withRules)
+ expect(draft.choices.map((row) => row.points)).toEqual(['10', '30', '50'])
+ expect(draft.rules.map(({ emoji, points, valueKey }) => [emoji, points, valueKey])).toEqual([
+ ['pb-10', '10', ''],
+ ['pb-30', '30', 'thanks'],
+ ])
+ expect(validateConversation(draft, program)).toEqual({})
+ expect(conversationPatchOf(draft, withRules)).toEqual({})
+ expect(deliveryKey(withRules)).toBe(deliveryKey(stored))
+ expect(conversationKey(withRules)).not.toBe(conversationKey(stored))
+ expect(conversationKey({ ...stored, locale: 'en' })).toBe(conversationKey(stored))
+ })
+
+ test('adding, editing and removing rules sends the whole list, emoji normalized and no value as null', () => {
+ const rowId = newRowId('rule')
+ const added = apply(withRules, { type: 'addRule', rowId }, { type: 'setRule', rowId, change: { emoji: ':Tada::skin-tone-3:', points: '50', valueKey: 'teamwork' } })
+ expect(conversationPatchOf(added, withRules)).toEqual({
+ reactionRules: [
+ { emoji: 'pb-10', points: 10, valueKey: null },
+ { emoji: 'pb-30', points: 30, valueKey: 'thanks' },
+ { emoji: 'tada', points: 50, valueKey: 'teamwork' },
+ ],
+ })
+ const first = added.rules[0]!.rowId
+ const edited = conversationReducer(conversationReducer(added, { type: 'setRule', rowId: first, change: { points: '20' } }), { type: 'removeRule', rowId: added.rules[1]!.rowId })
+ expect(conversationPatchOf(edited, withRules).reactionRules).toEqual([
+ { emoji: 'pb-10', points: 20, valueKey: null },
+ { emoji: 'tada', points: 50, valueKey: 'teamwork' },
+ ])
+ // Typing ":pb-10:" for a stored "pb-10" is no change; removing every rule sends an empty list.
+ const same = conversationDraftOf(withRules)
+ expect(conversationPatchOf(conversationReducer(same, { type: 'setRule', rowId: same.rules[0]!.rowId, change: { emoji: ':pb-10:' } }), withRules)).toEqual({})
+ const cleared = same.rules.reduce((current, row) => conversationReducer(current, { type: 'removeRule', rowId: row.rowId }), same)
+ expect(conversationPatchOf(cleared, withRules)).toEqual({ reactionRules: [] })
+ expect(conversationReducer(cleared, { type: 'reset', settings: withRules }).rules.map((row) => row.emoji)).toEqual(['pb-10', 'pb-30'])
+ })
+
+ test('point choices: 1–5, the last one stays, the list is sent whole in order', () => {
+ const draft = conversationDraftOf(stored)
+ const removed = draft.choices.reduce((current, row) => conversationReducer(current, { type: 'removeChoice', rowId: row.rowId }), draft)
+ expect(removed.choices.map((row) => row.points)).toEqual(['50'])
+ const full = [1, 2, 3, 4].reduce((current) => conversationReducer(current, { type: 'addChoice', rowId: newRowId('choice') }), draft)
+ expect(full.choices).toHaveLength(5)
+ const rowId = newRowId('choice')
+ const grown = conversationReducer(draft, { type: 'addChoice', rowId })
+ const typed = conversationReducer(grown, { type: 'setChoice', rowId, points: '5' })
+ expect(conversationPatchOf(typed, stored)).toEqual({ mentionPointChoices: [10, 30, 50, 5] })
+ expect(conversationPatchOf(removed, stored)).toEqual({ mentionPointChoices: [50] })
+ })
+
+ test('problems: amounts out of range or repeated, emoji missing / malformed / repeated, points over the cap, a removed value', () => {
+ const draft = conversationDraftOf(withRules)
+ const [ten, , fifty] = draft.choices.map((row) => row.rowId)
+ const [pb10, pb30] = draft.rules.map((row) => row.rowId)
+ const broken = [
+ { type: 'setChoice', rowId: ten!, points: '0' },
+ { type: 'setChoice', rowId: fifty!, points: '30' },
+ { type: 'setRule', rowId: pb10!, change: { emoji: ':PB-30:', points: '121' } },
+ { type: 'setRule', rowId: pb30!, change: { valueKey: 'gone' } },
+ ] satisfies ConversationAction[]
+ const problems = validateConversation(broken.reduce(conversationReducer, draft), program)
+ expect(problems).toEqual({
+ choices: { [ten!]: 'range', [fifty!]: 'duplicate' },
+ rules: { [pb10!]: { points: 'range' }, [pb30!]: { emoji: 'duplicate', valueKey: 'unknown' } },
+ })
+ const rowId = newRowId('rule')
+ const blank = conversationReducer(draft, { type: 'addRule', rowId })
+ expect(validateConversation(blank, program).rules?.[rowId]).toEqual({ emoji: 'required', points: 'range' })
+ const spaced = conversationReducer(blank, { type: 'setRule', rowId, change: { emoji: 'party parrot', points: '1.5' } })
+ expect(validateConversation(spaced, program).rules?.[rowId]).toEqual({ emoji: 'invalid', points: 'range' })
+ })
+
+ test('on without the signing secret is a problem; turning it off never is', () => {
+ const on = conversationReducer(conversationDraftOf(stored), { type: 'toggle', value: true })
+ expect(validateConversation(on, { ...program, signingSecret: false })).toEqual({ giveInConversation: 'signingSecretMissing' })
+ expect(validateConversation(on, program)).toEqual({})
+ expect(conversationPatchOf(on, stored)).toEqual({ giveInConversation: true })
+ const off = conversationReducer(conversationDraftOf({ ...stored, giveInConversation: true }), { type: 'toggle', value: false })
+ expect(validateConversation(off, { ...program, signingSecret: false })).toEqual({})
+ })
+
+ test('emoji names: colons and skin tones go; everyday emoji are flagged', () => {
+ expect(['pb-10', ':pb-10:', ' :PB-10: ', '+1::skin-tone-3', ':+1::skin-tone-3:'].map(normalizeSlackEmoji)).toEqual(['pb-10', 'pb-10', 'pb-10', '+1', '+1'])
+ expect(['+1', ':thumbsup:', 'heart', 'pray::skin-tone-2', 'tada'].every(isEverydayEmoji)).toBe(true)
+ expect(['pb-10', 'kansha', 'constructor', ''].some(isEverydayEmoji)).toBe(false)
+ })
+})
diff --git a/web/src/features/admin/slack/slack-form.ts b/web/src/features/admin/slack/slack-form.ts
index dfd2ac7..2af3961 100644
--- a/web/src/features/admin/slack/slack-form.ts
+++ b/web/src/features/admin/slack/slack-form.ts
@@ -1,7 +1,8 @@
-// The Slack settings form: a draft of the server's settings, the reducer the
-// controls dispatch to, the checks the server would refuse (design §5 PATCH),
-// and the patch of only what changed.
-import type { SlackChannelRef, SlackLocale, SlackSettings, SlackSettingsPatch } from '../../../api/peerbonus'
+// The Slack settings forms: drafts of the server's settings, the reducers the
+// controls dispatch to, the checks the server would refuse (design §5 PATCH,
+// reaction-give §5), and the patch of only what changed. Two cards edit the
+// settings: 配信設定 (delivery) and 会話の中で贈る (giving in a conversation).
+import type { SlackChannelRef, SlackLocale, SlackReactionRule, SlackSettings, SlackSettingsPatch } from '../../../api/peerbonus'
export type SlackDraft = SlackSettings
@@ -49,3 +50,160 @@ export function slackPatchOf(draft: SlackDraft, settings: SlackSettings): SlackS
if (draft.locale !== settings.locale) patch.locale = draft.locale
return patch
}
+
+/** What the delivery card edits, as a stable string: its form restarts when a save changed it. */
+export const deliveryKey = (settings: SlackSettings) =>
+ JSON.stringify([settings.announceChannel?.id ?? null, settings.announcePosts, settings.dmRecipientOnPost, settings.giveFromSlack, settings.locale])
+
+// ---- 会話の中で贈る (mentions and reaction emoji) ----
+
+/** domain.SlackMaxPointChoices / SlackMaxReactionRules. */
+export const MAX_POINT_CHOICES = 5
+export const MAX_REACTION_RULES = 8
+const MAX_EMOJI_LENGTH = 100
+const WHOLE = /^\d+$/
+
+/** Numbers stay text while typing; `rowId` keeps React keys and problems stable. `valueKey: ''` is no value. */
+export type PointChoiceDraft = { rowId: string; points: string }
+export type ReactionRuleDraft = { rowId: string; emoji: string; points: string; valueKey: string }
+export type ConversationDraft = { giveInConversation: boolean; choices: PointChoiceDraft[]; rules: ReactionRuleDraft[] }
+
+/** Add actions carry the new row's id (`newRowId`), so the caller can focus it and the reducer stays pure. */
+export type ConversationAction =
+ | { type: 'toggle'; value: boolean }
+ | { type: 'addChoice'; rowId: string }
+ | { type: 'setChoice'; rowId: string; points: string }
+ | { type: 'removeChoice'; rowId: string }
+ | { type: 'addRule'; rowId: string }
+ | { type: 'setRule'; rowId: string; change: Partial> }
+ | { type: 'removeRule'; rowId: string }
+ | { type: 'reset'; settings: SlackSettings }
+
+let rowSeq = 0
+/** A fresh local row id (never sent to the server). */
+export const newRowId = (prefix: 'choice' | 'rule') => `${prefix}-${++rowSeq}`
+
+export function conversationDraftOf(settings: SlackSettings): ConversationDraft {
+ return {
+ giveInConversation: settings.giveInConversation,
+ choices: settings.mentionPointChoices.map((points) => ({ rowId: newRowId('choice'), points: String(points) })),
+ rules: settings.reactionRules.map((rule) => ({ rowId: newRowId('rule'), emoji: rule.emoji, points: String(rule.points), valueKey: rule.valueKey ?? '' })),
+ }
+}
+
+/** What the conversation card edits, as a stable string (see deliveryKey). */
+export const conversationKey = (settings: SlackSettings) => JSON.stringify([settings.giveInConversation, settings.mentionPointChoices, settings.reactionRules])
+
+/** Adding stops at the limits (1–5 choices, at most 8 rules); the last choice cannot go. */
+export function conversationReducer(draft: ConversationDraft, action: ConversationAction): ConversationDraft {
+ switch (action.type) {
+ case 'toggle':
+ return { ...draft, giveInConversation: action.value }
+ case 'addChoice':
+ return draft.choices.length >= MAX_POINT_CHOICES ? draft : { ...draft, choices: [...draft.choices, { rowId: action.rowId, points: '' }] }
+ case 'setChoice':
+ return { ...draft, choices: draft.choices.map((row) => (row.rowId === action.rowId ? { ...row, points: action.points } : row)) }
+ case 'removeChoice':
+ return draft.choices.length <= 1 ? draft : { ...draft, choices: draft.choices.filter((row) => row.rowId !== action.rowId) }
+ case 'addRule':
+ return draft.rules.length >= MAX_REACTION_RULES ? draft : { ...draft, rules: [...draft.rules, { rowId: action.rowId, emoji: '', points: '', valueKey: '' }] }
+ case 'setRule':
+ return { ...draft, rules: draft.rules.map((row) => (row.rowId === action.rowId ? { ...row, ...action.change } : row)) }
+ case 'removeRule':
+ return { ...draft, rules: draft.rules.filter((row) => row.rowId !== action.rowId) }
+ case 'reset':
+ return conversationDraftOf(action.settings)
+ }
+}
+
+/** As domain.NormalizeSlackEmoji: no colons, no skin tone (":+1::skin-tone-3:" → "+1"), lower case. */
+export function normalizeSlackEmoji(name: string): string {
+ let bare = name.trim().toLowerCase()
+ const tone = bare.indexOf('::')
+ if (tone >= 0) bare = bare.slice(0, tone)
+ return bare.replace(/^:+|:+$/g, '')
+}
+
+/** Emoji people put on messages every day: a rule for one would give points by accident. */
+const EVERYDAY_EMOJI: Record = {
+ '+1': true,
+ thumbsup: true,
+ '-1': true,
+ thumbsdown: true,
+ heart: true,
+ pray: true,
+ bow: true,
+ ok_hand: true,
+ ok: true,
+ eyes: true,
+ white_check_mark: true,
+ heavy_check_mark: true,
+ clap: true,
+ tada: true,
+ raised_hands: true,
+ joy: true,
+ smile: true,
+ laughing: true,
+ '100': true,
+ fire: true,
+ muscle: true,
+ sparkles: true,
+ sob: true,
+}
+
+export const isEverydayEmoji = (emoji: string) => EVERYDAY_EMOJI[normalizeSlackEmoji(emoji)] === true
+
+export type RuleProblems = { emoji?: 'required' | 'invalid' | 'duplicate'; points?: 'range'; valueKey?: 'unknown' }
+/**
+ * Per `rowId`. `giveInConversation`: on without the signing secret, which the server refuses (409). The
+ * missing inbound URL only keeps the switch from being turned on: the server does not know about it.
+ */
+export type ConversationProblems = {
+ giveInConversation?: 'signingSecretMissing'
+ choices?: Record
+ rules?: Record
+}
+
+const pointsIn = (text: string, max: number) => WHOLE.test(text.trim()) && Number(text) >= 1 && Number(text) <= max
+
+/** domain.ValidateMentionPointChoices / ValidateSlackReactionRules against the Program, and the signing secret the switch needs. */
+export function validateConversation(
+ draft: ConversationDraft,
+ { signingSecret, maxPointsPerPost, valueKeys }: { signingSecret: boolean; maxPointsPerPost: number; valueKeys: readonly string[] }
+): ConversationProblems {
+ const problems: ConversationProblems = {}
+ if (draft.giveInConversation && !signingSecret) problems.giveInConversation = 'signingSecretMissing'
+ const choices: Record = {}
+ draft.choices.forEach((row, index) => {
+ if (!pointsIn(row.points, maxPointsPerPost)) choices[row.rowId] = 'range'
+ else if (draft.choices.slice(0, index).some((other) => Number(other.points) === Number(row.points))) choices[row.rowId] = 'duplicate'
+ })
+ if (Object.keys(choices).length > 0) problems.choices = choices
+ const rules: Record = {}
+ draft.rules.forEach((row, index) => {
+ const rule: RuleProblems = {}
+ const emoji = normalizeSlackEmoji(row.emoji)
+ if (emoji === '') rule.emoji = 'required'
+ else if (emoji.length > MAX_EMOJI_LENGTH || /[:\s]/.test(emoji)) rule.emoji = 'invalid'
+ else if (draft.rules.slice(0, index).some((other) => normalizeSlackEmoji(other.emoji) === emoji)) rule.emoji = 'duplicate'
+ if (!pointsIn(row.points, maxPointsPerPost)) rule.points = 'range'
+ if (row.valueKey !== '' && !valueKeys.includes(row.valueKey)) rule.valueKey = 'unknown'
+ if (Object.keys(rule).length > 0) rules[row.rowId] = rule
+ })
+ if (Object.keys(rules).length > 0) problems.rules = rules
+ return problems
+}
+
+const sameRules = (a: SlackReactionRule[], b: SlackReactionRule[]) =>
+ a.length === b.length && a.every((rule, index) => rule.emoji === b[index]!.emoji && rule.points === b[index]!.points && rule.valueKey === b[index]!.valueKey)
+
+/** The PATCH body of the conversation card; the lists are sent whole (the server replaces them). `{}` when nothing changed. */
+export function conversationPatchOf(draft: ConversationDraft, settings: SlackSettings): SlackSettingsPatch {
+ const patch: SlackSettingsPatch = {}
+ if (draft.giveInConversation !== settings.giveInConversation) patch.giveInConversation = draft.giveInConversation
+ const choices = draft.choices.map((row) => Number(row.points.trim()))
+ if (choices.length !== settings.mentionPointChoices.length || choices.some((points, index) => points !== settings.mentionPointChoices[index])) patch.mentionPointChoices = choices
+ const rules = draft.rules.map((row) => ({ emoji: normalizeSlackEmoji(row.emoji), points: Number(row.points.trim()), valueKey: row.valueKey === '' ? null : row.valueKey }))
+ if (!sameRules(rules, settings.reactionRules)) patch.reactionRules = rules
+ return patch
+}
diff --git a/web/src/features/admin/slack/slack-page.tsx b/web/src/features/admin/slack/slack-page.tsx
index bcd8929..271beb9 100644
--- a/web/src/features/admin/slack/slack-page.tsx
+++ b/web/src/features/admin/slack/slack-page.tsx
@@ -7,12 +7,14 @@ import type { MessageId } from '../../../copy'
import { useText } from '../../../i18n'
import { Button, buttonClasses, CLOCK_TICK_MS, cn, ConfirmDialog, formatDateTime, Notice, PageHeader, useDocumentTitle, useNow } from '../../../ui'
import { formatCount } from '../format'
-import { slackQuery, SLACK_KEY } from '../queries'
+import { adminProgramQuery, slackQuery, SLACK_KEY } from '../queries'
+import { ConversationSettingsCard } from './conversation-settings'
import { DeliveriesCard } from './deliveries'
import { generateManifest, manifestHref } from './manifest'
import { Card, CopyField, ToneChip } from './parts'
import { SlackActionError } from './slack-error'
import { SlackSettingsCard } from './slack-settings'
+import { conversationKey, deliveryKey } from './slack-form'
import { SLACK_ERROR_LABELS, setupSteps, STATE_VIEWS, type SetupStepId } from './slack-state'
const SLACK_APPS_URL = 'https://api.slack.com/apps'
@@ -20,17 +22,20 @@ const MANIFEST_FILE = 'peerbonus-slack-manifest.json'
/**
* `/admin/slack`: one card per concern — the connection (state, workspace, verify), the setup guide
- * (folded once done), delivery settings, the Slack inbound endpoint (only once the platform projected
- * it, Phase B) and the delivery log.
+ * (folded once done), delivery settings, giving in a conversation (mentions and reaction emoji), the
+ * Slack inbound endpoint (only once the platform projected it, Phase B) and the delivery log.
*/
export function SlackPage() {
const { t } = useText()
const { data: slack } = useSuspenseQuery(slackQuery)
const { data: config } = useSuspenseQuery(configQuery)
+ const { data: program } = useSuspenseQuery(adminProgramQuery)
const now = useNow(CLOCK_TICK_MS)
- // Which stored settings a save returned: the remounted form shows its saved notice for them.
- const [savedSettings, setSavedSettings] = useState(null)
- const settingsKey = JSON.stringify(slack.settings)
+ // Which card's stored settings a save returned: that card remounts (its key changed) and shows its saved notice.
+ // Each settings card is keyed by its own fields, so saving one keeps the other's unsaved edits.
+ const [savedKey, setSavedKey] = useState(null)
+ const delivery = `delivery:${deliveryKey(slack.settings)}`
+ const conversation = `conversation:${conversationKey(slack.settings)}`
useDocumentTitle(t('peerbonus.slack.title'))
return (
@@ -39,7 +44,14 @@ export function SlackPage() {
-
+ setSavedKey(`delivery:${deliveryKey(settings)}`)} />
+ setSavedKey(`conversation:${conversationKey(settings)}`)}
+ />
{slack.inbound ? : null}
diff --git a/web/src/features/admin/slack/slack-settings.tsx b/web/src/features/admin/slack/slack-settings.tsx
index ad831d8..96df33f 100644
--- a/web/src/features/admin/slack/slack-settings.tsx
+++ b/web/src/features/admin/slack/slack-settings.tsx
@@ -2,7 +2,7 @@ import { useMutation, useQueryClient } from '@tanstack/react-query'
import { useBlocker } from '@tanstack/react-router'
import { Lock, Save, Send } from 'lucide-react'
import { useId, useReducer, useState, type FormEvent } from 'react'
-import { peerbonusApi, type SlackAdmin, type SlackLocale } from '../../../api/peerbonus'
+import { peerbonusApi, type SlackAdmin, type SlackLocale, type SlackSettings } from '../../../api/peerbonus'
import { LANGUAGES, useText } from '../../../i18n'
import { Button, cn, controlClasses, Notice } from '../../../ui'
import { slackQuery, SLACK_KEY } from '../queries'
@@ -16,7 +16,7 @@ import { slackDraftReducer, slackPatchOf, validateSlackDraft } from './slack-for
* the test message (to the saved channel). Locked until the workspace is connected. A save replaces
* the settings; the form restarts from what the server stored (`key` by the caller).
*/
-export function SlackSettingsCard({ slack, justSaved, onSaved }: { slack: SlackAdmin; justSaved: boolean; onSaved: (settingsKey: string) => void }) {
+export function SlackSettingsCard({ slack, justSaved, onSaved }: { slack: SlackAdmin; justSaved: boolean; onSaved: (settings: SlackSettings) => void }) {
const { t } = useText()
const client = useQueryClient()
const id = useId()
@@ -32,7 +32,7 @@ export function SlackSettingsCard({ slack, justSaved, onSaved }: { slack: SlackA
const save = useMutation({
mutationFn: () => peerbonusApi.admin.slack.update(patch),
onSuccess: async (result) => {
- onSaved(JSON.stringify(result.settings))
+ onSaved(result.settings)
client.setQueryData(slackQuery.queryKey, result)
await client.invalidateQueries({ queryKey: SLACK_KEY })
},
diff --git a/web/src/features/admin/slack/slack-state.test.ts b/web/src/features/admin/slack/slack-state.test.ts
index 7b668aa..85e3260 100644
--- a/web/src/features/admin/slack/slack-state.test.ts
+++ b/web/src/features/admin/slack/slack-state.test.ts
@@ -2,7 +2,7 @@ import { createDashboardTranslator } from '@appthrust/platform-dashboard-i18n'
import { describe, expect, test } from 'bun:test'
import type { SlackAdmin, SlackDeliveryKind, SlackState } from '../../../api/peerbonus'
import { catalogs } from '../../../copy'
-import { DELIVERY_KIND_LABELS, DELIVERY_STATE_VIEWS, DELIVERY_STATES, SLACK_ERROR_LABELS, setupSteps, STATE_VIEWS } from './slack-state'
+import { conversationBlocker, DELIVERY_KIND_LABELS, DELIVERY_STATE_VIEWS, DELIVERY_STATES, SLACK_ERROR_LABELS, setupSteps, STATE_VIEWS } from './slack-state'
const ja = createDashboardTranslator('ja', catalogs)
const en = createDashboardTranslator('en', catalogs)
@@ -10,7 +10,16 @@ const en = createDashboardTranslator('en', catalogs)
const base: Pick = {
credential: { botToken: false, signingSecret: false },
state: 'unconfigured',
- settings: { announceChannel: null, announcePosts: false, dmRecipientOnPost: true, giveFromSlack: false, locale: 'ja' },
+ settings: {
+ announceChannel: null,
+ announcePosts: false,
+ dmRecipientOnPost: true,
+ giveFromSlack: false,
+ locale: 'ja',
+ giveInConversation: false,
+ mentionPointChoices: [10, 30, 50],
+ reactionRules: [],
+ },
inbound: null,
}
@@ -65,3 +74,27 @@ describe('setup guide progress', () => {
expect(done({ ...phaseB, settings: { ...base.settings, giveFromSlack: true } }).at(-1)).toBe('signingSecret:done')
})
})
+
+describe('giving in a conversation: what keeps the switch off', () => {
+ const inbound = { url: 'https://in.example/x', ready: true, reason: null }
+
+ test('the signing secret first, then the inbound URL; nothing once both are there', () => {
+ const blocker = (slack: Parameters[0]) => {
+ const id = conversationBlocker(slack)
+ return id && ja.t(id)
+ }
+ expect(blocker({ credential: { botToken: true, signingSecret: false }, inbound })).toBe('Dashboard の Credentials に Slack signing secret が必要です。')
+ expect(blocker({ credential: { botToken: true, signingSecret: true }, inbound: null })).toBe('Slack からのリクエスト URL がまだないため、使えません。')
+ // A projected endpoint without a URL yet (or the platform unreachable) is no URL either.
+ expect(blocker({ credential: { botToken: true, signingSecret: true }, inbound: { url: null, ready: false, reason: 'platform_unavailable' } })).toBe(
+ 'Slack からのリクエスト URL がまだないため、使えません。'
+ )
+ expect(blocker({ credential: { botToken: true, signingSecret: true }, inbound })).toBeNull()
+ })
+
+ test('the usage help shows the mention format in both languages', () => {
+ expect(ja.t('peerbonus.slack.conversation.helpExample')).toBe('@Peer Bonus @相手 30 メッセージ')
+ expect(en.t('peerbonus.slack.conversation.helpExample')).toBe('@Peer Bonus @person 30 message')
+ expect(ja.t('peerbonus.slack.conversation.helpInvite')).toContain('/invite @Peer Bonus')
+ })
+})
diff --git a/web/src/features/admin/slack/slack-state.ts b/web/src/features/admin/slack/slack-state.ts
index 3724ab4..b741e17 100644
--- a/web/src/features/admin/slack/slack-state.ts
+++ b/web/src/features/admin/slack/slack-state.ts
@@ -41,6 +41,17 @@ export function setupSteps(slack: Pick): MessageId | null {
+ if (!slack.credential.signingSecret) return 'peerbonus.slack.giveFromSlackLocked'
+ if (!slack.inbound?.url) return 'peerbonus.slack.conversation.noInbound'
+ return null
+}
+
export const DELIVERY_STATES: readonly SlackDeliveryState[] = ['pending', 'sent', 'skipped', 'failed']
export const DELIVERY_STATE_VIEWS: Record = {
diff --git a/web/src/features/posts/post-card.test.tsx b/web/src/features/posts/post-card.test.tsx
index 692cfd1..1f0aec7 100644
--- a/web/src/features/posts/post-card.test.tsx
+++ b/web/src/features/posts/post-card.test.tsx
@@ -85,4 +85,15 @@ describe('post card', () => {
expect(detail).not.toContain(`href="/posts/${post.id}"`)
expect(detail).toContain('text-lg')
})
+
+ test('a post given in Slack links its original message in a new tab; a web post has no such link', async () => {
+ const me = await mockMe()
+ const post = (await mockPosts())[0]!
+ const permalink = 'https://acme.slack.com/archives/C0KUDOS/p1760929200000100'
+ const html = render(, me)
+ expect(html).toContain(`, me, 'en'))).toContain('Original Slack message')
+ expect(render(, me)).not.toContain('Slack の元メッセージ')
+ })
})
diff --git a/web/src/features/posts/post-card.tsx b/web/src/features/posts/post-card.tsx
index d8584f4..c09d51b 100644
--- a/web/src/features/posts/post-card.tsx
+++ b/web/src/features/posts/post-card.tsx
@@ -1,4 +1,4 @@
-import { Gift } from 'lucide-react'
+import { ExternalLink, Gift } from 'lucide-react'
import type { ReactNode } from 'react'
import type { Post } from '../../api/peerbonus'
import { useText } from '../../i18n'
@@ -29,7 +29,8 @@ function Sentence({ sentence, children }: { sentence: string; children: ReactNod
* recipient is the headline — "山田 太郎 さんへ" with a big "+30 pt" — then
* the message, its values, and a footer: the clap button with who clapped,
* 「同じ人に贈る」, and "from 鈴木 一郎 · 3 時間前" (the time links to the post
- * page). `detail` is the post page: larger text and the full timestamp.
+ * page), then a link to the Slack message a post given in Slack came from.
+ * `detail` is the post page: larger text and the full timestamp.
* `highlighted` plays a one-shot glow for a post the viewer just sent (the
* launcher scrolls it into view). Admins get an overflow menu with 投稿を削除.
* `now` anchors the relative time; a list passes one clock for all its cards.
@@ -149,6 +150,20 @@ export function PostCard({
{time}
)}
+ {post.slackPermalink ? (
+ <>
+ ·
+
+ {t('peerbonus.post.slackOriginal')}
+
+
+ >
+ ) : null}
diff --git a/web/src/routes/admin-pages.tsx b/web/src/routes/admin-pages.tsx
index fcbdff1..64c5fcb 100644
--- a/web/src/routes/admin-pages.tsx
+++ b/web/src/routes/admin-pages.tsx
@@ -142,6 +142,8 @@ export const adminSlackRoute = createRoute({
context.queryClient.ensureQueryData(slackQuery),
context.queryClient.ensureQueryData(configQuery),
context.queryClient.ensureQueryData(slackDeliveriesQuery(null)),
+ // The conversation card checks points and values against the Program.
+ context.queryClient.ensureQueryData(adminProgramQuery),
])
},
component: SlackPage,
From 3c4c13e9b962e44fab4c9e2f56371266c99a9e2b Mon Sep 17 00:00:00 2001
From: reoring
Date: Fri, 13 Nov 2026 19:28:37 +0900
Subject: [PATCH 3/3] fix(slack): limit conversation giving to once per message
---
.github/workflows/ci.yml | 2 +-
README.md | 7 ++
cmd/server/internal/domain/slack_give.go | 4 +-
.../internal/slackinbound/events_test.go | 64 +++++++++++++++++++
.../006_slack_conversation_give.sql | 5 +-
cmd/server/internal/store/slack_give.go | 10 +--
cmd/server/internal/store/slack_give_test.go | 22 ++++++-
7 files changed, 101 insertions(+), 13 deletions(-)
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index a1715e0..6de0d15 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -29,7 +29,7 @@ jobs:
timeout-minutes: 10
defaults:
run:
- working-peerbonus: web
+ working-directory: web
steps:
- uses: actions/checkout@d23441a48e516b6c34aea4fa41551a30e30af803
with:
diff --git a/README.md b/README.md
index dfb8cb6..04a9a61 100644
--- a/README.md
+++ b/README.md
@@ -12,6 +12,13 @@ Optional Slack credentials enable announcements, direct messages, the
omitted) or adding an admin-chosen reaction. Slack reaches the server through
the `slack` inbound endpoint declared in `catalog/entry.yaml` (`/slack/*`).
+A sender can give only once from the same Slack message, regardless of the emoji
+or whether the give started with a mention. A mention can still give to up to
+five recipients atomically; retries replay that entire original batch. Stored
+gives are unique by (channel, message timestamp, sender, recipient), with emoji
+retained only for reference. Removing a reaction does not refund points or allow
+another give. This replaces the per-emoji RL2 rule in `reaction-give.md`.
+
## Develop
Use Go 1.26 or newer and Bun 1.4.1. The server depends on the public
diff --git a/cmd/server/internal/domain/slack_give.go b/cmd/server/internal/domain/slack_give.go
index a225532..907bf74 100644
--- a/cmd/server/internal/domain/slack_give.go
+++ b/cmd/server/internal/domain/slack_give.go
@@ -27,8 +27,8 @@ type SlackReactionRule struct {
ValueKey *string
}
-// SlackGiveSource identifies the Slack message a give came from (RL2).
-// Emoji is empty for a mention.
+// SlackGiveSource identifies the Slack message a give came from.
+// Emoji is recorded for reference only, not deduplication; it is empty for a mention.
type SlackGiveSource struct {
ChannelID, MessageTS string
Emoji string
diff --git a/cmd/server/internal/slackinbound/events_test.go b/cmd/server/internal/slackinbound/events_test.go
index 0210210..62ccb1d 100644
--- a/cmd/server/internal/slackinbound/events_test.go
+++ b/cmd/server/internal/slackinbound/events_test.go
@@ -10,6 +10,7 @@ import (
"testing"
"time"
+ "github.com/appthrust/appserver-go/appserver/pgstore/testutil"
"github.com/appthrust/peerbonus/cmd/server/internal/domain"
"github.com/appthrust/peerbonus/cmd/server/internal/slack"
"github.com/appthrust/peerbonus/cmd/server/internal/slackinbound/slackinboundtest"
@@ -439,6 +440,69 @@ func TestConversationTransientFailureCanRetry(t *testing.T) {
}
}
+func TestConversationReactionGiveOncePerMessage(t *testing.T) {
+ db, _ := testutil.Database(t, store.Open)
+ s, client, o := conversationFixture()
+ o.Store = db
+ _, err := db.FixSlackWorkspace(t.Context(), *s.integration.Workspace, false, testNow)
+ require.NoError(t, err)
+ rules := []domain.SlackReactionRule{{Emoji: "pb-10", Points: 10}, {Emoji: "pb-30", Points: 30}}
+ channel := &domain.SlackChannel{ID: "CANNOUNCE", Name: "thanks"}
+ _, err = db.UpdateSlackSettings(t.Context(), store.SlackSettingsPatch{
+ GiveInConversation: new(true), ReactionRules: &rules,
+ AnnounceChannel: &channel, AnnouncePosts: new(true), DMRecipientOnPost: new(true),
+ }, testNow)
+ require.NoError(t, err)
+ for _, userID := range []string{"U123", "U456"} {
+ member, err := db.UpsertMember(t.Context(), store.MemberInput{PersonID: userID, DisplayName: userID}, testNow, true)
+ require.NoError(t, err)
+ require.NoError(t, db.LinkMemberSlackUser(t.Context(), member.ID, userID, testNow))
+ }
+ sender, err := db.MemberBySlackUser(t.Context(), "U123")
+ require.NoError(t, err)
+ remaining, err := db.GiveRemaining(t.Context(), sender.ID, testNow)
+ require.NoError(t, err)
+ h := New(o)
+ for _, tc := range []struct {
+ name string
+ emoji string
+ restart bool
+ }{
+ {name: "first reaction", emoji: "pb-10"},
+ {name: "same event retry", emoji: "pb-10"},
+ {name: "same event after restart", emoji: "pb-10", restart: true},
+ {name: "another configured emoji", emoji: "pb-30"},
+ {name: "second emoji after restart", emoji: "pb-30", restart: true},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ if tc.restart {
+ h = New(o)
+ }
+ event := reactionEvent()
+ event.Event.Reaction = tc.emoji
+ w := serveEvent(t, h, event)
+ require.Equal(t, http.StatusOK, w.Code)
+ posts, _, err := db.ListPosts(t.Context(), store.PostFilter{}, sender.ID)
+ require.NoError(t, err)
+ require.Len(t, posts, 1)
+ require.Equal(t, 10, posts[0].Points)
+ balance, err := db.GiveRemaining(t.Context(), sender.ID, testNow)
+ require.NoError(t, err)
+ require.Equal(t, remaining-10, balance)
+ var ledger, gives, deliveries int
+ require.NoError(t, db.Do(t.Context(), false, func(tx *store.Tx) error {
+ return tx.SQL.QueryRowContext(t.Context(), `SELECT
+ (SELECT count(*) FROM ledger), (SELECT count(*) FROM slack_gives), (SELECT count(*) FROM slack_deliveries)`).
+ Scan(&ledger, &gives, &deliveries)
+ }))
+ require.Equal(t, 2, ledger)
+ require.Equal(t, 1, gives)
+ require.Equal(t, 2, deliveries)
+ require.Len(t, client.posted, 1)
+ })
+ }
+}
+
func TestConversationReactionGiveAndAnnounceClap(t *testing.T) {
for _, name := range []string{"give", "normalized", "announce", "unrelated bot message", "clap replay", "clap domain error", "clap transient", "clap reply failure", "clap balance failure"} {
t.Run(name, func(t *testing.T) {
diff --git a/cmd/server/internal/store/migrations/006_slack_conversation_give.sql b/cmd/server/internal/store/migrations/006_slack_conversation_give.sql
index d86097e..d985987 100644
--- a/cmd/server/internal/store/migrations/006_slack_conversation_give.sql
+++ b/cmd/server/internal/store/migrations/006_slack_conversation_give.sql
@@ -10,7 +10,8 @@ CREATE TABLE slack_reaction_rules (
position smallint NOT NULL
);
--- RL2: one give per (message, sender, recipient, means). emoji = '' is a mention.
+-- One give per (message, sender, recipient), replacing reaction-give.md's per-emoji RL2.
+-- Emoji is recorded for reference only; emoji = '' is a mention.
-- The row outlives idempotency_keys, so removing and re-adding a reaction never gives twice.
CREATE TABLE slack_gives (
channel_id text NOT NULL,
@@ -22,7 +23,7 @@ CREATE TABLE slack_gives (
clap_id text REFERENCES claps(id),
permalink text,
created_at timestamptz NOT NULL,
- PRIMARY KEY (channel_id, message_ts, sender_id, recipient_id, emoji)
+ PRIMARY KEY (channel_id, message_ts, sender_id, recipient_id)
);
CREATE INDEX slack_gives_post ON slack_gives (post_id);
diff --git a/cmd/server/internal/store/slack_give.go b/cmd/server/internal/store/slack_give.go
index 50d0416..5566dee 100644
--- a/cmd/server/internal/store/slack_give.go
+++ b/cmd/server/internal/store/slack_give.go
@@ -30,8 +30,8 @@ type CreateSlackClapInput struct {
}
// CreateSlackPosts atomically gives to all recipients using the web ledger path.
-// Any existing give for the source and sender replays the entire original batch,
-// even if the requested recipients changed. Replay never consumes a pending give.
+// Any existing give for the message and sender replays the entire original batch,
+// regardless of emoji or requested recipients. Replay never consumes a pending give.
func (s *Store) CreateSlackPosts(ctx context.Context, in CreateSlackPostsInput) (posts []domain.Post, replayed bool, err error) {
err = s.Do(ctx, true, func(tx *Tx) error {
posts, err = tx.slackGivenPosts(in.Source, in.SenderID)
@@ -81,7 +81,7 @@ func (s *Store) CreateSlackPosts(ctx context.Context, in CreateSlackPostsInput)
func (tx *Tx) slackGivenPosts(source domain.SlackGiveSource, senderID string) ([]domain.Post, error) {
rows, err := tx.SQL.QueryContext(tx.Context, postSelect+`JOIN slack_gives g ON g.post_id=p.id
- WHERE g.channel_id=$2 AND g.message_ts=$3 AND g.sender_id=$1 AND g.emoji=$4 ORDER BY g.created_at,p.id`, senderID, source.ChannelID, source.MessageTS, source.Emoji)
+ WHERE g.channel_id=$2 AND g.message_ts=$3 AND g.sender_id=$1 ORDER BY g.created_at,p.id`, senderID, source.ChannelID, source.MessageTS)
if err != nil {
return nil, err
}
@@ -104,8 +104,8 @@ func (s *Store) CreateSlackClap(ctx context.Context, in CreateSlackClapInput) (c
var postID string
var clapID *string
err := tx.SQL.QueryRowContext(ctx, `SELECT post_id,clap_id FROM slack_gives
- WHERE channel_id=$1 AND message_ts=$2 AND sender_id=$3 AND emoji=$4
- AND recipient_id=(SELECT recipient_id FROM posts WHERE id=$5)`, in.Source.ChannelID, in.Source.MessageTS, in.MemberID, in.Source.Emoji, in.PostID).Scan(&postID, &clapID)
+ WHERE channel_id=$1 AND message_ts=$2 AND sender_id=$3
+ AND recipient_id=(SELECT recipient_id FROM posts WHERE id=$4)`, in.Source.ChannelID, in.Source.MessageTS, in.MemberID, in.PostID).Scan(&postID, &clapID)
if err == nil {
if clapID == nil || postID != in.PostID {
return &domain.ValidationError{Field: "source", Msg: "already used for a different action"}
diff --git a/cmd/server/internal/store/slack_give_test.go b/cmd/server/internal/store/slack_give_test.go
index 37d0949..8adba44 100644
--- a/cmd/server/internal/store/slack_give_test.go
+++ b/cmd/server/internal/store/slack_give_test.go
@@ -60,6 +60,11 @@ func TestSlackConversationPostsReplayAndPermalink(t *testing.T) {
require.NoError(t, err)
require.True(t, replayed)
require.Equal(t, posts, same, "changed recipients must never add another give")
+ in.Source.Emoji = "pb-30"
+ same, replayed, err = db.CreateSlackPosts(t.Context(), in)
+ require.NoError(t, err)
+ require.True(t, replayed)
+ require.Equal(t, posts, same, "a different emoji must replay the entire original give")
require.Equal(t, 4, count(t, db, `SELECT count(*) FROM ledger`))
require.Equal(t, 4, count(t, db, `SELECT count(*) FROM slack_deliveries`))
}
@@ -315,6 +320,15 @@ func TestSlackConversationClapAndAnnounce(t *testing.T) {
require.Equal(t, first.ID, same.ID)
require.Equal(t, 1, updated.ClapCount)
require.Equal(t, 5, count(t, db, `SELECT count(*) FROM ledger`))
+ in.Source.Emoji = "pb-30"
+ same, updated, replayed, err = db.CreateSlackClap(t.Context(), in)
+ require.NoError(t, err)
+ require.True(t, replayed)
+ require.Equal(t, first.ID, same.ID)
+ require.Equal(t, 1, updated.ClapCount)
+ require.Equal(t, 5, count(t, db, `SELECT count(*) FROM ledger`))
+ require.Equal(t, 1, count(t, db, `SELECT count(*) FROM slack_gives`))
+ require.Equal(t, 1, count(t, db, `SELECT count(*) FROM slack_deliveries WHERE kind='clap_update'`))
in.MemberID = members[0].ID
_, _, _, err = db.CreateSlackClap(t.Context(), in)
require.ErrorIs(t, err, domain.ErrOwnPost)
@@ -323,7 +337,9 @@ func TestSlackConversationClapAndAnnounce(t *testing.T) {
_, _, replayed, err = db.CreateSlackClap(t.Context(), in)
require.NoError(t, err)
require.True(t, replayed)
- in.Source.Emoji = "pb-30"
- _, _, _, err = db.CreateSlackClap(t.Context(), in)
- require.ErrorIs(t, err, domain.ErrNotFound)
+ in.Source.Emoji = "pb-10"
+ same, _, replayed, err = db.CreateSlackClap(t.Context(), in)
+ require.NoError(t, err)
+ require.True(t, replayed)
+ require.Equal(t, first.ID, same.ID)
}