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 19afca8..04a9a61 100644 --- a/README.md +++ b/README.md @@ -6,8 +6,18 @@ 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/*`). + +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 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/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/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..907bf74 --- /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. +// Emoji is recorded for reference only, not deduplication; it 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/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..62ccb1d --- /dev/null +++ b/cmd/server/internal/slackinbound/events_test.go @@ -0,0 +1,572 @@ +package slackinbound + +import ( + "context" + "encoding/json" + "errors" + "net/http" + "net/http/httptest" + "strings" + "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" + "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 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) { + 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/migrations/006_slack_conversation_give.sql b/cmd/server/internal/store/migrations/006_slack_conversation_give.sql new file mode 100644 index 0000000..d985987 --- /dev/null +++ b/cmd/server/internal/store/migrations/006_slack_conversation_give.sql @@ -0,0 +1,41 @@ +-- 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 +); + +-- 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, + 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) +); +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) +); 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..5566dee --- /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 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) + 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 ORDER BY g.created_at,p.id`, senderID, source.ChannelID, source.MessageTS) + 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 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"} + } + 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..8adba44 --- /dev/null +++ b/cmd/server/internal/store/slack_give_test.go @@ -0,0 +1,345 @@ +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") + 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`)) +} + +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.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) + 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-10" + same, _, replayed, err = db.CreateSlackClap(t.Context(), in) + require.NoError(t, err) + require.True(t, replayed) + require.Equal(t, first.ID, same.ID) +} 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 ( + +
+ {locked ? ( +

+ + {t('peerbonus.slack.settings.locked')} +

+ ) : null} +
+
+ {t(blocker)} : t('peerbonus.slack.conversation.toggleHint')} + checked={draft.giveInConversation} + // Turning it off stays possible after the secret or the endpoint went away. + disabled={locked || (blocker !== null && !draft.giveInConversation)} + onChange={(value) => edit({ type: 'toggle', value })} + /> +
+ +
+

+ {t('peerbonus.slack.conversation.choices')} +

+
    + {draft.choices.map((row, index) => { + const invalid = problems.choices?.[row.rowId] !== undefined && shown(`${row.rowId}-points`) + return ( +
  • + edit({ type: 'setChoice', rowId: row.rowId, points: event.target.value })} + onBlur={() => touch(`${row.rowId}-points`)} + /> + } + label={t('peerbonus.slack.conversation.removeChoice', { index: index + 1 })} + tone="secondary" + disabled={draft.choices.length <= 1} + className="-ml-px h-10 rounded-l-none md:h-9" + onClick={() => { + edit({ type: 'removeChoice', rowId: row.rowId }) + const neighbour = draft.choices[index + 1] ?? draft.choices[index - 1] + focusNext.current = neighbour ? `${neighbour.rowId}-points` : `${id}-add-choice` + }} + /> +
  • + ) + })} +
  • + +
  • +
+ {choiceError ? ( +

+ {choiceError} +

+ ) : ( +

+ {t('peerbonus.slack.conversation.choicesHint', { limit: MAX_POINT_CHOICES, max })} +

+ )} +
+ +
+

+ {t('peerbonus.slack.conversation.rules')} +

+

{t('peerbonus.slack.conversation.rulesHint')}

+ {draft.rules.length === 0 ? ( +

{t('peerbonus.slack.conversation.rulesEmpty')}

+ ) : ( +
    + {draft.rules.map((row, index) => { + const base = `${id}-${row.rowId}` + const position = index + 1 + const rule = problems.rules?.[row.rowId] ?? {} + const emojiProblem = shown(`${row.rowId}-emoji`) ? rule.emoji : undefined + const pointsProblem = shown(`${row.rowId}-points`) ? rule.points : undefined + const everyday = !rule.emoji && isEverydayEmoji(row.emoji) + const staleValue = row.valueKey !== '' && !program.values.some((value) => value.key === row.valueKey) + return ( +
  1. +
    + + + {t('peerbonus.slack.conversation.everyday', { emoji: normalizeSlackEmoji(row.emoji) })} + + ) : undefined + } + > +
    + + : + + edit({ type: 'setRule', rowId: row.rowId, change: { emoji: event.target.value } })} + onBlur={() => { + touch(`${row.rowId}-emoji`) + const normalized = normalizeSlackEmoji(row.emoji) + if (normalized !== row.emoji) edit({ type: 'setRule', rowId: row.rowId, change: { emoji: normalized } }) + }} + /> + + : + +
    +
    + + edit({ type: 'setRule', rowId: row.rowId, change: { points: event.target.value } })} + onBlur={() => touch(`${row.rowId}-points`)} + /> + + + + +
    + } + label={t('peerbonus.slack.conversation.removeRule', { index: position })} + className="mt-6.5 text-bad-ink hover:bg-bad-soft hover:text-bad-ink md:mt-7" + onClick={() => { + edit({ type: 'removeRule', rowId: row.rowId }) + const neighbour = draft.rules[index + 1] ?? draft.rules[index - 1] + focusNext.current = neighbour ? `${neighbour.rowId}-emoji` : `${id}-add-rule` + }} + /> +
  2. + ) + })} +
+ )} +
+ + + {t('peerbonus.slack.conversation.rulesCount', { count: draft.rules.length, max: MAX_REACTION_RULES })} + +
+
+
+ +
+

{t('peerbonus.slack.conversation.help')}

+
    +
  • + {t('peerbonus.slack.conversation.helpMention')}{' '} + + {t('peerbonus.slack.conversation.helpExample')} + +
  • +
  • {t('peerbonus.slack.conversation.helpAsk')}
  • +
  • {t('peerbonus.slack.conversation.helpInvite')}
  • +
  • {t('peerbonus.slack.conversation.helpReinstall')}
  • +
+
+ +
+ {save.isError ? : null} + {saved && !dirty ? ( + + {t('peerbonus.admin.program.saved')} + + ) : null} +
+ + {dirty ? t('peerbonus.admin.program.unsaved') : null} + +
+ + +
+
+
+
+
+ ) +} 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,