/**
* This class is the parent class for all *WorkerServlets. This class provides logging of exceptions
* that are uncaught by child *WorkerServlet classes. Child classes should also perform their own
* logging of exceptions that could occur during the execution of the servlet.
*/
@SuppressWarnings("serial")
public abstract class WorkerServlet extends HttpServlet {
protected static Logger log = Utils.getLogger();
protected String servletName = "unspecified";
protected String action = "unspecified";
public void doPost(HttpServletRequest req, HttpServletResponse resp) {
try {
doGet(req, resp);
} catch (Exception e) {
log.severe("Exception occured while performing " + servletName + e.getMessage());
}
}
public abstract void doGet(HttpServletRequest req, HttpServletResponse resp);
protected void logMessage(HttpServletRequest request, String message) {
String url = HttpRequestHelper.getRequestedURL(request);
ActivityLogEntry activityLogEntry =
new ActivityLogEntry(servletName, action, null, message, url);
log.log(Level.INFO, activityLogEntry.generateLogMessage());
}
}
@Test
public void testToString() {
EvaluationAttributes e;
e = generateValidEvaluationAttributesObject();
String inStringFormat = Utils.getTeammatesGson().toJson(e, EvaluationAttributes.class);
assertEquals(inStringFormat, e.toString());
}
protected static DataBundle loadDataBundle(String pathToJsonFile) {
if (pathToJsonFile.startsWith("/")) {
pathToJsonFile = TestProperties.TEST_DATA_FOLDER + pathToJsonFile;
}
try {
String jsonString = FileHelper.readFile(pathToJsonFile);
return Utils.getTeammatesGson().fromJson(jsonString, DataBundle.class);
} catch (FileNotFoundException e) {
throw new RuntimeException(e);
}
}
@Override
public boolean execute() {
log.info(
"Adjusting submissions for feedback session :" + sessionName + "in course : " + courseId);
FeedbackSessionAttributes feedbackSession =
FeedbackSessionsLogic.inst().getFeedbackSession(sessionName, courseId);
String errorString =
"Error encountered while adjusting feedback session responses of %s in course : %s : %s\n%s";
if (feedbackSession == null) {
log.severe(String.format(errorString, sessionName, courseId, "feedback session is null", ""));
return false;
}
List<FeedbackResponseAttributes> allResponses =
FeedbackResponsesLogic.inst()
.getFeedbackResponsesForSession(
feedbackSession.getFeedbackSessionName(), feedbackSession.getCourseId());
Gson gsonParser = Utils.getTeammatesGson();
ArrayList<StudentEnrollDetails> enrollmentList =
gsonParser.fromJson(
enrollmentDetails, new TypeToken<ArrayList<StudentEnrollDetails>>() {}.getType());
for (FeedbackResponseAttributes response : allResponses) {
try {
StudentsLogic.inst().adjustFeedbackResponseForEnrollments(enrollmentList, response);
} catch (Exception e) {
log.severe(
String.format(
errorString,
sessionName,
courseId,
e.getMessage(),
ActivityLogEntry.generateServletActionFailureLogMessage(request, e)));
return false;
}
}
return true;
}
public class FeedbackSessionsDb extends EntitiesDb {
public static final String ERROR_UPDATE_NON_EXISTENT =
"Trying to update non-existent Feedback Session : ";
private static final Logger log = Utils.getLogger();
public void createFeedbackSessions(Collection<FeedbackSessionAttributes> feedbackSessionsToAdd)
throws InvalidParametersException {
List<EntityAttributes> feedbackSessionsToUpdate = createEntities(feedbackSessionsToAdd);
for (EntityAttributes entity : feedbackSessionsToUpdate) {
FeedbackSessionAttributes session = (FeedbackSessionAttributes) entity;
try {
updateFeedbackSession(session);
} catch (EntityDoesNotExistException e) {
// This situation is not tested as replicating such a situation is
// difficult during testing
Assumption.fail("Entity found be already existing and not existing simultaneously");
}
}
}
public List<FeedbackSessionAttributes> getAllOpenFeedbackSessions(
Date start, Date end, double zone) {
List<FeedbackSessionAttributes> list = new LinkedList<FeedbackSessionAttributes>();
final Query endTimequery =
getPM()
.newQuery(
"SELECT FROM teammates.storage.entity.FeedbackSession "
+ "WHERE this.endTime>rangeStart && this.endTime<=rangeEnd "
+ " PARAMETERS java.util.Date rangeStart, "
+ "java.util.Date rangeEnd");
final Query startTimequery =
getPM()
.newQuery(
"SELECT FROM teammates.storage.entity.FeedbackSession "
+ "WHERE this.startTime>=rangeStart && this.startTime<rangeEnd "
+ "PARAMETERS java.util.Date rangeStart, "
+ "java.util.Date rangeEnd");
Calendar startCal = Calendar.getInstance();
startCal.setTime(start);
Calendar endCal = Calendar.getInstance();
endCal.setTime(end);
Date curStart = TimeHelper.convertToUserTimeZone(startCal, -25).getTime();
Date curEnd = TimeHelper.convertToUserTimeZone(endCal, 25).getTime();
@SuppressWarnings("unchecked")
List<FeedbackSession> endEntities =
(List<FeedbackSession>) endTimequery.execute(curStart, curEnd);
@SuppressWarnings("unchecked")
List<FeedbackSession> startEntities =
(List<FeedbackSession>) startTimequery.execute(curStart, curEnd);
List<FeedbackSession> endTimeEntities = new ArrayList<FeedbackSession>(endEntities);
List<FeedbackSession> startTimeEntities = new ArrayList<FeedbackSession>(startEntities);
endTimeEntities.removeAll(startTimeEntities);
startTimeEntities.removeAll(endTimeEntities);
endTimeEntities.addAll(startTimeEntities);
Iterator<FeedbackSession> it = endTimeEntities.iterator();
while (it.hasNext()) {
startCal.setTime(start);
endCal.setTime(end);
FeedbackSessionAttributes fs = new FeedbackSessionAttributes(it.next());
Date standardStart = TimeHelper.convertToUserTimeZone(startCal, fs.timeZone - zone).getTime();
Date standardEnd = TimeHelper.convertToUserTimeZone(endCal, fs.timeZone - zone).getTime();
if ((fs.startTime.getTime() >= standardStart.getTime()
&& fs.startTime.getTime() < standardEnd.getTime())
|| (fs.endTime.getTime() > standardStart.getTime()
&& fs.endTime.getTime() <= standardEnd.getTime())) list.add(fs);
}
return list;
}
/**
* Preconditions: <br>
* * All parameters are non-null.
*
* @return Null if not found.
*/
public FeedbackSessionAttributes getFeedbackSession(String courseId, String feedbackSessionName) {
Assumption.assertNotNull(Const.StatusCodes.DBLEVEL_NULL_INPUT, feedbackSessionName);
Assumption.assertNotNull(Const.StatusCodes.DBLEVEL_NULL_INPUT, courseId);
FeedbackSession fs = getFeedbackSessionEntity(feedbackSessionName, courseId);
if (fs == null) {
log.info("Trying to get non-existent Session: " + feedbackSessionName + "/" + courseId);
return null;
}
return new FeedbackSessionAttributes(fs);
}
/**
* @return empty list if none found.
* @deprecated Not scalable. Created for data migration purposes.
*/
@Deprecated
public List<FeedbackSessionAttributes> getAllFeedbackSessions() {
List<FeedbackSession> allFS = getAllFeedbackSessionEntities();
List<FeedbackSessionAttributes> fsaList = new ArrayList<FeedbackSessionAttributes>();
for (FeedbackSession fs : allFS) {
fsaList.add(new FeedbackSessionAttributes(fs));
}
return fsaList;
}
/**
* Preconditions: <br>
* * All parameters are non-null.
*
* @return An empty list if no non-private sessions are found.
*/
public List<FeedbackSessionAttributes> getNonPrivateFeedbackSessions() {
List<FeedbackSession> fsList = getNonPrivateFeedbackSessionEntities();
List<FeedbackSessionAttributes> fsaList = new ArrayList<FeedbackSessionAttributes>();
for (FeedbackSession fs : fsList) {
fsaList.add(new FeedbackSessionAttributes(fs));
}
return fsaList;
}
/**
* Preconditions: <br>
* * All parameters are non-null.
*
* @return An empty list if no sessions are found for the given course.
*/
public List<FeedbackSessionAttributes> getFeedbackSessionsForCourse(String courseId) {
Assumption.assertNotNull(Const.StatusCodes.DBLEVEL_NULL_INPUT, courseId);
List<FeedbackSession> fsList = getFeedbackSessionEntitiesForCourse(courseId);
List<FeedbackSessionAttributes> fsaList = new ArrayList<FeedbackSessionAttributes>();
for (FeedbackSession fs : fsList) {
fsaList.add(new FeedbackSessionAttributes(fs));
}
return fsaList;
}
/**
* Preconditions: <br>
* * All parameters are non-null.
*
* @return An empty list if no sessions are found that have unsent open emails.
*/
public List<FeedbackSessionAttributes> getFeedbackSessionsWithUnsentOpenEmail() {
List<FeedbackSession> fsList = getFeedbackSessionEntitiesWithUnsentOpenEmail();
List<FeedbackSessionAttributes> fsaList = new ArrayList<FeedbackSessionAttributes>();
for (FeedbackSession fs : fsList) {
fsaList.add(new FeedbackSessionAttributes(fs));
}
return fsaList;
}
/**
* Preconditions: <br>
* * All parameters are non-null.
*
* @return An empty list if no sessions are found that have unsent published emails.
*/
public List<FeedbackSessionAttributes> getFeedbackSessionsWithUnsentPublishedEmail() {
List<FeedbackSession> fsList = getFeedbackSessionEntitiesWithUnsentPublishedEmail();
List<FeedbackSessionAttributes> fsaList = new ArrayList<FeedbackSessionAttributes>();
for (FeedbackSession fs : fsList) {
fsaList.add(new FeedbackSessionAttributes(fs));
}
return fsaList;
}
/**
* Updates the feedback session identified by {@code newAttributes.feedbackSesionName} and {@code
* newAttributes.courseId}. For the remaining parameters, the existing value is preserved if the
* parameter is null (due to 'keep existing' policy).<br>
* Preconditions: <br>
* * {@code newAttributes.feedbackSesionName} and {@code newAttributes.courseId} are non-null and
* correspond to an existing feedback session. <br>
*/
public void updateFeedbackSession(FeedbackSessionAttributes newAttributes)
throws InvalidParametersException, EntityDoesNotExistException {
Assumption.assertNotNull(Const.StatusCodes.DBLEVEL_NULL_INPUT, newAttributes);
newAttributes.sanitizeForSaving();
if (!newAttributes.isValid()) {
throw new InvalidParametersException(newAttributes.getInvalidityInfo());
}
FeedbackSession fs = (FeedbackSession) getEntity(newAttributes);
if (fs == null) {
throw new EntityDoesNotExistException(ERROR_UPDATE_NON_EXISTENT + newAttributes.toString());
}
fs.setInstructions(newAttributes.instructions);
fs.setStartTime(newAttributes.startTime);
fs.setEndTime(newAttributes.endTime);
fs.setSessionVisibleFromTime(newAttributes.sessionVisibleFromTime);
fs.setResultsVisibleFromTime(newAttributes.resultsVisibleFromTime);
fs.setTimeZone(newAttributes.timeZone);
fs.setGracePeriod(newAttributes.gracePeriod);
fs.setFeedbackSessionType(newAttributes.feedbackSessionType);
fs.setSentOpenEmail(newAttributes.sentOpenEmail);
fs.setSentPublishedEmail(newAttributes.sentPublishedEmail);
fs.setIsOpeningEmailEnabled(newAttributes.isOpeningEmailEnabled);
fs.setSendClosingEmail(newAttributes.isClosingEmailEnabled);
fs.setSendPublishedEmail(newAttributes.isPublishedEmailEnabled);
getPM().close();
}
public void deleteFeedbackSessionsForCourses(List<String> courseIds) {
Assumption.assertNotNull(Const.StatusCodes.DBLEVEL_NULL_INPUT, courseIds);
List<FeedbackSession> feedbackSessionList = getFeedbackSessionEntitiesForCourses(courseIds);
getPM().deletePersistentAll(feedbackSessionList);
getPM().flush();
}
private List<FeedbackSession> getFeedbackSessionEntitiesForCourses(List<String> courseIds) {
Query q = getPM().newQuery(FeedbackSession.class);
q.setFilter(":p.contains(courseId)");
@SuppressWarnings("unchecked")
List<FeedbackSession> feedbackSessionList = (List<FeedbackSession>) q.execute(courseIds);
return feedbackSessionList;
}
private List<FeedbackSession> getAllFeedbackSessionEntities() {
Query q = getPM().newQuery(FeedbackSession.class);
@SuppressWarnings("unchecked")
List<FeedbackSession> fsList = (List<FeedbackSession>) q.execute();
return fsList;
}
private List<FeedbackSession> getNonPrivateFeedbackSessionEntities() {
Query q = getPM().newQuery(FeedbackSession.class);
q.declareParameters("Enum private");
q.setFilter("feedbackSessionType != private");
@SuppressWarnings("unchecked")
List<FeedbackSession> fsList = (List<FeedbackSession>) q.execute(FeedbackSessionType.PRIVATE);
return fsList;
}
private List<FeedbackSession> getFeedbackSessionEntitiesForCourse(String courseId) {
Query q = getPM().newQuery(FeedbackSession.class);
q.declareParameters("String courseIdParam");
q.setFilter("courseId == courseIdParam");
@SuppressWarnings("unchecked")
List<FeedbackSession> fsList = (List<FeedbackSession>) q.execute(courseId);
return fsList;
}
private List<FeedbackSession> getFeedbackSessionEntitiesWithUnsentOpenEmail() {
Query q = getPM().newQuery(FeedbackSession.class);
q.declareParameters("boolean sentParam, Enum notTypeParam");
q.setFilter("sentOpenEmail == sentParam && feedbackSessionType != notTypeParam");
@SuppressWarnings("unchecked")
List<FeedbackSession> fsList =
(List<FeedbackSession>) q.execute(false, FeedbackSessionType.PRIVATE);
return fsList;
}
private List<FeedbackSession> getFeedbackSessionEntitiesWithUnsentPublishedEmail() {
Query q = getPM().newQuery(FeedbackSession.class);
q.declareParameters("boolean sentParam, Enum notTypeParam");
q.setFilter("sentPublishedEmail == sentParam && feedbackSessionType != notTypeParam");
@SuppressWarnings("unchecked")
List<FeedbackSession> fsList =
(List<FeedbackSession>) q.execute(false, FeedbackSessionType.PRIVATE);
return fsList;
}
private FeedbackSession getFeedbackSessionEntity(String feedbackSessionName, String courseId) {
Query q = getPM().newQuery(FeedbackSession.class);
q.declareParameters("String feedbackSessionNameParam, String courseIdParam");
q.setFilter("feedbackSessionName == feedbackSessionNameParam && courseId == courseIdParam");
@SuppressWarnings("unchecked")
List<FeedbackSession> feedbackSessionList =
(List<FeedbackSession>) q.execute(feedbackSessionName, courseId);
if (feedbackSessionList.isEmpty() || JDOHelper.isDeleted(feedbackSessionList.get(0))) {
return null;
}
return feedbackSessionList.get(0);
}
@Override
protected Object getEntity(EntityAttributes attributes) {
FeedbackSessionAttributes feedbackSessionToGet = (FeedbackSessionAttributes) attributes;
return getFeedbackSessionEntity(
feedbackSessionToGet.feedbackSessionName, feedbackSessionToGet.courseId);
}
}
/** Handles the logic related to {@link CommentAttributes}. */
public class CommentsLogic {
private static CommentsLogic instance;
@SuppressWarnings("unused") // used by test
private static final Logger log = Utils.getLogger();
private static final CommentsDb commentsDb = new CommentsDb();
private static final CoursesLogic coursesLogic = CoursesLogic.inst();
private static final InstructorsLogic instructorsLogic = InstructorsLogic.inst();
private static final StudentsLogic studentsLogic = StudentsLogic.inst();
private static final FeedbackQuestionsLogic fqLogic = FeedbackQuestionsLogic.inst();
private static final FeedbackResponsesLogic frLogic = FeedbackResponsesLogic.inst();
private static final FeedbackResponseCommentsLogic frcLogic =
FeedbackResponseCommentsLogic.inst();
public static CommentsLogic inst() {
if (instance == null) {
instance = new CommentsLogic();
}
return instance;
}
/** ********** CRUD *********** */
public CommentAttributes createComment(CommentAttributes comment)
throws InvalidParametersException, EntityAlreadyExistsException, EntityDoesNotExistException {
verifyIsCoursePresent(comment.courseId, "create");
verifyIsInstructorOfCourse(comment.courseId, comment.giverEmail);
return commentsDb.createEntity(comment);
}
public CommentAttributes getComment(Long commentId) {
return commentsDb.getComment(commentId);
}
public List<CommentAttributes> getCommentsForGiver(String courseId, String giverEmail)
throws EntityDoesNotExistException {
verifyIsCoursePresent(courseId, "get");
return commentsDb.getCommentsForGiver(courseId, giverEmail);
}
public List<CommentAttributes> getCommentsForReceiver(
String courseId,
String giverEmail,
CommentParticipantType recipientType,
String receiverEmail)
throws EntityDoesNotExistException {
verifyIsCoursePresent(courseId, "get");
List<CommentAttributes> comments =
commentsDb.getCommentsForReceiver(courseId, recipientType, receiverEmail);
Iterator<CommentAttributes> iterator = comments.iterator();
while (iterator.hasNext()) {
CommentAttributes c = iterator.next();
if (!c.giverEmail.equals(giverEmail)) {
iterator.remove();
}
}
return comments;
}
public List<CommentAttributes> getCommentsForReceiver(
String courseId, CommentParticipantType recipientType, String receiverEmail)
throws EntityDoesNotExistException {
verifyIsCoursePresent(courseId, "get");
return commentsDb.getCommentsForReceiver(courseId, recipientType, receiverEmail);
}
public List<CommentAttributes> getCommentsForSendingState(
String courseId, CommentSendingState sendingState) throws EntityDoesNotExistException {
verifyIsCoursePresent(courseId, "get");
return commentsDb.getCommentsForSendingState(courseId, sendingState);
}
public void updateCommentsSendingState(
String courseId, CommentSendingState oldState, CommentSendingState newState)
throws EntityDoesNotExistException {
verifyIsCoursePresent(courseId, "clear pending");
commentsDb.updateComments(courseId, oldState, newState);
}
public CommentAttributes updateComment(CommentAttributes comment)
throws InvalidParametersException, EntityDoesNotExistException {
verifyIsCoursePresent(comment.courseId, "update");
return commentsDb.updateComment(comment);
}
/**
* update comment's giver email (assume to be an instructor)
*
* @param courseId
* @param oldInstrEmail
* @param updatedInstrEmail
*/
public void updateInstructorEmail(
String courseId, String oldInstrEmail, String updatedInstrEmail) {
commentsDb.updateInstructorEmail(courseId, oldInstrEmail, updatedInstrEmail);
}
/**
* update comment's recipient email (assume to be a student)
*
* @param courseId
* @param oldStudentEmail
* @param updatedStudentEmail
*/
public void updateStudentEmail(
String courseId, String oldStudentEmail, String updatedStudentEmail) {
commentsDb.updateStudentEmail(courseId, oldStudentEmail, updatedStudentEmail);
}
public void deleteCommentsForInstructor(String courseId, String instructorEmail) {
commentsDb.deleteCommentsByInstructorEmail(courseId, instructorEmail);
}
public void deleteCommentsForStudent(String courseId, String studentEmail) {
commentsDb.deleteCommentsByStudentEmail(courseId, studentEmail);
}
public void deleteCommentsForTeam(String courseId, String teamName) {
commentsDb.deleteCommentsForTeam(courseId, teamName);
}
public void deleteCommentsForSection(String courseId, String sectionName) {
commentsDb.deleteCommentsForSection(courseId, sectionName);
}
public void deleteCommentsForCourse(String courseId) {
commentsDb.deleteCommentsForCourse(courseId);
}
public void deleteCommentAndDocument(CommentAttributes comment) {
this.deleteComment(comment);
this.deleteDocument(comment);
}
public void deleteComment(CommentAttributes comment) {
commentsDb.deleteEntity(comment);
}
public void deleteDocument(CommentAttributes comment) {
commentsDb.deleteDocument(comment);
}
public List<CommentAttributes> getCommentDrafts(String giverEmail) {
return commentsDb.getCommentDrafts(giverEmail);
}
/**
* Create or update document for comment
*
* @param comment
*/
public void putDocument(CommentAttributes comment) {
commentsDb.putDocument(comment);
}
public CommentSearchResultBundle searchComment(
String queryString, List<InstructorAttributes> instructors, String cursorString) {
return commentsDb.search(queryString, instructors, cursorString);
}
private void verifyIsCoursePresent(String courseId, String action)
throws EntityDoesNotExistException {
if (!coursesLogic.isCoursePresent(courseId)) {
throw new EntityDoesNotExistException(
"Trying to " + action + " comments for a course that does not exist.");
}
}
private void verifyIsInstructorOfCourse(String courseId, String email)
throws EntityDoesNotExistException {
InstructorAttributes instructor = instructorsLogic.getInstructorForEmail(courseId, email);
if (instructor == null) {
throw new EntityDoesNotExistException(
"User " + email + " is not a registered instructor for course " + courseId + ".");
}
}
/** ********** Get Comments For an Instructor *********** */
/**
* Get comments visible for the given instructor
*
* @param instructor
* @return list of {@link CommentAttributes}
* @throws EntityDoesNotExistException when the course doesn't exist
*/
public List<CommentAttributes> getCommentsForInstructor(InstructorAttributes instructor)
throws EntityDoesNotExistException {
verifyIsCoursePresent(instructor.courseId, "get");
verifyIsInstructorOfCourse(instructor.courseId, instructor.email);
HashSet<String> commentsVisitedSet = new HashSet<String>();
// When the given instructor is the comment giver,
List<CommentAttributes> comments =
getCommentsForGiverAndStatus(instructor.courseId, instructor.email, CommentStatus.FINAL);
for (CommentAttributes c : comments) {
preventAppendingThisCommentAgain(commentsVisitedSet, c);
}
// When other giver's comments are visible to the given instructor
List<CommentAttributes> commentsForOtherInstructor =
getCommentsForCommentViewer(instructor.courseId, CommentParticipantType.INSTRUCTOR);
removeNonVisibleCommentsForInstructor(commentsForOtherInstructor, commentsVisitedSet, comments);
java.util.Collections.sort(comments);
return comments;
}
private void removeNonVisibleCommentsForInstructor(
List<CommentAttributes> commentsForInstructor,
HashSet<String> commentsVisitedSet,
List<CommentAttributes> comments) {
for (CommentAttributes c : commentsForInstructor) {
removeGiverAndRecipientNameByVisibilityOptions(c, CommentParticipantType.INSTRUCTOR);
appendComments(c, comments, commentsVisitedSet);
}
}
private List<CommentAttributes> getCommentsForCommentViewer(
String courseId, CommentParticipantType commentViewerType)
throws EntityDoesNotExistException {
verifyIsCoursePresent(courseId, "get");
return commentsDb.getCommentsForCommentViewer(courseId, commentViewerType);
}
private List<CommentAttributes> getCommentsForGiverAndStatus(
String courseId, String giverEmail, CommentStatus status) throws EntityDoesNotExistException {
verifyIsCoursePresent(courseId, "get");
return commentsDb.getCommentsForGiverAndStatus(courseId, giverEmail, status);
}
/** ********** Get Comments For a Student *********** */
/**
* Get comments visible to the given student
*
* @param student
* @return list of {@link CommentAttributes}
* @throws EntityDoesNotExistException when the course doesn't exist
*/
public List<CommentAttributes> getCommentsForStudent(StudentAttributes student)
throws EntityDoesNotExistException {
verifyIsCoursePresent(student.course, "get");
List<StudentAttributes> teammates =
studentsLogic.getStudentsForTeam(student.team, student.course);
List<StudentAttributes> studentsInTheSameSection =
studentsLogic.getStudentsForSection(student.section, student.course);
List<String> teammatesEmails = getTeammatesEmails(teammates);
List<String> sectionStudentsEmails = getSectionStudentsEmails(studentsInTheSameSection);
List<String> teamsInThisSection = getTeamsForSection(studentsInTheSameSection);
List<CommentAttributes> comments = new ArrayList<CommentAttributes>();
HashSet<String> commentsVisitedSet = new HashSet<String>();
// Get comments sent to the given student
List<CommentAttributes> commentsForStudent =
getCommentsForReceiver(student.course, CommentParticipantType.PERSON, student.email);
removeNonVisibleCommentsForStudent(commentsForStudent, commentsVisitedSet, comments);
// Get comments visible to the given student's teammates
List<CommentAttributes> commentsForTeam =
getCommentsForCommentViewer(student.course, CommentParticipantType.TEAM);
removeNonVisibleCommentsForTeam(
commentsForTeam, student, teammatesEmails, commentsVisitedSet, comments);
// Get comments visible to the given student's section
List<CommentAttributes> commentsForSection =
getCommentsForCommentViewer(student.course, CommentParticipantType.SECTION);
removeNonVisibleCommentsForSection(
commentsForSection,
student,
teammatesEmails,
sectionStudentsEmails,
teamsInThisSection,
commentsVisitedSet,
comments);
// Get comments visible to the whole course
List<CommentAttributes> commentsForCourse =
getCommentsForCommentViewer(student.course, CommentParticipantType.COURSE);
removeNonVisibleCommentsForCourse(
commentsForCourse,
student,
teammatesEmails,
sectionStudentsEmails,
teamsInThisSection,
commentsVisitedSet,
comments);
java.util.Collections.sort(comments);
return comments;
}
private List<String> getTeamsForSection(List<StudentAttributes> studentsInTheSameSection) {
List<String> teams = new ArrayList<String>();
for (StudentAttributes stu : studentsInTheSameSection) {
teams.add(stu.team);
}
return teams;
}
private List<String> getSectionStudentsEmails(List<StudentAttributes> studentsInTheSameSection) {
List<String> sectionStudentsEmails = new ArrayList<String>();
for (StudentAttributes stu : studentsInTheSameSection) {
sectionStudentsEmails.add(stu.email);
}
return sectionStudentsEmails;
}
private List<String> getTeammatesEmails(List<StudentAttributes> teammates) {
List<String> teammatesEmails = new ArrayList<String>();
for (StudentAttributes teammate : teammates) {
teammatesEmails.add(teammate.email);
}
return teammatesEmails;
}
private void removeNonVisibleCommentsForCourse(
List<CommentAttributes> commentsForCourse,
StudentAttributes student,
List<String> teammates,
List<String> sectionStudentsEmails,
List<String> teamsInThisSection,
HashSet<String> commentsVisitedSet,
List<CommentAttributes> comments) {
removeNonVisibleCommentsForSection(
commentsForCourse,
student,
teammates,
sectionStudentsEmails,
teamsInThisSection,
commentsVisitedSet,
comments);
for (CommentAttributes c : commentsForCourse) {
if (c.courseId.equals(student.course)) {
if (c.recipientType == CommentParticipantType.COURSE) {
removeGiverNameByVisibilityOptions(c, CommentParticipantType.COURSE);
} else {
removeGiverAndRecipientNameByVisibilityOptions(c, CommentParticipantType.COURSE);
}
appendComments(c, comments, commentsVisitedSet);
}
}
}
private void removeNonVisibleCommentsForSection(
List<CommentAttributes> commentsForSection,
StudentAttributes student,
List<String> teammatesEmails,
List<String> sectionStudentsEmails,
List<String> teamsInThisSection,
HashSet<String> commentsVisitedSet,
List<CommentAttributes> comments) {
removeNonVisibleCommentsForTeam(
commentsForSection, student, teammatesEmails, commentsVisitedSet, comments);
for (CommentAttributes c : commentsForSection) {
// for teammates
if (c.recipientType == CommentParticipantType.PERSON
&& isCommentRecipientsWithinGroup(sectionStudentsEmails, c)) {
if (c.showCommentTo.contains(CommentParticipantType.SECTION)) {
removeGiverAndRecipientNameByVisibilityOptions(c, CommentParticipantType.SECTION);
appendComments(c, comments, commentsVisitedSet);
} else {
preventAppendingThisCommentAgain(commentsVisitedSet, c);
}
// for team
} else if (c.recipientType == CommentParticipantType.TEAM
&& isCommentRecipientsWithinGroup(teamsInThisSection, c)) {
if (c.showCommentTo.contains(CommentParticipantType.SECTION)) {
removeGiverNameByVisibilityOptions(c, CommentParticipantType.SECTION);
appendComments(c, comments, commentsVisitedSet);
} else {
preventAppendingThisCommentAgain(commentsVisitedSet, c);
}
// for section
} else if (c.recipientType == CommentParticipantType.SECTION
&& c.recipients.contains(student.section)) {
if (c.showCommentTo.contains(CommentParticipantType.SECTION)) {
removeGiverNameByVisibilityOptions(c, CommentParticipantType.SECTION);
appendComments(c, comments, commentsVisitedSet);
} else {
preventAppendingThisCommentAgain(commentsVisitedSet, c);
}
}
}
}
private void removeNonVisibleCommentsForTeam(
List<CommentAttributes> commentsForTeam,
StudentAttributes student,
List<String> teammates,
HashSet<String> commentsVisitedSet,
List<CommentAttributes> comments) {
for (CommentAttributes c : commentsForTeam) {
// for teammates
if (c.recipientType == CommentParticipantType.PERSON
&& isCommentRecipientsWithinGroup(teammates, c)) {
if (c.showCommentTo.contains(CommentParticipantType.TEAM)) {
removeGiverAndRecipientNameByVisibilityOptions(c, CommentParticipantType.TEAM);
appendComments(c, comments, commentsVisitedSet);
} else {
preventAppendingThisCommentAgain(commentsVisitedSet, c);
}
// for team
} else if (c.recipientType == CommentParticipantType.TEAM
&& c.recipients.contains(Sanitizer.sanitizeForHtml(student.team))) {
if (c.showCommentTo.contains(CommentParticipantType.TEAM)) {
removeGiverNameByVisibilityOptions(c, CommentParticipantType.TEAM);
appendComments(c, comments, commentsVisitedSet);
} else {
preventAppendingThisCommentAgain(commentsVisitedSet, c);
}
}
}
}
private void removeNonVisibleCommentsForStudent(
List<CommentAttributes> commentsForStudent,
HashSet<String> commentsVisitedSet,
List<CommentAttributes> comments) {
for (CommentAttributes c : commentsForStudent) {
if (c.showCommentTo.contains(CommentParticipantType.PERSON)) {
removeGiverNameByVisibilityOptions(c, CommentParticipantType.PERSON);
appendComments(c, comments, commentsVisitedSet);
} else {
preventAppendingThisCommentAgain(commentsVisitedSet, c);
}
}
}
private void removeGiverNameByVisibilityOptions(
CommentAttributes c, CommentParticipantType viewerType) {
if (!c.showGiverNameTo.contains(viewerType)) {
c.giverEmail = "Anonymous";
}
}
private void removeGiverAndRecipientNameByVisibilityOptions(
CommentAttributes c, CommentParticipantType viewerType) {
removeGiverNameByVisibilityOptions(c, viewerType);
if (!c.showRecipientNameTo.contains(viewerType)) {
c.recipients = new HashSet<String>();
c.recipients.add("Anonymous");
}
}
private void appendComments(
CommentAttributes c,
List<CommentAttributes> toThisCommentList,
HashSet<String> commentsVisitedSet) {
if (!commentsVisitedSet.contains(c.getCommentId().toString())) {
toThisCommentList.add(c);
preventAppendingThisCommentAgain(commentsVisitedSet, c);
}
}
private void preventAppendingThisCommentAgain(
HashSet<String> commentsVisitedSet, CommentAttributes c) {
commentsVisitedSet.add(c.getCommentId().toString());
}
private boolean isCommentRecipientsWithinGroup(List<String> group, CommentAttributes c) {
for (String recipient : c.recipients) {
if (group.contains(recipient)) {
return true;
}
}
return false;
}
/** ********** Send Email For Pending Comments *********** */
/**
* Get recipient emails for comments with sending state. When pending comments are cleared,
* they'll become sending comments.
*
* @param courseId
* @return set of emails for recipients who can see the sending comments
* @throws EntityDoesNotExistException when the course doesn't exist
*/
public Set<String> getRecipientEmailsForSendingComments(String courseId)
throws EntityDoesNotExistException {
List<StudentAttributes> allStudents = new StudentsDb().getStudentsForCourse(courseId);
CourseRoster roster =
new CourseRoster(allStudents, new InstructorsDb().getInstructorsForCourse(courseId));
Map<String, List<StudentAttributes>> teamStudentTable =
new HashMap<String, List<StudentAttributes>>();
Map<String, List<StudentAttributes>> sectionStudentTable =
new HashMap<String, List<StudentAttributes>>();
populateTeamSectionStudentTables(allStudents, teamStudentTable, sectionStudentTable);
Set<String> recipientEmailsList =
populateRecipientEmails(
courseId, allStudents, roster, teamStudentTable, sectionStudentTable);
return recipientEmailsList;
}
private Set<String> populateRecipientEmails(
String courseId,
List<StudentAttributes> allStudents,
CourseRoster roster,
Map<String, List<StudentAttributes>> teamStudentTable,
Map<String, List<StudentAttributes>> sectionStudentTable)
throws EntityDoesNotExistException {
Set<String> recipientEmailsList = new HashSet<String>();
List<CommentAttributes> sendingCommentsList =
commentsDb.getCommentsForSendingState(courseId, CommentSendingState.SENDING);
populateRecipientEmailsFromPendingComments(
sendingCommentsList,
allStudents,
roster,
teamStudentTable,
sectionStudentTable,
recipientEmailsList);
List<FeedbackResponseCommentAttributes> sendingResponseCommentsList =
frcLogic.getFeedbackResponseCommentsForSendingState(courseId, CommentSendingState.SENDING);
populateRecipientEmailsFromPendingResponseComments(
sendingResponseCommentsList, allStudents, roster, teamStudentTable, recipientEmailsList);
return recipientEmailsList;
}
private void populateTeamSectionStudentTables(
List<StudentAttributes> allStudents,
Map<String, List<StudentAttributes>> teamStudentTable,
Map<String, List<StudentAttributes>> sectionStudentTable) {
for (StudentAttributes student : allStudents) {
List<StudentAttributes> teammates = teamStudentTable.get(student.team);
if (teammates == null) {
teammates = new ArrayList<StudentAttributes>();
teamStudentTable.put(student.team, teammates);
}
teammates.add(student);
List<StudentAttributes> studentsInTheSameSection = sectionStudentTable.get(student.section);
if (studentsInTheSameSection == null) {
studentsInTheSameSection = new ArrayList<StudentAttributes>();
sectionStudentTable.put(student.section, studentsInTheSameSection);
}
studentsInTheSameSection.add(student);
}
}
/**
* ********** Send Email For Pending Comments : populate recipients emails from Feedback Response
* Comments ***********
*/
private void populateRecipientEmailsFromPendingResponseComments(
List<FeedbackResponseCommentAttributes> sendingResponseCommentsList,
List<StudentAttributes> allStudents,
CourseRoster roster,
Map<String, List<StudentAttributes>> teamStudentTable,
Set<String> recipientEmailsList) {
Map<String, FeedbackQuestionAttributes> feedbackQuestionsTable =
new HashMap<String, FeedbackQuestionAttributes>();
Map<String, FeedbackResponseAttributes> feedbackResponsesTable =
new HashMap<String, FeedbackResponseAttributes>();
Map<String, Set<String>> responseCommentsAddedTable = new HashMap<String, Set<String>>();
for (FeedbackResponseCommentAttributes frc : sendingResponseCommentsList) {
FeedbackQuestionAttributes relatedQuestion = getRelatedQuestion(feedbackQuestionsTable, frc);
FeedbackResponseAttributes relatedResponse = getRelatedResponse(feedbackResponsesTable, frc);
if (relatedQuestion != null && relatedResponse != null) {
populateRecipientEmailsForGiver(
roster,
teamStudentTable,
recipientEmailsList,
responseCommentsAddedTable,
frc,
relatedQuestion,
relatedResponse);
populateRecipientEmailsForReceiver(
roster,
teamStudentTable,
recipientEmailsList,
responseCommentsAddedTable,
frc,
relatedResponse);
populateRecipientEmailsForTeamMember(
roster,
teamStudentTable,
recipientEmailsList,
responseCommentsAddedTable,
frc,
relatedResponse);
populateRecipientEmailsForAllStudents(
allStudents, recipientEmailsList, responseCommentsAddedTable, frc);
}
}
}
private void populateRecipientEmailsForAllStudents(
List<StudentAttributes> allStudents,
Set<String> recipientEmailsList,
Map<String, Set<String>> responseCommentsAddedTable,
FeedbackResponseCommentAttributes frc) {
if (frc.isVisibleTo(FeedbackParticipantType.STUDENTS)) {
for (StudentAttributes student : allStudents) {
addRecipientEmailsToList(
responseCommentsAddedTable, recipientEmailsList, frc.getId().toString(), student.email);
}
}
}
private void populateRecipientEmailsForTeamMember(
CourseRoster roster,
Map<String, List<StudentAttributes>> teamStudentTable,
Set<String> recipientEmailsList,
Map<String, Set<String>> responseCommentsAddedTable,
FeedbackResponseCommentAttributes frc,
FeedbackResponseAttributes relatedResponse) {
if (frc.isVisibleTo(FeedbackParticipantType.RECEIVER_TEAM_MEMBERS)) {
StudentAttributes studentOfThisEmail = roster.getStudentForEmail(relatedResponse.recipient);
if (studentOfThisEmail == null) {
addRecipientEmailsForTeam(
teamStudentTable,
recipientEmailsList,
responseCommentsAddedTable,
frc.getId().toString(),
relatedResponse.recipient);
} else {
addRecipientEmailsForTeam(
teamStudentTable,
recipientEmailsList,
responseCommentsAddedTable,
frc.getId().toString(),
studentOfThisEmail.team);
}
}
}
private void populateRecipientEmailsForReceiver(
CourseRoster roster,
Map<String, List<StudentAttributes>> teamStudentTable,
Set<String> recipientEmailsList,
Map<String, Set<String>> responseCommentsAddedTable,
FeedbackResponseCommentAttributes frc,
FeedbackResponseAttributes relatedResponse) {
if (frc.isVisibleTo(FeedbackParticipantType.RECEIVER)) {
// recipientEmail is email
if (roster.getStudentForEmail(relatedResponse.recipient) == null) {
addRecipientEmailsForTeam(
teamStudentTable,
recipientEmailsList,
responseCommentsAddedTable,
frc.getId().toString(),
relatedResponse.recipient);
} else {
addRecipientEmailsToList(
responseCommentsAddedTable,
recipientEmailsList,
frc.getId().toString(),
relatedResponse.recipient);
}
}
}
private void populateRecipientEmailsForGiver(
CourseRoster roster,
Map<String, List<StudentAttributes>> teamStudentTable,
Set<String> recipientEmailsList,
Map<String, Set<String>> responseCommentsAddedTable,
FeedbackResponseCommentAttributes frc,
FeedbackQuestionAttributes relatedQuestion,
FeedbackResponseAttributes relatedResponse) {
StudentAttributes giver = roster.getStudentForEmail(relatedResponse.giver);
if (giver == null) {
return;
}
if (frc.isVisibleTo(FeedbackParticipantType.GIVER)) {
addRecipientEmailsToList(
responseCommentsAddedTable,
recipientEmailsList,
frc.getId().toString(),
relatedResponse.giver);
}
if (relatedQuestion.giverType == FeedbackParticipantType.TEAMS
|| frc.isVisibleTo(FeedbackParticipantType.OWN_TEAM_MEMBERS)) {
addRecipientEmailsForTeam(
teamStudentTable,
recipientEmailsList,
responseCommentsAddedTable,
frc.getId().toString(),
giver.team);
}
}
private FeedbackResponseAttributes getRelatedResponse(
Map<String, FeedbackResponseAttributes> feedbackResponsesTable,
FeedbackResponseCommentAttributes frc) {
FeedbackResponseAttributes relatedResponse = feedbackResponsesTable.get(frc.feedbackResponseId);
if (relatedResponse == null) {
relatedResponse = frLogic.getFeedbackResponse(frc.feedbackResponseId);
feedbackResponsesTable.put(frc.feedbackResponseId, relatedResponse);
}
return relatedResponse;
}
private FeedbackQuestionAttributes getRelatedQuestion(
Map<String, FeedbackQuestionAttributes> feedbackQuestionsTable,
FeedbackResponseCommentAttributes frc) {
FeedbackQuestionAttributes relatedQuestion = feedbackQuestionsTable.get(frc.feedbackQuestionId);
if (relatedQuestion == null) {
relatedQuestion = fqLogic.getFeedbackQuestion(frc.feedbackQuestionId);
feedbackQuestionsTable.put(frc.feedbackQuestionId, relatedQuestion);
}
return relatedQuestion;
}
/**
* ********** Send Email For Pending Comments : populate recipients emails from Student Comments
* ***********
*/
private void populateRecipientEmailsFromPendingComments(
List<CommentAttributes> sendingCommentsList,
List<StudentAttributes> allStudents,
CourseRoster roster,
Map<String, List<StudentAttributes>> teamStudentTable,
Map<String, List<StudentAttributes>> sectionStudentTable,
Set<String> recipientEmailList) {
Map<String, Set<String>> studentCommentsAddedTable = new HashMap<String, Set<String>>();
for (CommentAttributes pendingComment : sendingCommentsList) {
populateRecipientEmailsForPerson(
recipientEmailList, studentCommentsAddedTable, pendingComment);
populateRecipientEmailsForTeam(
recipientEmailList, roster, teamStudentTable, studentCommentsAddedTable, pendingComment);
populateRecipientEmailsForSection(
recipientEmailList,
roster,
teamStudentTable,
sectionStudentTable,
studentCommentsAddedTable,
pendingComment);
populateRecipientEmailsForCourse(
recipientEmailList, allStudents,
studentCommentsAddedTable, pendingComment);
}
}
private void populateRecipientEmailsForCourse(
Set<String> recipientEmailList,
List<StudentAttributes> allStudents,
Map<String, Set<String>> studentCommentsAddedTable,
CommentAttributes pendingComment) {
if (pendingComment.isVisibleTo(CommentParticipantType.COURSE)) {
for (StudentAttributes student : allStudents) {
addRecipientEmailsToList(
studentCommentsAddedTable,
recipientEmailList,
pendingComment.getCommentId().toString(),
student.email);
}
}
}
private void populateRecipientEmailsForSection(
Set<String> recipientEmailList,
CourseRoster roster,
Map<String, List<StudentAttributes>> teamStudentTable,
Map<String, List<StudentAttributes>> sectionStudentTable,
Map<String, Set<String>> studentCommentsAddedTable,
CommentAttributes pendingComment) {
String commentId = pendingComment.getCommentId().toString();
if (pendingComment.isVisibleTo(CommentParticipantType.SECTION)) {
if (pendingComment.recipientType == CommentParticipantType.PERSON) {
for (String recipientEmail : pendingComment.recipients) {
StudentAttributes student = roster.getStudentForEmail(recipientEmail);
if (student == null) {
continue;
}
addRecipientEmailsForSection(
sectionStudentTable,
recipientEmailList,
studentCommentsAddedTable,
commentId,
student.section);
}
} else if (pendingComment.recipientType == CommentParticipantType.TEAM) {
for (String team : pendingComment.recipients) {
List<StudentAttributes> students = teamStudentTable.get(team);
if (students == null) {
continue;
}
for (StudentAttributes stu : students) {
addRecipientEmailsForSection(
sectionStudentTable,
recipientEmailList,
studentCommentsAddedTable,
commentId,
stu.section);
}
}
} else if (pendingComment.recipientType == CommentParticipantType.SECTION) {
for (String section : pendingComment.recipients) {
addRecipientEmailsForSection(
sectionStudentTable,
recipientEmailList,
studentCommentsAddedTable,
commentId,
section);
}
}
} else { // not visible to SECTION
if (pendingComment.recipientType == CommentParticipantType.PERSON) {
for (String recipientEmail : pendingComment.recipients) {
StudentAttributes student = roster.getStudentForEmail(recipientEmail);
if (student == null) {
continue;
}
preventAddRecipientEmailsForSection(
teamStudentTable, studentCommentsAddedTable, commentId, student.section);
}
} else if (pendingComment.recipientType == CommentParticipantType.TEAM) {
for (String team : pendingComment.recipients) {
List<StudentAttributes> students = teamStudentTable.get(team);
if (students == null) {
continue;
}
for (StudentAttributes stu : students) {
preventAddRecipientEmailsForSection(
teamStudentTable, studentCommentsAddedTable, commentId, stu.section);
}
}
} else if (pendingComment.recipientType == CommentParticipantType.SECTION) {
for (String section : pendingComment.recipients) {
preventAddRecipientEmailsForSection(
teamStudentTable, studentCommentsAddedTable,
commentId, section);
}
}
}
}
private void populateRecipientEmailsForTeam(
Set<String> recipientEmailList,
CourseRoster roster,
Map<String, List<StudentAttributes>> teamStudentTable,
Map<String, Set<String>> studentCommentsAddedTable,
CommentAttributes pendingComment) {
String commentId = pendingComment.getCommentId().toString();
if (pendingComment.isVisibleTo(CommentParticipantType.TEAM)) {
if (pendingComment.recipientType == CommentParticipantType.PERSON) {
for (String recipientEmail : pendingComment.recipients) {
StudentAttributes student = roster.getStudentForEmail(recipientEmail);
if (student == null) {
continue;
}
addRecipientEmailsForTeam(
teamStudentTable,
recipientEmailList,
studentCommentsAddedTable,
commentId,
student.team);
}
} else if (pendingComment.recipientType == CommentParticipantType.TEAM) {
for (String team : pendingComment.recipients) {
addRecipientEmailsForTeam(
teamStudentTable, recipientEmailList, studentCommentsAddedTable, commentId, team);
}
}
} else { // not visible to TEAM
if (pendingComment.recipientType == CommentParticipantType.PERSON) {
for (String recipientEmail : pendingComment.recipients) {
StudentAttributes student = roster.getStudentForEmail(recipientEmail);
if (student == null) {
continue;
}
preventAddRecipientEmailsForTeam(
teamStudentTable, studentCommentsAddedTable, commentId, student.team);
}
} else if (pendingComment.recipientType == CommentParticipantType.TEAM) {
for (String team : pendingComment.recipients) {
preventAddRecipientEmailsForTeam(
teamStudentTable, studentCommentsAddedTable,
commentId, team);
}
}
}
}
private void populateRecipientEmailsForPerson(
Set<String> recipientEmailList,
Map<String, Set<String>> studentCommentsAddedTable,
CommentAttributes pendingComment) {
String commentId = pendingComment.getCommentId().toString();
if (pendingComment.isVisibleTo(CommentParticipantType.PERSON)) {
for (String recipientEmail : pendingComment.recipients) {
addRecipientEmailsToList(
studentCommentsAddedTable, recipientEmailList,
commentId, recipientEmail);
}
} else { // not visible to PERSON
for (String recipientEmail : pendingComment.recipients) {
preventAddRecipientEmailsToList(studentCommentsAddedTable, commentId, recipientEmail);
}
}
}
private void addRecipientEmailsToList(
Map<String, Set<String>> isAddedTable, Set<String> targetTable, String subKey, String key) {
// prevent re-entry
Set<String> commentIdsSet = isAddedTable.get(key);
if (commentIdsSet == null) {
commentIdsSet = new HashSet<String>();
isAddedTable.put(key, commentIdsSet);
}
if (!commentIdsSet.contains(subKey)) {
commentIdsSet.add(subKey);
targetTable.add(key);
}
}
private void addRecipientEmailsForSection(
Map<String, List<StudentAttributes>> sectionStudentTable,
Set<String> recipientEmailsList,
Map<String, Set<String>> responseCommentsAddedTable,
String commentId,
String sectionName) {
List<StudentAttributes> students = sectionStudentTable.get(sectionName);
if (students == null) {
return;
}
for (StudentAttributes stu : students) {
addRecipientEmailsToList(
responseCommentsAddedTable, recipientEmailsList, commentId, stu.email);
}
}
private void addRecipientEmailsForTeam(
Map<String, List<StudentAttributes>> teamStudentTable,
Set<String> recipientEmailsList,
Map<String, Set<String>> responseCommentsAddedTable,
String commentId,
String teamName) {
List<StudentAttributes> students = teamStudentTable.get(teamName);
if (students == null) {
return;
}
for (StudentAttributes stu : students) {
addRecipientEmailsToList(
responseCommentsAddedTable, recipientEmailsList, commentId, stu.email);
}
}
private void preventAddRecipientEmailsToList(
Map<String, Set<String>> isAddedTable, String subKey, String key) {
Set<String> commentIdsSet = isAddedTable.get(key);
if (commentIdsSet == null) {
commentIdsSet = new HashSet<String>();
isAddedTable.put(key, commentIdsSet);
}
commentIdsSet.add(subKey);
}
private void preventAddRecipientEmailsForSection(
Map<String, List<StudentAttributes>> sectionStudentTable,
Map<String, Set<String>> isAddedTable,
String commentId,
String section) {
List<StudentAttributes> students = sectionStudentTable.get(section);
if (students == null) {
return;
}
for (StudentAttributes stu : students) {
preventAddRecipientEmailsToList(isAddedTable, commentId, stu.email);
}
}
private void preventAddRecipientEmailsForTeam(
Map<String, List<StudentAttributes>> teamStudentTable,
Map<String, Set<String>> isAddedTable,
String commentId,
String team) {
List<StudentAttributes> teammates = teamStudentTable.get(team);
if (teammates == null) {
return;
}
for (StudentAttributes teamMember : teammates) {
preventAddRecipientEmailsToList(isAddedTable, commentId, teamMember.email);
}
}
@SuppressWarnings("deprecation")
public List<CommentAttributes> getAllComments() {
return commentsDb.getAllComments();
}
/**
* Sends notifications to students in course {@code courseId} who have received comments and not
* yet been notified.
*/
public void sendCommentNotification(String courseId) {
Map<String, String> paramMap = new HashMap<String, String>();
paramMap.put(Const.ParamsNames.EMAIL_COURSE, courseId);
paramMap.put(Const.ParamsNames.EMAIL_TYPE, EmailType.PENDING_COMMENT_CLEARED.toString());
TaskQueuesLogic taskQueueLogic = TaskQueuesLogic.inst();
taskQueueLogic.createAndAddTask(
Const.SystemParams.EMAIL_TASK_QUEUE, Const.ActionURIs.EMAIL_WORKER, paramMap);
}
}
@Override
public String getJsonString() {
return Utils.getTeammatesGson().toJson(this, StudentProfileAttributes.class);
}
public class FeedbackRubricResponseDetails extends FeedbackResponseDetails {
private static final Logger log = Utils.getLogger();
/**
* List of integers, the size of the list corresponds to the number of sub-questions Each integer
* at index i, represents the choice chosen for sub-question i
*/
public List<Integer> answer;
public FeedbackRubricResponseDetails() {
super(FeedbackQuestionType.RUBRIC);
}
@Override
public void extractResponseDetails(
FeedbackQuestionType questionType, FeedbackQuestionDetails questionDetails, String[] answer) {
/**
* Example: a response in the form: "0-1,1-0" means that for sub-question 0, choice 1 is chosen,
* and for sub-question 1, choice 0 is chosen.
*/
String rawResponses = answer[0];
FeedbackRubricQuestionDetails fqd = (FeedbackRubricQuestionDetails) questionDetails;
initializeEmptyAnswerList(fqd.getNumOfRubricSubQuestions());
// Parse and extract answers
String[] subQuestionResponses = rawResponses.split(Pattern.quote(","));
for (String subQuestionResponse : subQuestionResponses) {
String[] subQuestionIndexAndChoice = subQuestionResponse.split(Pattern.quote("-"));
if (subQuestionIndexAndChoice.length != 2) {
// Expected length is 2.
// Failed to parse, ignore response.
continue;
}
try {
int subQuestionIndex = Integer.parseInt(subQuestionIndexAndChoice[0]);
int subQuestionChoice = Integer.parseInt(subQuestionIndexAndChoice[1]);
if (subQuestionIndex >= 0
&& subQuestionIndex < fqd.getNumOfRubricSubQuestions()
&& subQuestionChoice >= 0
&& subQuestionChoice < fqd.getNumOfRubricChoices()) {
setAnswer(subQuestionIndex, subQuestionChoice);
} // else the indexes are invalid.
} catch (NumberFormatException e) {
// Failed to parse, ignore response.
log.warning(TeammatesException.toStringWithStackTrace(e));
}
}
}
/**
* Initializes the answer list to have empty responses -1 indicates no choice chosen
*
* @param numSubQuestions
*/
private void initializeEmptyAnswerList(int numSubQuestions) {
answer = new ArrayList<Integer>();
for (int i = 0; i < numSubQuestions; i++) {
answer.add(-1);
}
}
@Override
public String getAnswerString() {
return this.answer.toString();
}
@Override
public String getAnswerHtml(FeedbackQuestionDetails questionDetails) {
FeedbackRubricQuestionDetails fqd = (FeedbackRubricQuestionDetails) questionDetails;
StringBuilder html = new StringBuilder(100);
for (int i = 0; i < answer.size(); i++) {
int chosenIndex = answer.get(i);
String chosenChoice = "";
if (chosenIndex == -1) {
chosenChoice =
"<span class=\"color_neutral\"><i>"
+ Const.INSTRUCTOR_FEEDBACK_RESULTS_MISSING_RESPONSE
+ "</i></span>";
html.append(
StringHelper.integerToLowerCaseAlphabeticalIndex(i + 1) + ") " + chosenChoice + "<br>");
} else {
chosenChoice = Sanitizer.sanitizeForHtml(fqd.getRubricChoices().get(answer.get(i)));
html.append(
StringHelper.integerToLowerCaseAlphabeticalIndex(i + 1)
+ ") "
+ chosenChoice
+ " <span class=\"color_neutral\"><i>(Choice "
+ (chosenIndex + 1)
+ ")</i></span><br>");
}
}
return html.toString();
}
@Override
public String getAnswerCsv(FeedbackQuestionDetails questionDetails) {
return answer.toString();
}
public int getAnswer(int subQuestionIndex) {
return answer.get(subQuestionIndex);
}
public void setAnswer(int subQuestionIndex, int choice) {
this.answer.set(subQuestionIndex, choice);
}
}
public class FeedbackResponsesLogic {
private static final Logger log = Utils.getLogger();
private static FeedbackResponsesLogic instance = null;
private static final StudentsLogic studentsLogic = StudentsLogic.inst();
private static final FeedbackQuestionsLogic fqLogic = FeedbackQuestionsLogic.inst();
private static final FeedbackResponseCommentsLogic frcLogic =
FeedbackResponseCommentsLogic.inst();
private static final FeedbackResponsesDb frDb = new FeedbackResponsesDb();
public static FeedbackResponsesLogic inst() {
if (instance == null) instance = new FeedbackResponsesLogic();
return instance;
}
public void createFeedbackResponse(FeedbackResponseAttributes fra)
throws InvalidParametersException {
try {
frDb.createEntity(fra);
} catch (Exception EntityAlreadyExistsException) {
try {
FeedbackResponseAttributes existingFeedback = new FeedbackResponseAttributes();
existingFeedback =
frDb.getFeedbackResponse(fra.feedbackQuestionId, fra.giverEmail, fra.recipientEmail);
fra.setId(existingFeedback.getId());
frDb.updateFeedbackResponse(fra);
} catch (Exception EntityDoesNotExistException) {
Assumption.fail();
}
}
}
public FeedbackResponseAttributes getFeedbackResponse(String feedbackResponseId) {
return frDb.getFeedbackResponse(feedbackResponseId);
}
public FeedbackResponseAttributes getFeedbackResponse(
String feedbackQuestionId, String giverEmail, String recipient) {
// TODO: check what is this line doing here!!!
log.warning(feedbackQuestionId);
return frDb.getFeedbackResponse(feedbackQuestionId, giverEmail, recipient);
}
public List<FeedbackResponseAttributes> getFeedbackResponsesForSession(
String feedbackSessionName, String courseId) {
return frDb.getFeedbackResponsesForSession(feedbackSessionName, courseId);
}
public List<FeedbackResponseAttributes> getFeedbackResponsesForSessionInSection(
String feedbackSessionName, String courseId, String section) {
if (section == null) {
return getFeedbackResponsesForSession(feedbackSessionName, courseId);
} else {
return frDb.getFeedbackResponsesForSessionInSection(feedbackSessionName, courseId, section);
}
}
public List<FeedbackResponseAttributes> getFeedbackResponsesForSessionFromSection(
String feedbackSessionName, String courseId, String section) {
if (section == null) {
return getFeedbackResponsesForSession(feedbackSessionName, courseId);
} else {
return frDb.getFeedbackResponsesForSessionFromSection(feedbackSessionName, courseId, section);
}
}
public List<FeedbackResponseAttributes> getFeedbackResponsesForSessionToSection(
String feedbackSessionName, String courseId, String section) {
if (section == null) {
return getFeedbackResponsesForSession(feedbackSessionName, courseId);
} else {
return frDb.getFeedbackResponsesForSessionToSection(feedbackSessionName, courseId, section);
}
}
public List<FeedbackResponseAttributes> getFeedbackResponsesForSessionWithinRange(
String feedbackSessionName, String courseId, long range) {
return frDb.getFeedbackResponsesForSessionWithinRange(feedbackSessionName, courseId, range);
}
public List<FeedbackResponseAttributes> getFeedbackResponsesForSessionInSectionWithinRange(
String feedbackSessionName, String courseId, String section, long range) {
if (section == null) {
return getFeedbackResponsesForSessionWithinRange(feedbackSessionName, courseId, range);
} else {
return frDb.getFeedbackResponsesForSessionInSectionWithinRange(
feedbackSessionName, courseId, section, range);
}
}
public List<FeedbackResponseAttributes> getFeedbackResponsesForSessionFromSectionWithinRange(
String feedbackSessionName, String courseId, String section, long range) {
if (section == null) {
return getFeedbackResponsesForSessionWithinRange(feedbackSessionName, courseId, range);
} else {
return frDb.getFeedbackResponsesForSessionFromSectionWithinRange(
feedbackSessionName, courseId, section, range);
}
}
public List<FeedbackResponseAttributes> getFeedbackResponsesForSessionToSectionWithinRange(
String feedbackSessionName, String courseId, String section, long range) {
if (section == null) {
return getFeedbackResponsesForSessionWithinRange(feedbackSessionName, courseId, range);
} else {
return frDb.getFeedbackResponsesForSessionToSectionWithinRange(
feedbackSessionName, courseId, section, range);
}
}
public List<FeedbackResponseAttributes> getFeedbackResponsesForQuestion(
String feedbackQuestionId) {
return frDb.getFeedbackResponsesForQuestion(feedbackQuestionId);
}
public List<FeedbackResponseAttributes> getFeedbackResponsesForQuestionWithinRange(
String feedbackQuestionId, long range) {
return frDb.getFeedbackResponsesForQuestionWithinRange(feedbackQuestionId, range);
}
public List<FeedbackResponseAttributes> getFeedbackResponsesForQuestionInSection(
String feedbackQuestionId, String section) {
if (section == null) {
return getFeedbackResponsesForQuestion(feedbackQuestionId);
}
return frDb.getFeedbackResponsesForQuestionInSection(feedbackQuestionId, section);
}
public List<FeedbackResponseAttributes> getFeedbackResponsesForReceiverForQuestion(
String feedbackQuestionId, String userEmail) {
return frDb.getFeedbackResponsesForReceiverForQuestion(feedbackQuestionId, userEmail);
}
public List<FeedbackResponseAttributes> getFeedbackResponsesForReceiverForQuestionInSection(
String feedbackQuestionId, String userEmail, String section) {
if (section == null) {
return getFeedbackResponsesForReceiverForQuestion(feedbackQuestionId, userEmail);
}
return frDb.getFeedbackResponsesForReceiverForQuestionInSection(
feedbackQuestionId, userEmail, section);
}
public List<FeedbackResponseAttributes> getFeedbackResponsesFromGiverForQuestion(
String feedbackQuestionId, String userEmail) {
return frDb.getFeedbackResponsesFromGiverForQuestion(feedbackQuestionId, userEmail);
}
public List<FeedbackResponseAttributes> getFeedbackResponsesFromGiverForQuestionInSection(
String feedbackQuestionId, String userEmail, String section) {
if (section == null) {
return getFeedbackResponsesFromGiverForQuestion(feedbackQuestionId, userEmail);
}
return frDb.getFeedbackResponsesFromGiverForQuestionInSection(
feedbackQuestionId, userEmail, section);
}
public List<FeedbackResponseAttributes> getFeedbackResponsesForReceiverForCourse(
String courseId, String userEmail) {
return frDb.getFeedbackResponsesForReceiverForCourse(courseId, userEmail);
}
public List<FeedbackResponseAttributes> getFeedbackResponsesFromGiverForCourse(
String courseId, String userEmail) {
return frDb.getFeedbackResponsesFromGiverForCourse(courseId, userEmail);
}
/** Get existing feedback responses from student or his team for the given question. */
public List<FeedbackResponseAttributes> getFeedbackResponsesFromStudentOrTeamForQuestion(
FeedbackQuestionAttributes question, StudentAttributes student) {
if (question.giverType == FeedbackParticipantType.TEAMS) {
return getFeedbackResponsesFromTeamForQuestion(
question.getId(), question.courseId, student.team);
} else {
return frDb.getFeedbackResponsesFromGiverForQuestion(question.getId(), student.email);
}
}
public List<FeedbackResponseAttributes> getViewableFeedbackResponsesForQuestionInSection(
FeedbackQuestionAttributes question, String userEmail, UserType.Role role, String section)
throws EntityDoesNotExistException {
List<FeedbackResponseAttributes> viewableResponses =
new ArrayList<FeedbackResponseAttributes>();
// Add responses that the user submitted himself
addNewResponses(
viewableResponses,
getFeedbackResponsesFromGiverForQuestionInSection(question.getId(), userEmail, section));
// Add responses that user is a receiver of when question is visible to
// receiver.
if (question.isResponseVisibleTo(FeedbackParticipantType.RECEIVER)) {
addNewResponses(
viewableResponses,
getFeedbackResponsesForReceiverForQuestionInSection(
question.getId(), userEmail, section));
}
switch (role) {
case STUDENT:
addNewResponses(
viewableResponses,
// many queries
getViewableFeedbackResponsesForStudentForQuestion(question, userEmail));
break;
case INSTRUCTOR:
if (question.isResponseVisibleTo(FeedbackParticipantType.INSTRUCTORS)) {
addNewResponses(
viewableResponses,
getFeedbackResponsesForQuestionInSection(question.getId(), section));
}
break;
default:
Assumption.fail("The role of the requesting use has to be Student or Instructor");
}
return viewableResponses;
}
public boolean isNameVisibleTo(
FeedbackQuestionAttributes question,
FeedbackResponseAttributes response,
String userEmail,
UserType.Role role,
boolean isGiverName,
CourseRoster roster) {
if (question == null) {
return false;
}
List<FeedbackParticipantType> showNameTo =
isGiverName ? question.showGiverNameTo : question.showRecipientNameTo;
// Giver can always see giver and recipient.(because he answered.)
if (response.giverEmail.equals(userEmail)) {
return true;
}
for (FeedbackParticipantType type : showNameTo) {
switch (type) {
case INSTRUCTORS:
if (roster.getInstructorForEmail(userEmail) != null && role == UserType.Role.INSTRUCTOR) {
return true;
} else {
break;
}
case OWN_TEAM_MEMBERS:
case OWN_TEAM_MEMBERS_INCLUDING_SELF:
// Refers to Giver's Team Members
if (roster.isStudentsInSameTeam(response.giverEmail, userEmail)) {
return true;
} else {
break;
}
case RECEIVER:
// Response to team
if (question.recipientType == FeedbackParticipantType.TEAMS) {
if (roster.isStudentInTeam(
userEmail, /* this is a team name */ response.recipientEmail)) {
return true;
}
// Response to individual
} else if (response.recipientEmail.equals(userEmail)) {
return true;
} else {
break;
}
case RECEIVER_TEAM_MEMBERS:
// Response to team; recipient = teamName
if (question.recipientType == FeedbackParticipantType.TEAMS) {
if (roster.isStudentInTeam(
userEmail, /* this is a team name */ response.recipientEmail)) {
return true;
}
// Response to individual
} else if (roster.isStudentsInSameTeam(response.recipientEmail, userEmail)) {
return true;
} else {
break;
}
case STUDENTS:
if (roster.isStudentInCourse(userEmail)) {
return true;
} else {
break;
}
default:
Assumption.fail(
"Invalid FeedbackPariticipantType for showNameTo in "
+ "FeedbackResponseLogic.isNameVisible()");
break;
}
}
return false;
}
/**
* Updates a {@link FeedbackResponse} based on it's {@code id}.<br>
* If the giver/recipient field is changed, the {@link FeedbackResponse} is updated by recreating
* the response<br>
* in order to prevent an id clash if the previous email is reused later on.
*/
public void updateFeedbackResponse(FeedbackResponseAttributes responseToUpdate)
throws InvalidParametersException, EntityDoesNotExistException, EntityAlreadyExistsException {
// Create a copy.
FeedbackResponseAttributes newResponse = new FeedbackResponseAttributes(responseToUpdate);
FeedbackResponseAttributes oldResponse = null;
if (newResponse.getId() == null) {
oldResponse =
frDb.getFeedbackResponse(
newResponse.feedbackQuestionId, newResponse.giverEmail, newResponse.recipientEmail);
} else {
oldResponse = frDb.getFeedbackResponse(newResponse.getId());
}
if (oldResponse == null) {
throw new EntityDoesNotExistException(
"Trying to update a feedback response that does not exist.");
}
// Copy values that cannot be changed to defensively avoid invalid
// parameters.
newResponse.courseId = oldResponse.courseId;
newResponse.feedbackSessionName = oldResponse.feedbackSessionName;
newResponse.feedbackQuestionId = oldResponse.feedbackQuestionId;
newResponse.feedbackQuestionType = oldResponse.feedbackQuestionType;
if (newResponse.responseMetaData == null) {
newResponse.responseMetaData = oldResponse.responseMetaData;
}
if (newResponse.giverEmail == null) {
newResponse.giverEmail = oldResponse.giverEmail;
}
if (newResponse.recipientEmail == null) {
newResponse.recipientEmail = oldResponse.recipientEmail;
}
if (newResponse.giverSection == null) {
newResponse.giverSection = oldResponse.giverSection;
}
if (newResponse.recipientSection == null) {
newResponse.recipientSection = oldResponse.recipientSection;
}
if (!newResponse.recipientEmail.equals(oldResponse.recipientEmail)
|| !newResponse.giverEmail.equals(oldResponse.giverEmail)) {
// Recreate response to prevent possible future id conflict.
try {
newResponse.setId(null);
frDb.createEntity(newResponse);
frDb.deleteEntity(oldResponse);
} catch (EntityAlreadyExistsException e) {
log.warning("Trying to update an existing response to one that already exists.");
throw new EntityAlreadyExistsException(
e.getMessage()
+ Const.EOL
+ "Trying to update recipient for response to one that already exists for this giver.");
}
} else {
frDb.updateFeedbackResponse(newResponse);
}
}
/**
* Updates responses for a student when his team changes. This is done by deleting responses that
* are no longer relevant to him in his new team.
*/
public void updateFeedbackResponsesForChangingTeam(
String courseId, String userEmail, String oldTeam, String newTeam)
throws EntityDoesNotExistException {
FeedbackQuestionAttributes question;
List<FeedbackResponseAttributes> responsesFromUser =
getFeedbackResponsesFromGiverForCourse(courseId, userEmail);
for (FeedbackResponseAttributes response : responsesFromUser) {
question = fqLogic.getFeedbackQuestion(response.feedbackQuestionId);
if (question.giverType == FeedbackParticipantType.TEAMS
|| question.recipientType == FeedbackParticipantType.OWN_TEAM_MEMBERS
|| question.recipientType == FeedbackParticipantType.OWN_TEAM_MEMBERS_INCLUDING_SELF) {
frDb.deleteEntity(response);
}
}
List<FeedbackResponseAttributes> responsesToUser =
getFeedbackResponsesForReceiverForCourse(courseId, userEmail);
for (FeedbackResponseAttributes response : responsesToUser) {
question = fqLogic.getFeedbackQuestion(response.feedbackQuestionId);
if (question.recipientType == FeedbackParticipantType.OWN_TEAM_MEMBERS
|| question.recipientType == FeedbackParticipantType.OWN_TEAM_MEMBERS_INCLUDING_SELF) {
frDb.deleteEntity(response);
}
}
if (studentsLogic.getStudentsForTeam(oldTeam, courseId).isEmpty()) {
List<FeedbackResponseAttributes> responsesToTeam =
getFeedbackResponsesForReceiverForCourse(courseId, oldTeam);
for (FeedbackResponseAttributes response : responsesToTeam) {
frDb.deleteEntity(response);
}
}
}
public void updateFeedbackResponsesForChangingSection(
String courseId, String userEmail, String oldSection, String newSection)
throws EntityDoesNotExistException, InvalidParametersException {
List<FeedbackResponseAttributes> responsesFromUser =
getFeedbackResponsesFromGiverForCourse(courseId, userEmail);
for (FeedbackResponseAttributes response : responsesFromUser) {
response.giverSection = newSection;
frDb.updateFeedbackResponse(response);
frcLogic.updateFeedbackResponseCommentsForResponse(response.getId());
}
List<FeedbackResponseAttributes> responsesToUser =
getFeedbackResponsesForReceiverForCourse(courseId, userEmail);
for (FeedbackResponseAttributes response : responsesToUser) {
response.recipientSection = newSection;
frDb.updateFeedbackResponse(response);
frcLogic.updateFeedbackResponseCommentsForResponse(response.getId());
}
}
public boolean updateFeedbackResponseForChangingTeam(
StudentEnrollDetails enrollment, FeedbackResponseAttributes response) {
FeedbackQuestionAttributes question = fqLogic.getFeedbackQuestion(response.feedbackQuestionId);
boolean isGiverSameForResponseAndEnrollment = response.giverEmail.equals(enrollment.email);
boolean isReceiverSameForResponseAndEnrollment =
response.recipientEmail.equals(enrollment.email);
boolean shouldDeleteByChangeOfGiver =
(isGiverSameForResponseAndEnrollment
&& (question.giverType == FeedbackParticipantType.TEAMS
|| question.recipientType == FeedbackParticipantType.OWN_TEAM_MEMBERS));
boolean shouldDeleteByChangeOfRecipient =
(isReceiverSameForResponseAndEnrollment
&& question.recipientType == FeedbackParticipantType.OWN_TEAM_MEMBERS);
boolean shouldDeleteResponse = shouldDeleteByChangeOfGiver || shouldDeleteByChangeOfRecipient;
if (shouldDeleteResponse) {
frDb.deleteEntity(response);
}
return shouldDeleteResponse;
}
public void updateFeedbackResponseForChangingSection(
StudentEnrollDetails enrollment, FeedbackResponseAttributes response)
throws InvalidParametersException, EntityDoesNotExistException {
FeedbackResponse feedbackResponse = frDb.getFeedbackResponseEntityOptimized(response);
boolean isGiverSameForResponseAndEnrollment =
feedbackResponse.getGiverEmail().equals(enrollment.email);
boolean isReceiverSameForResponseAndEnrollment =
feedbackResponse.getRecipientEmail().equals(enrollment.email);
if (isGiverSameForResponseAndEnrollment) {
feedbackResponse.setGiverSection(enrollment.newSection);
}
if (isReceiverSameForResponseAndEnrollment) {
feedbackResponse.setRecipientSection(enrollment.newSection);
}
frDb.commitOutstandingChanges();
if (isGiverSameForResponseAndEnrollment || isReceiverSameForResponseAndEnrollment) {
frcLogic.updateFeedbackResponseCommentsForResponse(response.getId());
}
}
/** Updates responses for a student when his email changes. */
// TODO: cascade the update to response comments
public void updateFeedbackResponsesForChangingEmail(
String courseId, String oldEmail, String newEmail)
throws InvalidParametersException, EntityDoesNotExistException {
List<FeedbackResponseAttributes> responsesFromUser =
getFeedbackResponsesFromGiverForCourse(courseId, oldEmail);
for (FeedbackResponseAttributes response : responsesFromUser) {
response.giverEmail = newEmail;
try {
updateFeedbackResponse(response);
} catch (EntityAlreadyExistsException e) {
Assumption.fail(
"Feedback response failed to update successfully" + "as email was already in use.");
}
}
List<FeedbackResponseAttributes> responsesToUser =
getFeedbackResponsesForReceiverForCourse(courseId, oldEmail);
for (FeedbackResponseAttributes response : responsesToUser) {
response.recipientEmail = newEmail;
try {
updateFeedbackResponse(response);
} catch (EntityAlreadyExistsException e) {
Assumption.fail(
"Feedback response failed to update successfully" + "as email was already in use.");
}
}
}
public void deleteFeedbackResponseAndCascade(FeedbackResponseAttributes responseToDelete) {
frcLogic.deleteFeedbackResponseCommentsForResponse(responseToDelete.getId());
frDb.deleteEntity(responseToDelete);
}
public void deleteFeedbackResponsesForQuestionAndCascade(String feedbackQuestionId) {
List<FeedbackResponseAttributes> responsesForQuestion =
getFeedbackResponsesForQuestion(feedbackQuestionId);
for (FeedbackResponseAttributes response : responsesForQuestion) {
this.deleteFeedbackResponseAndCascade(response);
}
}
public void deleteFeedbackResponsesForStudentAndCascade(String courseId, String studentEmail) {
String studentTeam = "";
StudentAttributes student = studentsLogic.getStudentForEmail(courseId, studentEmail);
if (student != null) {
studentTeam = student.team;
}
List<FeedbackResponseAttributes> responses =
getFeedbackResponsesFromGiverForCourse(courseId, studentEmail);
responses.addAll(getFeedbackResponsesForReceiverForCourse(courseId, studentEmail));
// Delete responses to team as well if student is last person in team.
if (studentsLogic.getStudentsForTeam(studentTeam, courseId).size() <= 1) {
responses.addAll(getFeedbackResponsesForReceiverForCourse(courseId, studentTeam));
}
for (FeedbackResponseAttributes response : responses) {
this.deleteFeedbackResponseAndCascade(response);
}
}
/**
* Adds {@link FeedbackResponseAttributes} in {@code newResponses} that are not already in to
* {@code existingResponses} to {@code existingResponses}.
*/
private void addNewResponses(
List<FeedbackResponseAttributes> existingResponses,
List<FeedbackResponseAttributes> newResponses) {
Map<String, FeedbackResponseAttributes> responses =
new HashMap<String, FeedbackResponseAttributes>();
for (FeedbackResponseAttributes existingResponse : existingResponses) {
responses.put(existingResponse.getId(), existingResponse);
}
for (FeedbackResponseAttributes newResponse : newResponses) {
if (!responses.containsKey(newResponse.getId())) {
responses.put(newResponse.getId(), newResponse);
existingResponses.add(newResponse);
}
}
}
private List<FeedbackResponseAttributes> getFeedbackResponsesFromTeamForQuestion(
String feedbackQuestionId, String courseId, String teamName) {
List<FeedbackResponseAttributes> responses = new ArrayList<FeedbackResponseAttributes>();
List<StudentAttributes> studentsInTeam = studentsLogic.getStudentsForTeam(teamName, courseId);
for (StudentAttributes student : studentsInTeam) {
responses.addAll(
frDb.getFeedbackResponsesFromGiverForQuestion(feedbackQuestionId, student.email));
}
return responses;
}
private List<FeedbackResponseAttributes> getFeedbackResponsesForTeamMembersOfStudent(
String feedbackQuestionId, StudentAttributes student) {
List<StudentAttributes> studentsInTeam =
studentsLogic.getStudentsForTeam(student.team, student.course);
List<FeedbackResponseAttributes> teamResponses = new ArrayList<FeedbackResponseAttributes>();
for (StudentAttributes studentInTeam : studentsInTeam) {
if (studentInTeam.email.equals(student.email)) {
continue;
}
List<FeedbackResponseAttributes> responses =
frDb.getFeedbackResponsesForReceiverForQuestion(feedbackQuestionId, studentInTeam.email);
teamResponses.addAll(responses);
}
return teamResponses;
}
private List<FeedbackResponseAttributes> getViewableFeedbackResponsesForStudentForQuestion(
FeedbackQuestionAttributes question, String studentEmail) {
List<FeedbackResponseAttributes> viewableResponses =
new ArrayList<FeedbackResponseAttributes>();
StudentAttributes student = studentsLogic.getStudentForEmail(question.courseId, studentEmail);
if (question.isResponseVisibleTo(FeedbackParticipantType.STUDENTS)) {
addNewResponses(viewableResponses, getFeedbackResponsesForQuestion(question.getId()));
// Early return as STUDENTS covers all other student types.
return viewableResponses;
}
if (question.recipientType == FeedbackParticipantType.TEAMS
&& question.isResponseVisibleTo(FeedbackParticipantType.RECEIVER)) {
addNewResponses(
viewableResponses,
getFeedbackResponsesForReceiverForQuestion(question.getId(), student.team));
}
if (question.giverType == FeedbackParticipantType.TEAMS
|| question.isResponseVisibleTo(FeedbackParticipantType.OWN_TEAM_MEMBERS)) {
addNewResponses(
viewableResponses,
getFeedbackResponsesFromTeamForQuestion(
question.getId(), question.courseId, student.team));
}
if (question.isResponseVisibleTo(FeedbackParticipantType.RECEIVER_TEAM_MEMBERS)) {
addNewResponses(
viewableResponses,
getFeedbackResponsesForTeamMembersOfStudent(question.getId(), student));
}
return viewableResponses;
}
}
public void testGetCoursesSummaryWithoutStatsForInstructor() throws Exception {
______TS("Typical case");
HashMap<String, CourseSummaryBundle> courseListForInstructor =
coursesLogic.getCoursesSummaryWithoutStatsForInstructor("idOfInstructor3");
assertEquals(2, courseListForInstructor.size());
String course1Id = "idOfTypicalCourse1";
// course with 2 evaluations
ArrayList<EvaluationAttributes> course1Evals =
courseListForInstructor.get(course1Id).evaluations;
String course1EvalsAttributes = "";
for (EvaluationAttributes evalAttr : course1Evals) {
course1EvalsAttributes =
course1EvalsAttributes + Utils.getTeammatesGson().toJson(evalAttr) + Const.EOL;
}
int numberOfEvalsInCourse1 = course1Evals.size();
assertEquals(course1EvalsAttributes, 2, numberOfEvalsInCourse1);
assertEquals(course1Id, course1Evals.get(0).courseId);
TestHelper.verifyEvaluationInfoExistsInAttributeList(
dataBundle.evaluations.get("evaluation1InCourse1"), course1Evals);
TestHelper.verifyEvaluationInfoExistsInAttributeList(
dataBundle.evaluations.get("evaluation2InCourse1"), course1Evals);
// course with 1 evaluation
assertEquals(course1Id, course1Evals.get(1).courseId);
ArrayList<EvaluationAttributes> course2Evals =
courseListForInstructor.get("idOfTypicalCourse2").evaluations;
assertEquals(1, course2Evals.size());
TestHelper.verifyEvaluationInfoExistsInAttributeList(
dataBundle.evaluations.get("evaluation1InCourse2"), course2Evals);
______TS("Instructor has a course with 0 evaluations");
courseListForInstructor =
coursesLogic.getCoursesSummaryWithoutStatsForInstructor("idOfInstructor4");
assertEquals(1, courseListForInstructor.size());
assertEquals(0, courseListForInstructor.get("idOfCourseNoEvals").evaluations.size());
______TS("Instructor with 0 courses");
courseListForInstructor =
coursesLogic.getCoursesSummaryWithoutStatsForInstructor("instructorWithoutCourses");
assertEquals(0, courseListForInstructor.size());
______TS("Non-existent instructor");
try {
coursesLogic.getCoursesSummaryWithoutStatsForInstructor("non-existent-instructor");
signalFailureToDetectException();
} catch (EntityDoesNotExistException e) {
AssertHelper.assertContains("does not exist", e.getMessage());
}
______TS("Null parameter");
try {
coursesLogic.getCoursesSummaryWithoutStatsForInstructor(null);
signalFailureToDetectException();
} catch (AssertionError e) {
assertEquals("Supplied parameter was null\n", e.getMessage());
}
}
