Merge branch 'develop' into feature-2854/slack-integration-per-deployment

Author: ocielliottc

server/src/main/java/com/objectcomputing/checkins/notifications/social_media/SlackSearch.java

@@ -10,6 +10,8 @@
 import com.slack.api.methods.response.conversations.ConversationsListResponse;
 import com.slack.api.methods.request.users.UsersLookupByEmailRequest;
 import com.slack.api.methods.response.users.UsersLookupByEmailResponse;
+import com.slack.api.methods.request.users.UsersInfoRequest;
+import com.slack.api.methods.response.users.UsersInfoResponse;
 
 import jakarta.inject.Singleton;
 import jakarta.inject.Inject;
@@ -76,5 +78,26 @@ public String findUserId(String userEmail) {
         }
         return null;
     }
+
+    public String findUserEmail(String userId) {
+        String token = configuration.getApplication().getNotifications().getSlack().getBotToken();
+        if (token != null) {
+            try {
+                MethodsClient client = Slack.getInstance().methods(token);
+                UsersInfoResponse response = client.usersInfo(
+                    UsersInfoRequest.builder().user(userId).build()
+                );
+
+                if (response.isOk()) {
+                    return response.getUser().getProfile().getEmail();
+                }
+            } catch(IOException e) {
+                LOG.error("SlackSearch.findUserEmail: " + e.toString());
+            } catch(SlackApiException e) {
+                LOG.error("SlackSearch.findUserEmail: " + e.toString());
+            }
+        }
+        return null;
+    }
 }
 

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

@@ -77,7 +77,7 @@ public class PulseResponse {
     protected PulseResponse() {
     }
 
-    public PulseResponse(UUID id, Integer internalScore, @Nullable Integer externalScore, LocalDate submissionDate, @Nullable UUID teamMemberId, String internalFeelings, String externalFeelings) {
+    public PulseResponse(UUID id, Integer internalScore, @Nullable Integer externalScore, LocalDate submissionDate, @Nullable UUID teamMemberId, @Nullable String internalFeelings, @Nullable String externalFeelings) {
         this.id = id;
         this.internalScore = internalScore;
         this.externalScore = externalScore;
@@ -91,62 +91,6 @@ public PulseResponse(Integer internalScore, Integer externalScore, LocalDate sub
         this(null, internalScore, externalScore, submissionDate, teamMemberId, internalFeelings, externalFeelings);
     }
 
-    public UUID getId() {
-        return this.id;
-    }
-
-    public void setId(UUID id) {
-        this.id = id;
-    }
-
-    public Integer getInternalScore() {
-        return internalScore;
-    }
-
-    public void setInternalScore(Integer internalScore) {
-        this.internalScore = internalScore;
-    }
-
-    public Integer getExternalScore() {
-        return externalScore;
-    }
-
-    public void setExternalScore(Integer externalScore) {
-        this.externalScore = externalScore;
-    }
-
-    public LocalDate getSubmissionDate() {
-        return submissionDate;
-    }
-
-    public void setSubmissionDate(LocalDate submissionDate) {
-        this.submissionDate = submissionDate;
-    }
-
-    public UUID getTeamMemberId() {
-        return this.teamMemberId;
-    }
-
-    public void setTeamMemberId(UUID teamMemberId) {
-        this.teamMemberId = teamMemberId;
-    }
-
-    public String getInternalFeelings() {
-        return internalFeelings;
-    }
-
-    public void setInternalFeelings(String internalFeelings) {
-        this.internalFeelings = internalFeelings;
-    }
-
-    public String getExternalFeelings() {
-        return externalFeelings;
-    }
-
-    public void setExternalFeelings(String externalFeelings) {
-        this.externalFeelings = externalFeelings;
-    }
-
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;

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

@@ -25,9 +25,6 @@
 import jakarta.validation.Valid;
 import jakarta.validation.constraints.NotNull;
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import java.net.URI;
 import java.time.LocalDate;
 import java.util.Set;
@@ -39,21 +36,22 @@
 @ExecuteOn(TaskExecutors.BLOCKING)
 @Tag(name = "pulse-responses")
 public class PulseResponseController {
-    private static final Logger LOG = LoggerFactory.getLogger(PulseResponseController.class);
-
     private final PulseResponseService pulseResponseServices;
     private final MemberProfileServices memberProfileServices;
     private final SlackSignatureVerifier slackSignatureVerifier;
     private final PulseSlackCommand pulseSlackCommand;
+    private final SlackPulseResponseConverter slackPulseResponseConverter;
 
     public PulseResponseController(PulseResponseService pulseResponseServices,
                                    MemberProfileServices memberProfileServices,
                                    SlackSignatureVerifier slackSignatureVerifier,
-                                   PulseSlackCommand pulseSlackCommand) {
+                                   PulseSlackCommand pulseSlackCommand,
+                                   SlackPulseResponseConverter slackPulseResponseConverter) {
         this.pulseResponseServices = pulseResponseServices;
         this.memberProfileServices = memberProfileServices;
         this.slackSignatureVerifier = slackSignatureVerifier;
         this.pulseSlackCommand = pulseSlackCommand;
+        this.slackPulseResponseConverter = slackPulseResponseConverter;
     }
 
     /**
@@ -145,48 +143,55 @@ public HttpResponse commandPulseResponse(
 
     @Secured(SecurityRule.IS_ANONYMOUS)
     @Post(uri = "/external", consumes = MediaType.APPLICATION_FORM_URLENCODED)
-    public HttpResponse<PulseResponse> externalPulseResponse(
+    public HttpResponse externalPulseResponse(
                @Header("X-Slack-Signature") String signature,
                @Header("X-Slack-Request-Timestamp") String timestamp,
                @Body String requestBody,
                HttpRequest<?> request) {
-        // DEBUG Only
-        LOG.info(requestBody);
-
         // Validate the request
         if (slackSignatureVerifier.verifyRequest(signature,
                                                  timestamp, requestBody)) {
-            // DEBUG Only
-            LOG.info("Request has been verified");
-
-            PulseResponseCreateDTO pulseResponseDTO =
-                SlackPulseResponseConverter.get(memberProfileServices,
-                                                requestBody);
-
-            // DEBUG Only
-            LOG.info("Request has been converted");
-
-            // Create the pulse response
-            PulseResponse pulseResponse = pulseResponseServices.unsecureSave(
-                new PulseResponse(
-                    pulseResponseDTO.getInternalScore(),
-                    pulseResponseDTO.getExternalScore(),
-                    pulseResponseDTO.getSubmissionDate(),
-                    pulseResponseDTO.getTeamMemberId(),
-                    pulseResponseDTO.getInternalFeelings(),
-                    pulseResponseDTO.getExternalFeelings()
-                )
-            );
-
-            if (pulseResponse == null) {
-                return HttpResponse.status(HttpStatus.CONFLICT,
-                                           "Already submitted today");
+            // Convert the request body to a map of values.
+            FormUrlEncodedDecoder formUrlEncodedDecoder =
+                new FormUrlEncodedDecoder();
+            Map<String, Object> body =
+                formUrlEncodedDecoder.decode(requestBody,
+                                             StandardCharsets.UTF_8);
+
+            final String key = "payload";
+            if (body.containsKey(key)) {
+                PulseResponseCreateDTO pulseResponseDTO =
+                    slackPulseResponseConverter.get(memberProfileServices,
+                                                    (String)body.get(key));
+
+                // If we receive a null DTO, that means that this is not the
+                // actual submission of the form.  We can just return 200 so
+                // that Slack knows to continue without error.
+                if (pulseResponseDTO == null) {
+                    return HttpResponse.ok();
+                }
+
+                // Create the pulse response
+                PulseResponse pulseResponse =
+                    pulseResponseServices.unsecureSave(
+                        new PulseResponse(
+                            pulseResponseDTO.getInternalScore(),
+                            pulseResponseDTO.getExternalScore(),
+                            pulseResponseDTO.getSubmissionDate(),
+                            pulseResponseDTO.getTeamMemberId(),
+                            pulseResponseDTO.getInternalFeelings(),
+                            pulseResponseDTO.getExternalFeelings()
+                        )
+                );
+
+                if (pulseResponse == null) {
+                    return HttpResponse.status(HttpStatus.CONFLICT,
+                                               "Already submitted today");
+                } else {
+                    return HttpResponse.ok();
+                }
             } else {
-                return HttpResponse.created(pulseResponse)
-                                   .headers(headers -> headers.location(
-                                       URI.create(String.format("%s/%s",
-                                                  request.getPath(),
-                                                  pulseResponse.getId()))));
+                return HttpResponse.unprocessableEntity();
             }
         } else {
             return HttpResponse.unauthorized();

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

@@ -3,6 +3,9 @@
 import com.objectcomputing.checkins.exceptions.BadArgException;
 import com.objectcomputing.checkins.services.memberprofile.MemberProfile;
 import com.objectcomputing.checkins.services.memberprofile.MemberProfileServices;
+import com.objectcomputing.checkins.notifications.social_media.SlackSearch;
+
+import jakarta.inject.Singleton;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -15,20 +18,26 @@
 import java.util.UUID;
 import java.time.LocalDate;
 
+@Singleton
 public class SlackPulseResponseConverter {
     private static final Logger LOG = LoggerFactory.getLogger(SlackPulseResponseConverter.class);
 
-    public static PulseResponseCreateDTO get(
+    private final SlackSearch slackSearch;
+
+    public SlackPulseResponseConverter(SlackSearch slackSearch) {
+        this.slackSearch = slackSearch;
+    }
+
+    public PulseResponseCreateDTO get(
                     MemberProfileServices memberProfileServices, String body) {
-        final String key = "payload=";
-        final int start = body.indexOf(key);
-        if (start >= 0) {
-            try {
-                // Get the map of values from the string body
-                final ObjectMapper mapper = new ObjectMapper();
-                final Map<String, Object> map =
-                        mapper.readValue(body.substring(start + key.length()),
-                                         new TypeReference<>() {});
+        try {
+            // Get the map of values from the string body
+            final ObjectMapper mapper = new ObjectMapper();
+            final Map<String, Object> map =
+                    mapper.readValue(body, new TypeReference<>() {});
+            final String type = (String)map.get("type");
+
+            if (type.equals("view_submission")) {
                 final Map<String, Object> view =
                         (Map<String, Object>)map.get("view");
                 final Map<String, Object> state =
@@ -41,59 +50,77 @@ public static PulseResponseCreateDTO get(
                 response.setTeamMemberId(lookupUser(memberProfileServices, map));
                 response.setSubmissionDate(LocalDate.now());
 
-                response.setInternalScore(Integer.parseInt(
-                    getMappedValue(values, "internalScore", true)));
-                response.setInternalFeelings(
-                    getMappedValue(values, "internalFeelings", false));
+                // Internal Score
+                Map<String, Object> internalBlock =
+                    (Map<String, Object>)values.get("internalNumber");
+                response.setInternalScore(Integer.parseInt(getMappedValue(
+                    internalBlock, "internalScore", "selected_option", true)));
+                // Internal Feelings
+                response.setInternalFeelings(getMappedValue(
+                    values, "internalText", "internalFeelings", false));
 
-                String score = getMappedValue(values, "externalScore", false);
-                if (!score.isEmpty()) {
+                // External Score
+                Map<String, Object> externalBlock =
+                    (Map<String, Object>)values.get("externalNumber");
+                String score = getMappedValue(externalBlock, "externalScore",
+                                              "selected_option", false);
+                if (score != null && !score.isEmpty()) {
                     response.setExternalScore(Integer.parseInt(score));
                 }
-                response.setExternalFeelings(
-                    getMappedValue(values, "externalFeelings", false));
+                // External Feelings
+                response.setExternalFeelings(getMappedValue(
+                    values, "externalText", "externalFeelings", false));
 
                 return response;
-            } catch(JsonProcessingException ex) {
-                LOG.error(ex.getMessage());
-                throw new BadArgException(ex.getMessage());
-            } catch(NumberFormatException ex) {
-                LOG.error(ex.getMessage());
-                throw new BadArgException("Pulse scores must be integers");
+            } else {
+                // If it's not a view submission, we need to return null so
+                // the the caller knows that this is not the full pulse
+                // response.
+                return null;
             }
-        } else {
-            LOG.error(body);
-            throw new BadArgException("Invalid pulse response body");
+        } catch(JsonProcessingException ex) {
+            LOG.error(ex.getMessage());
+            throw new BadArgException(ex.getMessage());
+        } catch(NumberFormatException ex) {
+            LOG.error(ex.getMessage());
+            throw new BadArgException("Pulse scores must be integers");
         }
     }
 
-    private static String getMappedValue(Map<String, Object> map,
-                                         String key, boolean required) {
+    private String getMappedValue(Map<String, Object> map, String key1,
+                                  String key2, boolean required) {
         final String valueKey = "value";
-        if (map.containsKey(key)) {
-            final Map<String, Object> other = (Map<String, Object>)map.get(key);
-            if (other.containsKey(valueKey)) {
-                return (String)other.get(valueKey);
+        if (map != null && map.containsKey(key1)) {
+            Map<String, Object> firstMap = (Map<String, Object>)map.get(key1);
+            if (firstMap != null && firstMap.containsKey(key2)) {
+                final Map<String, Object> secondMap =
+                    (Map<String, Object>)firstMap.get(key2);
+                if (secondMap != null && secondMap.containsKey(valueKey)) {
+                    return (String)secondMap.get(valueKey);
+                }
             }
         }
 
         if (required) {
-            LOG.error("Expected {}.{} was not found", key, valueKey);
+            LOG.error("Expected {}.{}.{} was not found", key1, key2, valueKey);
             throw new BadArgException(
-                String.format("Expected %s.%s was not found", key, valueKey));
+                String.format("Expected %s.%s.%s was not found",
+                              key1, key2, valueKey));
         } else {
-            return "";
+            return null;
         }
     }
 
-    private static UUID lookupUser(MemberProfileServices memberProfileServices,
-                                   Map<String, Object> map) {
+    private UUID lookupUser(MemberProfileServices memberProfileServices,
+                            Map<String, Object> map) {
         // Get the user's profile map.
         Map<String, Object> user = (Map<String, Object>)map.get("user");
-        Map<String, Object> profile = (Map<String, Object>)user.get("profile");
 
         // Lookup the user based on the email address.
-        String email = (String)profile.get("email");
+        String email = slackSearch.findUserEmail((String)user.get("id"));
+        if (email == null) {
+            throw new BadArgException("Unable to find the user email address");
+        }
         MemberProfile member = memberProfileServices.findByWorkEmail(email);
         return member.getId();
     }