Added support for opening the pulse modal via a slash command.

Author: ocielliottc

.github/workflows/gradle-build-production.yml

@@ -88,6 +88,7 @@ jobs:
             --set-env-vars "SLACK_WEBHOOK_URL=${{ secrets.SLACK_WEBHOOK_URL }}" \
             --set-env-vars "SLACK_BOT_TOKEN=${{ secrets.SLACK_BOT_TOKEN }}" \
             --set-env-vars "SLACK_PULSE_SIGNING_SECRET=${{ secrets.SLACK_PULSE_SIGNING_SECRET }}" \
+            --set-env-vars "SLACK_PULSE_BOT_TOKEN=${{ secrets.SLACK_PULSE_BOT_TOKEN }}" \
             --platform "managed" \
             --max-instances 8 \
             --allow-unauthenticated

server/src/main/java/com/objectcomputing/checkins/configuration/CheckInsConfiguration.java

@@ -109,7 +109,7 @@ public static class SlackConfig {
                 private String signingSecret;
 
                 @NotBlank
-                private String webhookUrl;
+                private String botToken;
             }
         }
     }

server/src/main/java/com/objectcomputing/checkins/services/pulse/PulseServicesImpl.java

@@ -47,9 +47,6 @@ private class Frequency {
   @Inject
   private PulseEmail email;
 
-  @Inject
-  private PulseSlackPoster slackPoster;
-
   private final DayOfWeek emailDay = DayOfWeek.MONDAY;
 
   private String setting = "bi-weekly";
@@ -106,7 +103,6 @@ public void notifyUsers(LocalDate check) {
           if (sent.isEmpty()) {
             LOG.info("Sending Pulse Email");
             email.send();
-            slackPoster.send();
             automatedEmailRepository.save(new AutomatedEmail(key));
           } else {
             LOG.info("The Pulse Email has already been sent today");

server/src/main/java/com/objectcomputing/checkins/services/pulse/PulseSlackPoster.java

@@ -1,8 +1,10 @@
 package com.objectcomputing.checkins.services.pulseresponse;
 
 import com.objectcomputing.checkins.exceptions.NotFoundException;
+import com.objectcomputing.checkins.util.form.FormUrlEncodedDecoder;
 import com.objectcomputing.checkins.services.memberprofile.MemberProfileServices;
 
+import io.micronaut.http.MediaType;
 import io.micronaut.core.annotation.Nullable;
 import io.micronaut.core.convert.format.Format;
 import io.micronaut.http.HttpStatus;
@@ -27,6 +29,8 @@
 import java.time.LocalDate;
 import java.util.Set;
 import java.util.UUID;
+import java.util.Map;
+import java.nio.charset.StandardCharsets;
 
 @Controller("/services/pulse-responses")
 @ExecuteOn(TaskExecutors.BLOCKING)
@@ -36,13 +40,16 @@ public class PulseResponseController {
     private final PulseResponseService pulseResponseServices;
     private final MemberProfileServices memberProfileServices;
     private final SlackSignatureVerifier slackSignatureVerifier;
+    private final PulseSlackCommand pulseSlackCommand;
 
     public PulseResponseController(PulseResponseService pulseResponseServices,
                                    MemberProfileServices memberProfileServices,
-                                   SlackSignatureVerifier slackSignatureVerifier) {
+                                   SlackSignatureVerifier slackSignatureVerifier,
+                                   PulseSlackCommand pulseSlackCommand) {
         this.pulseResponseServices = pulseResponseServices;
         this.memberProfileServices = memberProfileServices;
         this.slackSignatureVerifier = slackSignatureVerifier;
+        this.pulseSlackCommand = pulseSlackCommand;
     }
 
     /**
@@ -105,6 +112,33 @@ public PulseResponse readRole(@NotNull UUID id) {
         return result;
     }
 
+    @Secured(SecurityRule.IS_ANONYMOUS)
+    @Post(uri = "/command", consumes = MediaType.APPLICATION_FORM_URLENCODED)
+    public HttpResponse commandPulseResponse(
+               @Header("X-Slack-Signature") String signature,
+               @Header("X-Slack-Request-Timestamp") String timestamp,
+               @Body String requestBody) {
+        // Validate the request
+        if (slackSignatureVerifier.verifyRequest(signature,
+                                                 timestamp, requestBody)) {
+            // Convert the request body to a map of values.
+            FormUrlEncodedDecoder formUrlEncodedDecoder = new FormUrlEncodedDecoder();
+            Map<String, Object> body =
+                formUrlEncodedDecoder.decode(requestBody,
+                                             StandardCharsets.UTF_8);
+
+            // Respond to the slack command.
+            String triggerId = (String)body.get("trigger_id");
+            if (pulseSlackCommand.send(triggerId)) {
+                return HttpResponse.ok();
+            } else {
+                return HttpResponse.status(HttpStatus.INTERNAL_SERVER_ERROR);
+            }
+        } else {
+            return HttpResponse.unauthorized();
+        }
+    }
+
     @Secured(SecurityRule.IS_ANONYMOUS)
     @Post("/external")
     public HttpResponse<PulseResponse> externalPulseResponse(

server/src/main/java/com/objectcomputing/checkins/services/pulseresponse/PulseResponseController.java

@@ -0,0 +1,77 @@
+package com.objectcomputing.checkins.services.pulseresponse;
+
+import com.objectcomputing.checkins.configuration.CheckInsConfiguration;
+
+import com.slack.api.Slack;
+import com.slack.api.methods.MethodsClient;
+import com.slack.api.methods.request.views.ViewsOpenRequest;
+import com.slack.api.methods.response.views.ViewsOpenResponse;
+
+import io.micronaut.context.annotation.Value;
+import io.micronaut.core.io.Readable;
+import io.micronaut.core.io.IOUtils;
+
+import jakarta.inject.Singleton;
+import jakarta.inject.Inject;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.BufferedReader;
+import java.util.List;
+
+@Singleton
+public class PulseSlackCommand {
+    private static final Logger LOG = LoggerFactory.getLogger(PulseSlackCommand.class);
+
+    @Inject
+    private CheckInsConfiguration configuration;
+
+    @Value("classpath:slack/pulse_slack_blocks.json")
+    private Readable pulseSlackBlocks;
+
+    public boolean send(String triggerId) {
+        String slackBlocks = getSlackBlocks();
+
+        // See if we can have a token.
+        String token = configuration.getApplication()
+                                    .getPulseResponse()
+                                    .getSlack().getBotToken();
+        if (token != null && !slackBlocks.isEmpty()) {
+            MethodsClient client = Slack.getInstance().methods(token);
+
+            try {
+                ViewsOpenRequest request = ViewsOpenRequest.builder()
+                    .triggerId(triggerId)
+                    .viewAsString(slackBlocks)
+                    .build();
+
+                // Send it to Slack
+                ViewsOpenResponse response = client.viewsOpen(request);
+
+                if (!response.isOk()) {
+                    LOG.error("Unable to open the Pulse view");
+                }
+
+                return response.isOk();
+            } catch(Exception ex) {
+                LOG.error(ex.toString());
+                return false;
+            }
+        } else {
+            LOG.error("Missing token or missing slack blocks");
+            return false;
+        }
+    }
+
+    private String getSlackBlocks() {
+        try {
+            return IOUtils.readText(
+                       new BufferedReader(pulseSlackBlocks.asReader()));
+        } catch(Exception ex) {
+            LOG.error(ex.toString());
+            return "";
+        }
+    }
+}
+

server/src/main/java/com/objectcomputing/checkins/services/pulseresponse/PulseSlackCommand.java

@@ -0,0 +1,25 @@
+package com.objectcomputing.checkins.util.form;
+
+import java.nio.charset.Charset;
+import java.net.URLDecoder;
+import java.util.HashMap;
+import java.util.Map;
+
+import jakarta.inject.Singleton;
+
+@Singleton
+public class FormUrlEncodedDecoder {
+    public Map<String, Object> decode(String formUrlEncodedString, Charset charset) {
+        Map<String, Object> queryParams = new HashMap<>();
+        String[] pairs = formUrlEncodedString.split("&");
+        for (String pair : pairs) {
+            int idx = pair.indexOf("=");
+            if (idx > 0) {
+                String key = URLDecoder.decode(pair.substring(0, idx), charset);
+                String value = URLDecoder.decode(pair.substring(idx + 1), charset);
+                queryParams.put(key, value);
+            }
+        }
+        return queryParams;
+    }
+}

server/src/main/java/com/objectcomputing/checkins/util/form/FormUrlEncodedDecoder.java

@@ -104,7 +104,7 @@ check-ins:
     pulse-response:
       slack:
         signing-secret: ${ SLACK_PULSE_SIGNING_SECRET }
-        webhook-url: ${ SLACK_PULSE_WEBHOOK_URL }
+        bot-token: ${ SLACK_PULSE_BOT_TOKEN }
   web-address: ${ WEB_ADDRESS }
 ---
 flyway:

server/src/main/resources/application.yml

@@ -48,7 +48,7 @@ check-ins:
     pulse-response:
       slack:
         signing-secret: BOGUS_SIGNING_SECRET
-        webhook-url: https://bogus.objectcomputing.com/slack
+        bot-token: BOGUS_TOKEN
 ---
 aes:
   key: BOGUS_TEST_KEY