[#12048] Migrate GetSessionResultsAction

src/main/java/teammates/common/datatransfer/SqlSessionResultsBundle.java

@@ -0,0 +1,172 @@
+package teammates.common.datatransfer;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import teammates.common.util.Const;
+import teammates.common.util.StringHelper;
+import teammates.storage.sqlentity.FeedbackQuestion;
+import teammates.storage.sqlentity.FeedbackResponse;
+import teammates.storage.sqlentity.FeedbackResponseComment;
+
+/**
+ * Represents detailed results for a feedback session.
+ */
+public class SqlSessionResultsBundle {
+
+    private final List<FeedbackQuestion> questions;
+    private final Set<FeedbackQuestion> questionsNotVisibleForPreviewSet;
+    private final Set<FeedbackQuestion> questionsWithCommentNotVisibleForPreviewSet;
+    private final Map<FeedbackQuestion, List<FeedbackResponse>> questionResponseMap;
+    private final Map<FeedbackQuestion, List<FeedbackResponse>> questionMissingResponseMap;
+    private final Map<FeedbackResponse, List<FeedbackResponseComment>> responseCommentsMap;
+    private final Map<FeedbackResponse, Boolean> responseGiverVisibilityTable;
+    private final Map<FeedbackResponse, Boolean> responseRecipientVisibilityTable;
+    private final Map<Long, Boolean> commentGiverVisibilityTable;
+    private final SqlCourseRoster roster;
+
+    public SqlSessionResultsBundle(List<FeedbackQuestion> questions,
+                                Set<FeedbackQuestion> questionsNotVisibleForPreviewSet,
+                                Set<FeedbackQuestion> questionsWithCommentNotVisibleForPreviewSet,
+                                List<FeedbackResponse> responses,
+                                List<FeedbackResponse> missingResponses,
+                                Map<FeedbackResponse, Boolean> responseGiverVisibilityTable,
+                                Map<FeedbackResponse, Boolean> responseRecipientVisibilityTable,
+                                Map<FeedbackResponse, List<FeedbackResponseComment>> responseCommentsMap,
+                                Map<Long, Boolean> commentGiverVisibilityTable,
+                                SqlCourseRoster roster) {
+
+        this.questions = questions;
+        this.questionsNotVisibleForPreviewSet = questionsNotVisibleForPreviewSet;
+        this.questionsWithCommentNotVisibleForPreviewSet = questionsWithCommentNotVisibleForPreviewSet;
+        this.responseCommentsMap = responseCommentsMap;
+        this.responseGiverVisibilityTable = responseGiverVisibilityTable;
+        this.responseRecipientVisibilityTable = responseRecipientVisibilityTable;
+        this.commentGiverVisibilityTable = commentGiverVisibilityTable;
+        this.roster = roster;
+        this.questionResponseMap = buildQuestionToResponseMap(responses);
+        this.questionMissingResponseMap = buildQuestionToResponseMap(missingResponses);
+    }
+
+    private Map<FeedbackQuestion, List<FeedbackResponse>> buildQuestionToResponseMap(
+            List<FeedbackResponse> responses) {
+        // build question to response map
+        Map<FeedbackQuestion, List<FeedbackResponse>> questionToResponseMap = new LinkedHashMap<>();
+        for (FeedbackQuestion question : questions) {
+            questionToResponseMap.put(question, new ArrayList<>());
+        }
+        for (FeedbackResponse response : responses) {
+            FeedbackQuestion question = response.getFeedbackQuestion();
+            List<FeedbackResponse> responsesForQuestion = questionToResponseMap.get(question);
+            responsesForQuestion.add(response);
+        }
+        return questionToResponseMap;
+    }
+
+    /**
+     * Returns true if the giver of a response is visible to the current user.
+     * Returns false otherwise.
+     */
+    public boolean isResponseGiverVisible(FeedbackResponse response) {
+        return isResponseParticipantVisible(true, response);
+    }
+
+    /**
+     * Returns true if the recipient of a response is visible to the current user.
+     * Returns false otherwise.
+     */
+    public boolean isResponseRecipientVisible(FeedbackResponse response) {
+        return isResponseParticipantVisible(false, response);
+    }
+
+    /**
+     * Checks if the giver/recipient for a response is visible/hidden from the current user.
+     */
+    private boolean isResponseParticipantVisible(boolean isGiver, FeedbackResponse response) {
+        FeedbackQuestion question = response.getFeedbackQuestion();
+        FeedbackParticipantType participantType;
+
+        boolean isVisible;
+        if (isGiver) {
+            isVisible = responseGiverVisibilityTable.get(response);
+            participantType = question.getGiverType();
+        } else {
+            isVisible = responseRecipientVisibilityTable.get(response);
+            participantType = question.getRecipientType();
+        }
+        boolean isTypeNone = participantType == FeedbackParticipantType.NONE;
+
+        return isVisible || isTypeNone;
+    }
+
+    /**
+     * Returns true if the giver of a comment is visible to the current user.
+     * Returns false otherwise.
+     */
+    public boolean isCommentGiverVisible(FeedbackResponseComment comment) {
+        return commentGiverVisibilityTable.get(comment.getId());
+    }
+
+    /**
+     * Gets the anonymous name for a given name.
+     *
+     * <p>The anonymous name will be deterministic based on {@code name}.
+     */
+    public static String getAnonName(FeedbackParticipantType type, String name) {
+        String hashedEncryptedName = getHashOfName(getEncryptedName(name));
+        String participantType = type.toSingularFormString();
+        return String.format(
+                Const.DISPLAYED_NAME_FOR_ANONYMOUS_PARTICIPANT + " %s %s", participantType, hashedEncryptedName);
+    }
+
+    public Map<FeedbackQuestion, List<FeedbackResponse>> getQuestionResponseMap() {
+        return questionResponseMap;
+    }
+
+    public Map<FeedbackQuestion, List<FeedbackResponse>> getQuestionMissingResponseMap() {
+        return questionMissingResponseMap;
+    }
+
+    private static String getEncryptedName(String name) {
+        return StringHelper.encrypt(name);
+    }
+
+    private static String getHashOfName(String name) {
+        return Long.toString(Math.abs((long) name.hashCode()));
+    }
+
+    public List<FeedbackQuestion> getQuestions() {
+        return questions;
+    }
+
+    public Map<FeedbackResponse, List<FeedbackResponseComment>> getResponseCommentsMap() {
+        return responseCommentsMap;
+    }
+
+    public SqlCourseRoster getRoster() {
+        return roster;
+    }
+
+    public Map<FeedbackResponse, Boolean> getResponseGiverVisibilityTable() {
+        return responseGiverVisibilityTable;
+    }
+
+    public Map<FeedbackResponse, Boolean> getResponseRecipientVisibilityTable() {
+        return responseRecipientVisibilityTable;
+    }
+
+    public Map<Long, Boolean> getCommentGiverVisibilityTable() {
+        return commentGiverVisibilityTable;
+    }
+
+    public Set<FeedbackQuestion> getQuestionsNotVisibleForPreviewSet() {
+        return questionsNotVisibleForPreviewSet;
+    }
+
+    public Set<FeedbackQuestion> getQuestionsWithCommentNotVisibleForPreviewSet() {
+        return questionsWithCommentNotVisibleForPreviewSet;
+    }
+}

src/main/java/teammates/common/datatransfer/questions/FeedbackQuestionDetails.java

@@ -4,6 +4,7 @@
 
 import teammates.common.datatransfer.FeedbackParticipantType;
 import teammates.common.datatransfer.SessionResultsBundle;
+import teammates.common.datatransfer.SqlSessionResultsBundle;
 import teammates.common.datatransfer.attributes.FeedbackQuestionAttributes;
 import teammates.common.util.JsonUtils;
 import teammates.storage.sqlentity.FeedbackQuestion;
@@ -41,6 +42,19 @@ public String getQuestionResultStatisticsJson(
         return "";
     }
 
+    /**
+    * Get question result statistics as JSON string.
+    */
+    @SuppressWarnings("PMD.EmptyMethodInAbstractClassShouldBeAbstract")
+    public String getQuestionResultStatisticsJson(
+            FeedbackQuestion question, String studentEmail, SqlSessionResultsBundle bundle) {
+        // Statistics are calculated in the front-end as it is dependent on the responses being filtered.
+        // The only exception is contribution question, where there is only one statistics for the entire question.
+        // It is also necessary to calculate contribution question statistics here
+        // to be displayed in student result page as students are not supposed to be able to see the exact responses.
+        return "";
+    }
+
     /**
      * Checks whether the changes to the question details require deletion of corresponding responses.
      */
@@ -106,6 +120,17 @@ public boolean shouldGenerateMissingResponses(FeedbackQuestionAttributes questio
                 && question.getRecipientType() != FeedbackParticipantType.TEAMS_EXCLUDING_SELF;
     }
 
+    /**
+     * Checks whether missing responses should be generated.
+     */
+    public boolean shouldGenerateMissingResponses(FeedbackQuestion question) {
+        // generate combinations against all students/teams are meaningless
+        return question.getRecipientType() != FeedbackParticipantType.STUDENTS
+                && question.getRecipientType() != FeedbackParticipantType.STUDENTS_EXCLUDING_SELF
+                && question.getRecipientType() != FeedbackParticipantType.TEAMS
+                && question.getRecipientType() != FeedbackParticipantType.TEAMS_EXCLUDING_SELF;
+    }
+
     @Override
     public boolean equals(Object obj) {
         if (this == obj) {

src/main/java/teammates/common/util/Const.java

@@ -43,6 +43,8 @@ public final class Const {
     public static final String ERROR_CREATE_ENTITY_ALREADY_EXISTS = "Trying to create an entity that exists: %s";
     public static final String ERROR_UPDATE_NON_EXISTENT = "Trying to update non-existent Entity: ";
 
+    public static final String MISSING_RESPONSE_TEXT = "No Response";
+
     // These constants are used as variable values to mean that the variable is in a 'special' state.
 
     public static final int INT_UNINITIALIZED = -9999;

src/main/java/teammates/sqllogic/api/Logic.java

@@ -9,9 +9,11 @@
 import javax.annotation.Nullable;
 
 import teammates.common.datatransfer.FeedbackQuestionRecipient;
+import teammates.common.datatransfer.FeedbackResultFetchType;
 import teammates.common.datatransfer.NotificationStyle;
 import teammates.common.datatransfer.NotificationTargetUser;
 import teammates.common.datatransfer.SqlDataBundle;
+import teammates.common.datatransfer.SqlSessionResultsBundle;
 import teammates.common.exception.EnrollException;
 import teammates.common.exception.EntityAlreadyExistsException;
 import teammates.common.exception.EntityDoesNotExistException;
@@ -1227,6 +1229,39 @@ public List<FeedbackQuestion> getFeedbackQuestionsForInstructors(
         return feedbackQuestionsLogic.getFeedbackQuestionsForInstructors(feedbackSession, instructorEmail);
     }
 
+    /**
+     * Gets the session result for a feedback session.
+     *
+     * @see FeedbackResponsesLogic#getSessionResultsForCourse(
+     * FeedbackSession, String, String, String, Section, FeedbackResultFetchType)
+     */
+    public SqlSessionResultsBundle getSessionResultsForCourse(
+            FeedbackSession feedbackSession, String courseId, String userEmail,
+            @Nullable UUID questionId, @Nullable String sectionName, @Nullable FeedbackResultFetchType fetchType) {
+        assert feedbackSession != null;
+        assert courseId != null;
+        assert userEmail != null;
+
+        return feedbackResponsesLogic.getSessionResultsForCourse(
+                feedbackSession, courseId, userEmail, questionId, sectionName, fetchType);
+    }
+
+    /**
+     * Gets the session result for a feedback session for the given user.
+     *
+     * @see FeedbackResponsesLogic#getSessionResultsForUser(FeedbackSession, String, String, boolean, String)
+     */
+    public SqlSessionResultsBundle getSessionResultsForUser(
+            FeedbackSession feedbackSession, String courseId, String userEmail, boolean isInstructor,
+            @Nullable UUID questionId, boolean isPreviewResults) {
+        assert feedbackSession != null;
+        assert courseId != null;
+        assert userEmail != null;
+
+        return feedbackResponsesLogic.getSessionResultsForUser(
+                feedbackSession, courseId, userEmail, isInstructor, questionId, isPreviewResults);
+    }
+
     /**
      * Persists the given data bundle to the database.
      */

src/main/java/teammates/sqllogic/core/FeedbackQuestionsLogic.java

@@ -647,4 +647,105 @@ public List<FeedbackQuestion> getFeedbackQuestionForCourseWithType(
                 .collect(Collectors.toList());
     }
 
+    /**
+     * Builds a complete giver to recipient map for a {@code relatedQuestion}.
+     *
+     * @param relatedQuestion The question to be considered
+     * @param courseRoster the roster in the course
+     * @return a map from giver to recipient for the question.
+     */
+    public Map<String, Set<String>> buildCompleteGiverRecipientMap(
+            FeedbackQuestion relatedQuestion, SqlCourseRoster courseRoster) {
+        Map<String, Set<String>> completeGiverRecipientMap = new HashMap<>();
+
+        List<String> possibleGiverEmails = getPossibleGivers(relatedQuestion, courseRoster);
+        for (String possibleGiverEmail : possibleGiverEmails) {
+            switch (relatedQuestion.getGiverType()) {
+            case STUDENTS:
+                Student studentGiver = courseRoster.getStudentForEmail(possibleGiverEmail);
+                completeGiverRecipientMap
+                        .computeIfAbsent(possibleGiverEmail, key -> new HashSet<>())
+                        .addAll(getRecipientsOfQuestion(
+                                relatedQuestion, null, studentGiver, courseRoster).keySet());
+                break;
+            case TEAMS:
+                Student oneTeamMember =
+                        courseRoster.getTeamToMembersTable().get(possibleGiverEmail).iterator().next();
+                completeGiverRecipientMap
+                        .computeIfAbsent(possibleGiverEmail, key -> new HashSet<>())
+                        .addAll(getRecipientsOfQuestion(
+                                relatedQuestion, null, oneTeamMember, courseRoster).keySet());
+                break;
+            case INSTRUCTORS:
+            case SELF:
+                Instructor instructorGiver = courseRoster.getInstructorForEmail(possibleGiverEmail);
+
+                // only happens when a session creator quits their course
+                if (instructorGiver == null) {
+                    instructorGiver = new Instructor(
+                            relatedQuestion.getCourse(),
+                            USER_NAME_FOR_SELF,
+                            possibleGiverEmail,
+                            false,
+                            USER_NAME_FOR_SELF,
+                            null,
+                            null
+                            );
+                }
+
+                completeGiverRecipientMap
+                        .computeIfAbsent(possibleGiverEmail, key -> new HashSet<>())
+                        .addAll(getRecipientsOfQuestion(
+                                relatedQuestion, instructorGiver, null, courseRoster).keySet());
+                break;
+            default:
+                log.severe("Invalid giver type specified");
+                break;
+            }
+        }
+
+        return completeGiverRecipientMap;
+    }
+
+    /**
+     * Gets possible giver identifiers for a feedback question.
+     *
+     * @param fq the feedback question
+     * @param courseRoster roster of all students and instructors
+     * @return a list of giver identifier
+     */
+    private List<String> getPossibleGivers(
+            FeedbackQuestion fq, SqlCourseRoster courseRoster) {
+        FeedbackParticipantType giverType = fq.getGiverType();
+        List<String> possibleGivers = new ArrayList<>();
+
+        switch (giverType) {
+        case STUDENTS:
+            possibleGivers = courseRoster.getStudents()
+                    .stream()
+                    .map(Student::getEmail)
+                    .collect(Collectors.toList());
+            break;
+        case INSTRUCTORS:
+            possibleGivers = courseRoster.getInstructors()
+                    .stream()
+                    .map(Instructor::getEmail)
+                    .collect(Collectors.toList());
+            break;
+        case TEAMS:
+            possibleGivers = new ArrayList<>(courseRoster.getTeamToMembersTable().keySet());
+            break;
+        case SELF:
+            FeedbackSession feedbackSession =
+                    feedbackSessionsLogic.getFeedbackSession(fq.getFeedbackSessionName(), fq.getCourseId());
+            possibleGivers = Collections.singletonList(feedbackSession.getCreatorEmail());
+            break;
+        default:
+            log.severe("Invalid giver type specified");
+            break;
+        }
+
+        return possibleGivers;
+    }
+
 }