0001: /**********************************************************************************
0002: * $URL: https://source.sakaiproject.org/svn/msgcntr/trunk/messageforums-app/src/java/org/sakaiproject/tool/messageforums/PrivateMessagesTool.java $
0003: * $Id: PrivateMessagesTool.java 9227 2006-05-15 15:02:42Z cwen@iupui.edu $
0004: ***********************************************************************************
0005: *
0006: * Copyright (c) 2003, 2004, 2005, 2006, 2007 The Sakai Foundation.
0007: *
0008: * Licensed under the Educational Community License, Version 1.0 (the "License");
0009: * you may not use this file except in compliance with the License.
0010: * You may obtain a copy of the License at
0011: *
0012: * http://www.opensource.org/licenses/ecl1.php
0013: *
0014: * Unless required by applicable law or agreed to in writing, software
0015: * distributed under the License is distributed on an "AS IS" BASIS,
0016: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
0017: * See the License for the specific language governing permissions and
0018: * limitations under the License.
0019: *
0020: **********************************************************************************/package org.sakaiproject.tool.messageforums;
0021:
0022: import java.util.ArrayList;
0023: import java.util.Collection;
0024: import java.util.Collections;
0025: import java.util.Date;
0026: import java.util.HashSet;
0027: import java.util.Iterator;
0028: import java.util.List;
0029: import java.util.Map;
0030: import java.util.ResourceBundle;
0031: import java.util.Set;
0032:
0033: import javax.faces.application.FacesMessage;
0034: import javax.faces.context.ExternalContext;
0035: import javax.faces.context.FacesContext;
0036: import javax.faces.event.ValueChangeEvent;
0037: import javax.faces.model.SelectItem;
0038: import javax.servlet.http.HttpServletRequest;
0039:
0040: import org.apache.commons.logging.Log;
0041: import org.apache.commons.logging.LogFactory;
0042: import org.sakaiproject.api.app.messageforums.Area;
0043: import org.sakaiproject.api.app.messageforums.Attachment;
0044: import org.sakaiproject.api.app.messageforums.MembershipManager;
0045: import org.sakaiproject.api.app.messageforums.Message;
0046: import org.sakaiproject.api.app.messageforums.MessageForumsForumManager;
0047: import org.sakaiproject.api.app.messageforums.MessageForumsMessageManager;
0048: import org.sakaiproject.api.app.messageforums.MessageForumsTypeManager;
0049: import org.sakaiproject.api.app.messageforums.PrivateForum;
0050: import org.sakaiproject.api.app.messageforums.PrivateMessage;
0051: import org.sakaiproject.api.app.messageforums.PrivateMessageRecipient;
0052: import org.sakaiproject.api.app.messageforums.PrivateTopic;
0053: import org.sakaiproject.api.app.messageforums.Topic;
0054: import org.sakaiproject.api.app.messageforums.ui.PrivateMessageManager;
0055: import org.sakaiproject.authz.api.Member;
0056: import org.sakaiproject.authz.cover.SecurityService;
0057: import org.sakaiproject.component.app.messageforums.MembershipItem;
0058: import org.sakaiproject.component.app.messageforums.dao.hibernate.PrivateMessageImpl;
0059: import org.sakaiproject.component.app.messageforums.dao.hibernate.PrivateTopicImpl;
0060: import org.sakaiproject.component.cover.ServerConfigurationService;
0061: import org.sakaiproject.content.api.ContentResource;
0062: import org.sakaiproject.content.api.FilePickerHelper;
0063: import org.sakaiproject.content.cover.ContentHostingService;
0064: import org.sakaiproject.entity.api.Reference;
0065: import org.sakaiproject.exception.IdUnusedException;
0066: import org.sakaiproject.site.api.Site;
0067: import org.sakaiproject.site.api.ToolConfiguration;
0068: import org.sakaiproject.site.cover.SiteService;
0069: import org.sakaiproject.tool.api.Tool;
0070: import org.sakaiproject.tool.api.ToolSession;
0071: import org.sakaiproject.tool.cover.SessionManager;
0072: import org.sakaiproject.tool.cover.ToolManager;
0073: import org.sakaiproject.tool.messageforums.ui.DecoratedAttachment;
0074: import org.sakaiproject.tool.messageforums.ui.PrivateForumDecoratedBean;
0075: import org.sakaiproject.tool.messageforums.ui.PrivateMessageDecoratedBean;
0076: import org.sakaiproject.tool.messageforums.ui.PrivateTopicDecoratedBean;
0077: import org.sakaiproject.user.api.User;
0078: import org.sakaiproject.user.api.UserNotDefinedException;
0079: import org.sakaiproject.user.cover.UserDirectoryService;
0080: import org.sakaiproject.util.Validator;
0081:
0082: public class PrivateMessagesTool {
0083:
0084: private static final Log LOG = LogFactory
0085: .getLog(PrivateMessagesTool.class);
0086:
0087: private static final String MESSAGECENTER_PRIVACY_URL = "messagecenter.privacy.url";
0088: private static final String MESSAGECENTER_PRIVACY_TEXT = "messagecenter.privacy.text";
0089:
0090: private static final String MESSAGECENTER_BUNDLE = "org.sakaiproject.api.app.messagecenter.bundle.Messages";
0091:
0092: private static final ResourceBundle rb = ResourceBundle
0093: .getBundle(MESSAGECENTER_BUNDLE);
0094:
0095: /**
0096: * List individual private messages details
0097: */
0098: private static final String REPLY_SUBJECT_PREFIX = "pvt_reply_prefix";
0099: private static final String ALERT = "pvt_alert";
0100: private static final String NO_MATCH_FOUND = "pvt_no_match_found";
0101: private static final String MISSING_BEG_END_DATE = "pvt_missing_date_range";
0102: private static final String CREATE_DIFF_FOLDER_NAME = "pvt_create_diff_folder_name";
0103: private static final String FOLDER_NAME_BLANK = "pvt_folder_name_blank";
0104: private static final String ENTER_FOLDER_NAME = "pvt_enter_new_folder_name";
0105: private static final String CONFIRM_FOLDER_DELETE = "pvt_delete_folder_confirm";
0106: private static final String CANNOT_DEL_REVISE_FOLDER = "pvt_no_delete_revise_folder";
0107: private static final String PROVIDE_VALID_EMAIL = "pvt_provide_email_addr";
0108: private static final String CONFIRM_PERM_MSG_DELETE = "pvt_confirm_perm_msg_delete";
0109: private static final String SELECT_MSGS_TO_DELETE = "pvt_select_msgs_to_delete";
0110: private static final String SELECT_RECIPIENT_LIST_FOR_REPLY = "pvt_select_reply_recipients_list";
0111: private static final String MISSING_SUBJECT = "pvt_missing_subject";
0112: private static final String SELECT_MSG_RECIPIENT = "pvt_select_msg_recipient";
0113: private static final String CONFIRM_MSG_DELETE = "pvt_confirm_msg_delete";
0114: private static final String ENTER_SEARCH_TEXT = "pvt_enter_search_text";
0115: private static final String MOVE_MSG_ERROR = "pvt_move_msg_error";
0116: private static final String NO_MARKED_READ_MESSAGE = "pvt_no_message_mark_read";
0117:
0118: /** Used to determine if this is combined tool or not */
0119: private static final String MESSAGECENTER_TOOL_ID = "sakai.messagecenter";
0120: private static final String MESSAGECENTER_HELPER_TOOL_ID = "sakai.messageforums.helper";
0121: private static final String MESSAGES_TOOL_ID = "sakai.messages";
0122: private static final String FORUMS_TOOL_ID = "sakai.forums";
0123:
0124: /**
0125: *Dependency Injected
0126: */
0127: private PrivateMessageManager prtMsgManager;
0128: private MessageForumsMessageManager messageManager;
0129: private MessageForumsForumManager forumManager;
0130: private ErrorMessages errorMessages;
0131: private MembershipManager membershipManager;
0132:
0133: /** Dependency Injected */
0134: private MessageForumsTypeManager typeManager;
0135:
0136: /** Naigation for JSP */
0137: public static final String MAIN_PG = "main";
0138: public static final String DISPLAY_MESSAGES_PG = "pvtMsg";
0139: public static final String SELECTED_MESSAGE_PG = "pvtMsgDetail";
0140: public static final String COMPOSE_MSG_PG = "compose";
0141: public static final String COMPOSE_FROM_PG = "msgForum:mainOrHp";
0142: public static final String MESSAGE_SETTING_PG = "pvtMsgSettings";
0143: public static final String MESSAGE_FOLDER_SETTING_PG = "pvtMsgFolderSettings";
0144: public static final String SEARCH_RESULT_MESSAGES_PG = "pvtMsgEx";
0145: public static final String DELETE_MESSAGES_PG = "pvtMsgDelete";
0146: public static final String DELETE_FOLDER_PG = "pvtMsgFolderDelete";
0147: public static final String MESSAGE_STATISTICS_PG = "pvtMsgStatistics";
0148: public static final String MESSAGE_HOME_PG = "pvtMsgHpView";
0149: public static final String MESSAGE_REPLY_PG = "pvtMsgReply";
0150: public static final String DELETE_MESSAGE_PG = "pvtMsgDelete";
0151: public static final String REVISE_FOLDER_PG = "pvtMsgFolderRevise";
0152: public static final String MOVE_MESSAGE_PG = "pvtMsgMove";
0153: public static final String ADD_FOLDER_IN_FOLDER_PG = "pvtMsgFolderInFolderAdd";
0154: public static final String ADD_MESSAGE_FOLDER_PG = "pvtMsgFolderAdd";
0155: public static final String PVTMSG_COMPOSE = "pvtMsgCompose";
0156:
0157: /** portlet configuration parameter values**/
0158: public static final String PVTMSG_MODE_RECEIVED = "Received";
0159: public static final String PVTMSG_MODE_SENT = "Sent";
0160: public static final String PVTMSG_MODE_DELETE = "Deleted";
0161: public static final String PVTMSG_MODE_DRAFT = "Drafts";
0162: public static final String PVTMSG_MODE_CASE = "Personal Folders";
0163:
0164: public static final String RECIPIANTS_ENTIRE_CLASS = "All Participants";
0165: public static final String RECIPIANTS_ALL_INSTRUCTORS = "All Instructors";
0166:
0167: public static final String SET_AS_YES = "yes";
0168: public static final String SET_AS_NO = "no";
0169:
0170: public static final String THREADED_VIEW = "threaded";
0171:
0172: PrivateForumDecoratedBean decoratedForum;
0173:
0174: private Area area;
0175: private PrivateForum forum;
0176: private List pvtTopics = new ArrayList();
0177: private List decoratedPvtMsgs;
0178: private String msgNavMode = "privateMessages";
0179: private PrivateMessageDecoratedBean detailMsg;
0180: private boolean viewChanged = false;
0181:
0182: private String currentMsgUuid; //this is the message which is being currently edited/displayed/deleted
0183: private List selectedItems;
0184:
0185: private String userName; //current user
0186: private Date time; //current time
0187:
0188: //delete confirmation screen - single delete
0189: private boolean deleteConfirm = false; //used for displaying delete confirmation message in same jsp
0190: private boolean validEmail = true;
0191:
0192: //Compose Screen
0193: private List selectedComposeToList = new ArrayList();
0194: private String composeSendAsPvtMsg = SET_AS_YES; // currently set as Default as change by user is allowed
0195: private String composeSubject;
0196: private String composeBody;
0197: private String selectedLabel = "Normal"; //defautl set
0198: private List totalComposeToList;
0199: private List totalComposeToListRecipients;
0200:
0201: //Delete items - Checkbox display and selection - Multiple delete
0202: private List selectedDeleteItems;
0203: private List totalDisplayItems = new ArrayList();
0204:
0205: //reply to
0206: private String replyToBody;
0207: private String replyToSubject;
0208: //Setting Screen
0209: private String activatePvtMsg = SET_AS_NO;
0210: private String forwardPvtMsg = SET_AS_NO;
0211: private String forwardPvtMsgEmail;
0212: private boolean super User;
0213:
0214: //message header screen
0215: private String searchText = "";
0216: private String selectView;
0217:
0218: //return to previous page after send msg
0219: private String fromMainOrHp = null;
0220: //////////////////////
0221: /** The configuration mode, received, sent,delete, case etc ... */
0222: public static final String STATE_PVTMSG_MODE = "pvtmsg.mode";
0223:
0224: private Map courseMemberMap;
0225:
0226: public static final String SORT_SUBJECT_ASC = "subject_asc";
0227: public static final String SORT_SUBJECT_DESC = "subject_desc";
0228: public static final String SORT_AUTHOR_ASC = "author_asc";
0229: public static final String SORT_AUTHOR_DESC = "author_desc";
0230: public static final String SORT_DATE_ASC = "date_asc";
0231: public static final String SORT_DATE_DESC = "date_desc";
0232: public static final String SORT_LABEL_ASC = "label_asc";
0233: public static final String SORT_LABEL_DESC = "label_desc";
0234: public static final String SORT_TO_ASC = "to_asc";
0235: public static final String SORT_TO_DESC = "to_desc";
0236: public static final String SORT_ATTACHMENT_ASC = "attachment_asc";
0237: public static final String SORT_ATTACHMENT_DESC = "attachment_desc";
0238:
0239: /** sort member */
0240: private String sortType = SORT_DATE_DESC;
0241:
0242: public PrivateMessagesTool() {
0243: }
0244:
0245: /**
0246: * @return
0247: */
0248: public MessageForumsTypeManager getTypeManager() {
0249: return typeManager;
0250: }
0251:
0252: /**
0253: * @param prtMsgManager
0254: */
0255: public void setPrtMsgManager(PrivateMessageManager prtMsgManager) {
0256: this .prtMsgManager = prtMsgManager;
0257: }
0258:
0259: /**
0260: * @param messageManager
0261: */
0262: public void setMessageManager(
0263: MessageForumsMessageManager messageManager) {
0264: this .messageManager = messageManager;
0265: }
0266:
0267: /**
0268: * @param membershipManager
0269: */
0270: public void setMembershipManager(MembershipManager membershipManager) {
0271: this .membershipManager = membershipManager;
0272: }
0273:
0274: /**
0275: * @param typeManager
0276: */
0277: public void setTypeManager(MessageForumsTypeManager typeManager) {
0278: this .typeManager = typeManager;
0279: }
0280:
0281: public void initializePrivateMessageArea() {
0282: /** get area per request */
0283: area = prtMsgManager.getPrivateMessageArea();
0284:
0285: if (!area.getEnabled() && isMessages()) {
0286: area.setEnabled(true);
0287: }
0288:
0289: if (getPvtAreaEnabled() || isInstructor()) {
0290: PrivateForum pf = prtMsgManager
0291: .initializePrivateMessageArea(area);
0292: pf = prtMsgManager.initializationHelper(pf, area);
0293: pvtTopics = pf.getTopics();
0294: Collections.sort(pvtTopics,
0295: PrivateTopicImpl.TITLE_COMPARATOR); //changed to date comparator
0296: forum = pf;
0297: activatePvtMsg = (Boolean.TRUE.equals(area.getEnabled())) ? SET_AS_YES
0298: : SET_AS_NO;
0299: forwardPvtMsg = (Boolean.TRUE.equals(pf.getAutoForward())) ? SET_AS_YES
0300: : SET_AS_NO;
0301: forwardPvtMsgEmail = pf.getAutoForwardEmail();
0302: }
0303: }
0304:
0305: /**
0306: * Property created rather than setErrorMessage for design requirement
0307: * @return
0308: */
0309: public boolean isDispError() {
0310: if (isInstructor() && !getPvtAreaEnabled()) {
0311: return true;
0312: } else {
0313: return false;
0314: }
0315: }
0316:
0317: public boolean getPvtAreaEnabled() {
0318: return area.getEnabled().booleanValue();
0319: }
0320:
0321: //Return decorated Forum
0322: public PrivateForumDecoratedBean getDecoratedForum() {
0323: PrivateForumDecoratedBean decoratedForum = new PrivateForumDecoratedBean(
0324: getForum());
0325:
0326: /** only load topics/counts if area is enabled */
0327: if (getPvtAreaEnabled()) {
0328: for (Iterator iterator = pvtTopics.iterator(); iterator
0329: .hasNext();) {
0330: PrivateTopic topic = (PrivateTopic) iterator.next();
0331: if (topic != null) {
0332:
0333: /** filter topics by context and type*/
0334: if (topic.getTypeUuid() != null
0335: && topic
0336: .getTypeUuid()
0337: .equals(
0338: typeManager
0339: .getUserDefinedPrivateTopicType())
0340: && topic.getContextId() != null
0341: && !topic.getContextId().equals(
0342: prtMsgManager.getContextId())) {
0343: continue;
0344: }
0345:
0346: PrivateTopicDecoratedBean decoTopic = new PrivateTopicDecoratedBean(
0347: topic);
0348: //decoTopic.setTotalNoMessages(prtMsgManager.getTotalNoMessages(topic)) ;
0349: //decoTopic.setUnreadNoMessages(prtMsgManager.getUnreadNoMessages(SessionManager.getCurrentSessionUserId(), topic)) ;
0350:
0351: String typeUuid = getPrivateMessageTypeFromContext(topic
0352: .getTitle());
0353:
0354: decoTopic.setTotalNoMessages(prtMsgManager
0355: .findMessageCount(typeUuid));
0356: decoTopic.setUnreadNoMessages(prtMsgManager
0357: .findUnreadMessageCount(typeUuid));
0358:
0359: decoratedForum.addTopic(decoTopic);
0360: }
0361: }
0362: }
0363: return decoratedForum;
0364: }
0365:
0366: public List getDecoratedPvtMsgs() {
0367: /**
0368: avoid apply_request_values and render_response from calling this method on postback
0369: solution -- only call durig render_response phase
0370: */
0371: if (!FacesContext.getCurrentInstance().getRenderResponse()
0372: && !viewChanged) {
0373: return decoratedPvtMsgs;
0374: }
0375:
0376: if (selectView != null
0377: && selectView.equalsIgnoreCase(THREADED_VIEW)) {
0378: this .rearrageTopicMsgsThreaded(false);
0379: return decoratedPvtMsgs;
0380: }
0381:
0382: decoratedPvtMsgs = new ArrayList();
0383:
0384: String typeUuid = getPrivateMessageTypeFromContext(msgNavMode);
0385:
0386: /** support for sorting */
0387: /* if the view was changed to "All Messages", we want to retain the previous
0388: * sort setting. Otherwise, the user has selected a different sort setting.
0389: * Also retain sort setting if user has hit "Check All"
0390: */
0391: if ((!viewChanged || sortType == null) && !selectAll) {
0392: String sortColumnParameter = getExternalParameterByKey("sortColumn");
0393:
0394: if ("subject".equals(sortColumnParameter)) {
0395: sortType = (SORT_SUBJECT_ASC.equals(sortType)) ? SORT_SUBJECT_DESC
0396: : SORT_SUBJECT_ASC;
0397: } else if ("author".equals(sortColumnParameter)) {
0398: sortType = (SORT_AUTHOR_ASC.equals(sortType)) ? SORT_AUTHOR_DESC
0399: : SORT_AUTHOR_ASC;
0400: } else if ("date".equals(sortColumnParameter)) {
0401: sortType = (SORT_DATE_ASC.equals(sortType)) ? SORT_DATE_DESC
0402: : SORT_DATE_ASC;
0403: } else if ("label".equals(sortColumnParameter)) {
0404: sortType = (SORT_LABEL_ASC.equals(sortType)) ? SORT_LABEL_DESC
0405: : SORT_LABEL_ASC;
0406: } else if ("to".equals(sortColumnParameter)) {
0407: sortType = (SORT_TO_ASC.equals(sortType)) ? SORT_TO_DESC
0408: : SORT_TO_ASC;
0409: } else if ("attachment".equals(sortColumnParameter)) {
0410: sortType = (SORT_ATTACHMENT_ASC.equals(sortType)) ? SORT_ATTACHMENT_DESC
0411: : SORT_ATTACHMENT_ASC;
0412: } else {
0413: sortType = SORT_DATE_DESC;
0414: }
0415: }
0416:
0417: viewChanged = false;
0418:
0419: /** add support for sorting */
0420: if (SORT_SUBJECT_ASC.equals(sortType)) {
0421: decoratedPvtMsgs = prtMsgManager.getMessagesByType(
0422: typeUuid,
0423: PrivateMessageManager.SORT_COLUMN_SUBJECT,
0424: PrivateMessageManager.SORT_ASC);
0425: } else if (SORT_SUBJECT_DESC.equals(sortType)) {
0426: decoratedPvtMsgs = prtMsgManager.getMessagesByType(
0427: typeUuid,
0428: PrivateMessageManager.SORT_COLUMN_SUBJECT,
0429: PrivateMessageManager.SORT_DESC);
0430: } else if (SORT_AUTHOR_ASC.equals(sortType)) {
0431: decoratedPvtMsgs = prtMsgManager.getMessagesByType(
0432: typeUuid, PrivateMessageManager.SORT_COLUMN_AUTHOR,
0433: PrivateMessageManager.SORT_ASC);
0434: } else if (SORT_AUTHOR_DESC.equals(sortType)) {
0435: decoratedPvtMsgs = prtMsgManager.getMessagesByType(
0436: typeUuid, PrivateMessageManager.SORT_COLUMN_AUTHOR,
0437: PrivateMessageManager.SORT_DESC);
0438: } else if (SORT_DATE_ASC.equals(sortType)) {
0439: decoratedPvtMsgs = prtMsgManager.getMessagesByType(
0440: typeUuid, PrivateMessageManager.SORT_COLUMN_DATE,
0441: PrivateMessageManager.SORT_ASC);
0442: } else if (SORT_DATE_DESC.equals(sortType)) {
0443: decoratedPvtMsgs = prtMsgManager.getMessagesByType(
0444: typeUuid, PrivateMessageManager.SORT_COLUMN_DATE,
0445: PrivateMessageManager.SORT_DESC);
0446: } else if (SORT_LABEL_ASC.equals(sortType)) {
0447: decoratedPvtMsgs = prtMsgManager.getMessagesByType(
0448: typeUuid, PrivateMessageManager.SORT_COLUMN_LABEL,
0449: PrivateMessageManager.SORT_ASC);
0450: } else if (SORT_LABEL_DESC.equals(sortType)) {
0451: decoratedPvtMsgs = prtMsgManager.getMessagesByType(
0452: typeUuid, PrivateMessageManager.SORT_COLUMN_LABEL,
0453: PrivateMessageManager.SORT_DESC);
0454: } else if (SORT_TO_ASC.equals(sortType)) {
0455: // the recipient list is stored as a CLOB in Oracle, so we cannot use the
0456: // db query to obtain the sorted list - cannot order by CLOB
0457: /*decoratedPvtMsgs= prtMsgManager.getMessagesByType(typeUuid, PrivateMessageManager.SORT_COLUMN_TO,
0458: PrivateMessageManager.SORT_ASC);*/
0459: decoratedPvtMsgs = prtMsgManager.getMessagesByType(
0460: typeUuid, PrivateMessageManager.SORT_COLUMN_DATE,
0461: PrivateMessageManager.SORT_ASC);
0462: Collections.sort(decoratedPvtMsgs,
0463: PrivateMessageImpl.RECIPIENT_LIST_COMPARATOR_ASC);
0464: } else if (SORT_TO_DESC.equals(sortType)) {
0465: // the recipient list is stored as a CLOB in Oracle, so we cannot use the
0466: // db query to obtain the sorted list - cannot order by CLOB
0467: /*decoratedPvtMsgs= prtMsgManager.getMessagesByType(typeUuid, PrivateMessageManager.SORT_COLUMN_TO,
0468: PrivateMessageManager.SORT_DESC);*/
0469: decoratedPvtMsgs = prtMsgManager.getMessagesByType(
0470: typeUuid, PrivateMessageManager.SORT_COLUMN_DATE,
0471: PrivateMessageManager.SORT_ASC);
0472: Collections.sort(decoratedPvtMsgs,
0473: PrivateMessageImpl.RECIPIENT_LIST_COMPARATOR_DESC);
0474: } else if (SORT_ATTACHMENT_ASC.equals(sortType)) {
0475: decoratedPvtMsgs = prtMsgManager.getMessagesByType(
0476: typeUuid,
0477: PrivateMessageManager.SORT_COLUMN_ATTACHMENT,
0478: PrivateMessageManager.SORT_ASC);
0479: } else if (SORT_ATTACHMENT_DESC.equals(sortType)) {
0480: decoratedPvtMsgs = prtMsgManager.getMessagesByType(
0481: typeUuid,
0482: PrivateMessageManager.SORT_COLUMN_ATTACHMENT,
0483: PrivateMessageManager.SORT_DESC);
0484: }
0485:
0486: decoratedPvtMsgs = createDecoratedDisplay(decoratedPvtMsgs);
0487:
0488: //pre/next message
0489: if (decoratedPvtMsgs != null) {
0490: setMessageBeanPreNextStatus();
0491: }
0492:
0493: return decoratedPvtMsgs;
0494: }
0495:
0496: private void setMessageBeanPreNextStatus() {
0497: List tempMsgs = decoratedPvtMsgs;
0498: for (int i = 0; i < tempMsgs.size(); i++) {
0499: PrivateMessageDecoratedBean dmb = (PrivateMessageDecoratedBean) tempMsgs
0500: .get(i);
0501: if (i == 0) {
0502: dmb.setHasPre(false);
0503: if (i == (tempMsgs.size() - 1)) {
0504: dmb.setHasNext(false);
0505: } else {
0506: dmb.setHasNext(true);
0507: }
0508: } else if (i == (tempMsgs.size() - 1)) {
0509: dmb.setHasPre(true);
0510: dmb.setHasNext(false);
0511: } else {
0512: dmb.setHasNext(true);
0513: dmb.setHasPre(true);
0514: }
0515: }
0516: }
0517:
0518: public void setDecoratedPvtMsgs(List displayPvtMsgs) {
0519: this .decoratedPvtMsgs = displayPvtMsgs;
0520: }
0521:
0522: public String getMsgNavMode() {
0523: return msgNavMode;
0524: }
0525:
0526: public PrivateMessageDecoratedBean getDetailMsg() {
0527: return detailMsg;
0528: }
0529:
0530: public void setDetailMsg(PrivateMessageDecoratedBean detailMsg) {
0531: this .detailMsg = detailMsg;
0532: }
0533:
0534: public String getCurrentMsgUuid() {
0535: return currentMsgUuid;
0536: }
0537:
0538: public void setCurrentMsgUuid(String currentMsgUuid) {
0539: this .currentMsgUuid = currentMsgUuid;
0540: }
0541:
0542: public List getSelectedItems() {
0543: return selectedItems;
0544: }
0545:
0546: public void setSelectedItems(List selectedItems) {
0547: this .selectedItems = selectedItems;
0548: }
0549:
0550: public boolean isDeleteConfirm() {
0551: return deleteConfirm;
0552: }
0553:
0554: public void setDeleteConfirm(boolean deleteConfirm) {
0555: this .deleteConfirm = deleteConfirm;
0556: }
0557:
0558: public boolean isValidEmail() {
0559: return validEmail;
0560: }
0561:
0562: public void setValidEmail(boolean validEmail) {
0563: this .validEmail = validEmail;
0564: }
0565:
0566: //Deleted page - checkbox display and selection
0567: public List getSelectedDeleteItems() {
0568: return selectedDeleteItems;
0569: }
0570:
0571: public List getTotalDisplayItems() {
0572: return totalDisplayItems;
0573: }
0574:
0575: public void setTotalDisplayItems(List totalDisplayItems) {
0576: this .totalDisplayItems = totalDisplayItems;
0577: }
0578:
0579: public void setSelectedDeleteItems(List selectedDeleteItems) {
0580: this .selectedDeleteItems = selectedDeleteItems;
0581: }
0582:
0583: //Compose Getter and Setter
0584: public String getComposeBody() {
0585: return composeBody;
0586: }
0587:
0588: public void setComposeBody(String composeBody) {
0589: this .composeBody = composeBody;
0590: }
0591:
0592: public String getSelectedLabel() {
0593: return selectedLabel;
0594: }
0595:
0596: public void setSelectedLabel(String selectedLabel) {
0597: this .selectedLabel = selectedLabel;
0598: }
0599:
0600: public String getComposeSendAsPvtMsg() {
0601: return composeSendAsPvtMsg;
0602: }
0603:
0604: public void setComposeSendAsPvtMsg(String composeSendAsPvtMsg) {
0605: this .composeSendAsPvtMsg = composeSendAsPvtMsg;
0606: }
0607:
0608: public String getComposeSubject() {
0609: return composeSubject;
0610: }
0611:
0612: public void setComposeSubject(String composeSubject) {
0613: this .composeSubject = composeSubject;
0614: }
0615:
0616: public void setSelectedComposeToList(List selectedComposeToList) {
0617: this .selectedComposeToList = selectedComposeToList;
0618: }
0619:
0620: public void setTotalComposeToList(List totalComposeToList) {
0621: this .totalComposeToList = totalComposeToList;
0622: }
0623:
0624: public List getSelectedComposeToList() {
0625: return selectedComposeToList;
0626: }
0627:
0628: private String getSiteId() {
0629: return ToolManager.getCurrentPlacement().getContext();
0630: }
0631:
0632: private String getContextSiteId() {
0633: return "/site/"
0634: + ToolManager.getCurrentPlacement().getContext();
0635: }
0636:
0637: public List getTotalComposeToList() {
0638: /** just need to refilter */
0639: if (totalComposeToList != null) {
0640:
0641: List selectItemList = new ArrayList();
0642:
0643: for (Iterator i = totalComposeToList.iterator(); i
0644: .hasNext();) {
0645: MembershipItem item = (MembershipItem) i.next();
0646:
0647: if (isInstructor() || item.isViewable()) {
0648: selectItemList.add(new SelectItem(item.getId(),
0649: item.getName()));
0650: }
0651: }
0652:
0653: return selectItemList;
0654: }
0655:
0656: totalComposeToListRecipients = new ArrayList();
0657:
0658: courseMemberMap = membershipManager
0659: .getFilteredCourseMembers(true);
0660: // courseMemberMap = membershipManager.getAllCourseMembers(true, true, true);
0661: List members = membershipManager
0662: .convertMemberMapToList(courseMemberMap);
0663:
0664: Set memberIds = new HashSet();
0665:
0666: for (Iterator i = members.iterator(); i.hasNext();) {
0667: MembershipItem item = (MembershipItem) i.next();
0668:
0669: String name = item.getName();
0670:
0671: memberIds.add(item.getId());
0672: }
0673:
0674: totalComposeToList = members;
0675:
0676: List selectItemList = new ArrayList();
0677:
0678: for (Iterator i = members.iterator(); i.hasNext();) {
0679:
0680: MembershipItem item = (MembershipItem) i.next();
0681:
0682: if (isInstructor() || item.isViewable()) {
0683: selectItemList.add(new SelectItem(item.getId(), item
0684: .getName()));
0685: }
0686: }
0687:
0688: return selectItemList;
0689: }
0690:
0691: /**
0692: *
0693: * @param id
0694: * @return
0695: */
0696: public String getUserSortNameById(String id) {
0697: try {
0698: User user = UserDirectoryService.getUser(id);
0699: userName = user.getSortName();
0700: } catch (UserNotDefinedException e) {
0701: // TODO Auto-generated catch block
0702: e.printStackTrace();
0703: }
0704: return userName;
0705: }
0706:
0707: public String getUserName() {
0708: String userId = SessionManager.getCurrentSessionUserId();
0709: try {
0710: User user = UserDirectoryService.getUser(userId);
0711: userName = user.getDisplayName();
0712: } catch (UserNotDefinedException e) {
0713: // TODO Auto-generated catch block
0714: e.printStackTrace();
0715: }
0716: return userName;
0717: }
0718:
0719: public String getUserId() {
0720: return SessionManager.getCurrentSessionUserId();
0721: }
0722:
0723: //Reply time
0724: public Date getTime() {
0725: return new Date();
0726: }
0727:
0728: //Reply to page
0729: public String getReplyToBody() {
0730: return replyToBody;
0731: }
0732:
0733: public void setReplyToBody(String replyToBody) {
0734: this .replyToBody = replyToBody;
0735: }
0736:
0737: public String getReplyToSubject() {
0738: return replyToSubject;
0739: }
0740:
0741: public void setReplyToSubject(String replyToSubject) {
0742: this .replyToSubject = replyToSubject;
0743: }
0744:
0745: //message header Getter
0746: public String getSearchText() {
0747: return searchText;
0748: }
0749:
0750: public void setSearchText(String searchText) {
0751: this .searchText = searchText;
0752: }
0753:
0754: public String getSelectView() {
0755: return selectView;
0756: }
0757:
0758: public void setSelectView(String selectView) {
0759: this .selectView = selectView;
0760: }
0761:
0762: public void processChangeSelectView(ValueChangeEvent eve) {
0763: String currentValue = (String) eve.getNewValue();
0764: if (currentValue == null
0765: || !currentValue.equalsIgnoreCase(THREADED_VIEW)) {
0766: selectView = "";
0767: viewChanged = true;
0768: getDecoratedPvtMsgs();
0769: return;
0770: } else {
0771: selectView = THREADED_VIEW;
0772: if (searchPvtMsgs != null && !searchPvtMsgs.isEmpty())
0773: this .rearrageTopicMsgsThreaded(true);
0774: else
0775: this .rearrageTopicMsgsThreaded(false);
0776: return;
0777: }
0778: }
0779:
0780: public void rearrageTopicMsgsThreaded(boolean searcModeOn) {
0781: List msgsList = new ArrayList();
0782:
0783: if (searcModeOn) {
0784: for (int i = 0; i < searchPvtMsgs.size(); i++) {
0785: msgsList
0786: .add((PrivateMessageDecoratedBean) searchPvtMsgs
0787: .get(i));
0788: }
0789: searchPvtMsgs.clear();
0790: } else {
0791: // always start with the decorated pm in ascending date order
0792: String typeUuid = getPrivateMessageTypeFromContext(msgNavMode);
0793: decoratedPvtMsgs = prtMsgManager.getMessagesByType(
0794: typeUuid, PrivateMessageManager.SORT_COLUMN_DATE,
0795: PrivateMessageManager.SORT_ASC);
0796: decoratedPvtMsgs = createDecoratedDisplay(decoratedPvtMsgs);
0797:
0798: for (int i = 0; i < decoratedPvtMsgs.size(); i++) {
0799: msgsList
0800: .add((PrivateMessageDecoratedBean) decoratedPvtMsgs
0801: .get(i));
0802: }
0803: decoratedPvtMsgs.clear();
0804: }
0805:
0806: if (msgsList != null) {
0807: List tempMsgsList = new ArrayList();
0808: for (int i = 0; i < msgsList.size(); i++) {
0809: tempMsgsList.add((PrivateMessageDecoratedBean) msgsList
0810: .get(i));
0811: }
0812: Iterator iter = tempMsgsList.iterator();
0813: while (iter.hasNext()) {
0814: List allRelatedMsgs = messageManager
0815: .getAllRelatedMsgs(((PrivateMessageDecoratedBean) iter
0816: .next()).getMsg().getId());
0817: List currentRelatedMsgs = new ArrayList();
0818: if (allRelatedMsgs != null && allRelatedMsgs.size() > 0) {
0819: Long msgId = ((Message) allRelatedMsgs.get(0))
0820: .getId();
0821: PrivateMessage pvtMsg = (PrivateMessage) prtMsgManager
0822: .getMessageById(msgId);
0823: PrivateMessageDecoratedBean pdb = new PrivateMessageDecoratedBean(
0824: pvtMsg);
0825: pdb.setDepth(-1);
0826: boolean firstEleAdded = false;
0827: for (int i = 0; i < msgsList.size(); i++) {
0828: PrivateMessageDecoratedBean tempPMDB = (PrivateMessageDecoratedBean) msgsList
0829: .get(i);
0830: if (tempPMDB.getMsg().getId().equals(
0831: pdb.getMsg().getId())) {
0832: tempPMDB.setDepth(0);
0833: currentRelatedMsgs.add(tempPMDB);
0834: firstEleAdded = true;
0835: recursiveGetThreadedMsgsFromList(msgsList,
0836: allRelatedMsgs, currentRelatedMsgs,
0837: tempPMDB);
0838: break;
0839: }
0840: }
0841: if (!firstEleAdded)
0842: recursiveGetThreadedMsgsFromList(msgsList,
0843: allRelatedMsgs, currentRelatedMsgs, pdb);
0844: }
0845: for (int i = 0; i < currentRelatedMsgs.size(); i++) {
0846: if (searcModeOn) {
0847: searchPvtMsgs
0848: .add((PrivateMessageDecoratedBean) currentRelatedMsgs
0849: .get(i));
0850: } else {
0851: decoratedPvtMsgs
0852: .add((PrivateMessageDecoratedBean) currentRelatedMsgs
0853: .get(i));
0854: }
0855:
0856: tempMsgsList
0857: .remove((PrivateMessageDecoratedBean) currentRelatedMsgs
0858: .get(i));
0859: }
0860:
0861: iter = tempMsgsList.iterator();
0862: }
0863: }
0864:
0865: setMessageBeanPreNextStatus();
0866:
0867: }
0868:
0869: private void recursiveGetThreadedMsgsFromList(List msgsList,
0870: List allRelatedMsgs, List returnList,
0871: PrivateMessageDecoratedBean currentMsg) {
0872: for (int i = 0; i < allRelatedMsgs.size(); i++) {
0873: Long msgId = ((Message) allRelatedMsgs.get(i)).getId();
0874: PrivateMessage pvtMsg = (PrivateMessage) prtMsgManager
0875: .getMessageById(msgId);
0876: PrivateMessageDecoratedBean this MsgBean = new PrivateMessageDecoratedBean(
0877: pvtMsg);
0878:
0879: Message this Msg = this MsgBean.getMsg();
0880: boolean existedInCurrentUserList = false;
0881: for (int j = 0; j < msgsList.size(); j++) {
0882: PrivateMessageDecoratedBean currentUserBean = (PrivateMessageDecoratedBean) msgsList
0883: .get(j);
0884: if (this Msg.getInReplyTo() != null
0885: && this Msg.getInReplyTo().getId().equals(
0886: currentMsg.getMsg().getId())
0887: && currentUserBean.getMsg().getId().equals(
0888: this Msg.getId())) {
0889: currentUserBean.setDepth(currentMsg.getDepth() + 1);
0890: if (currentMsg.getDepth() > -1) {
0891: currentUserBean
0892: .setUiInReply(((PrivateMessageDecoratedBean) returnList
0893: .get(returnList.size() - 1))
0894: .getMsg());
0895: }
0896: returnList.add(currentUserBean);
0897: existedInCurrentUserList = true;
0898: recursiveGetThreadedMsgsFromList(msgsList,
0899: allRelatedMsgs, returnList, currentUserBean);
0900: break;
0901: }
0902: }
0903: if (!existedInCurrentUserList) {
0904: if (this Msg.getInReplyTo() != null
0905: && this Msg.getInReplyTo().getId().equals(
0906: currentMsg.getMsg().getId())) {
0907: this MsgBean.setDepth(currentMsg.getDepth());
0908: recursiveGetThreadedMsgsFromList(msgsList,
0909: allRelatedMsgs, returnList, this MsgBean);
0910: }
0911: }
0912: }
0913: }
0914:
0915: //////////////////////////////////////////////////////////////////////////////////
0916: /**
0917: * called when any topic like Received/Sent/Deleted clicked
0918: * @return - pvtMsg
0919: */
0920: private String selectedTopicTitle = "";
0921: private String selectedTopicId = "";
0922:
0923: public String getSelectedTopicTitle() {
0924: return selectedTopicTitle;
0925: }
0926:
0927: public void setSelectedTopicTitle(String selectedTopicTitle) {
0928: this .selectedTopicTitle = selectedTopicTitle;
0929: }
0930:
0931: public String getSelectedTopicId() {
0932: return selectedTopicId;
0933: }
0934:
0935: public void setSelectedTopicId(String selectedTopicId) {
0936: this .selectedTopicId = selectedTopicId;
0937: }
0938:
0939: public String processActionHome() {
0940: LOG.debug("processActionHome()");
0941: msgNavMode = "privateMessages";
0942: return MAIN_PG;
0943: }
0944:
0945: public String processActionPrivateMessages() {
0946: LOG.debug("processActionPrivateMessages()");
0947: msgNavMode = "privateMessages";
0948: return MESSAGE_HOME_PG;
0949: }
0950:
0951: public String processDisplayForum() {
0952: LOG.debug("processDisplayForum()");
0953: if (searchPvtMsgs != null)
0954: searchPvtMsgs.clear();
0955: return DISPLAY_MESSAGES_PG;
0956: }
0957:
0958: public String processPvtMsgTopic() {
0959: LOG.debug("processPvtMsgTopic()");
0960:
0961: /** reset sort type */
0962: sortType = SORT_DATE_DESC;
0963:
0964: //get external parameter
0965: //selectedTopicTitle = getExternalParameterByKey("pvtMsgTopicTitle") ;
0966: selectedTopicTitle = forumManager.getTopicByUuid(
0967: getExternalParameterByKey("pvtMsgTopicId")).getTitle();
0968: setSelectedTopicId(getExternalParameterByKey("pvtMsgTopicId"));
0969: msgNavMode = getSelectedTopicTitle();
0970:
0971: //set prev/next topic details
0972: setPrevNextTopicDetails(msgNavMode);
0973:
0974: return DISPLAY_MESSAGES_PG;
0975: }
0976:
0977: /**
0978: * process Cancel from all JSP's
0979: * @return - pvtMsg
0980: */
0981: public String processPvtMsgCancel() {
0982: LOG.debug("processPvtMsgCancel()");
0983:
0984: // Return to Messages & Forums page or Messages page
0985: if (isMessagesandForums()) {
0986: return MAIN_PG;
0987: } else {
0988: return MESSAGE_HOME_PG;
0989: }
0990: }
0991:
0992: public String processPvtMsgCancelToListView() {
0993: return DISPLAY_MESSAGES_PG;
0994: }
0995:
0996: /**
0997: * called when subject of List of messages to Topic clicked for detail
0998: * @return - pvtMsgDetail
0999: */
1000: public String processPvtMsgDetail() {
1001: LOG.debug("processPvtMsgDetail()");
1002:
1003: String msgId = getExternalParameterByKey("current_msg_detail");
1004: setCurrentMsgUuid(msgId);
1005: //retrive the detail for this message with currentMessageId
1006: for (Iterator iter = decoratedPvtMsgs.iterator(); iter
1007: .hasNext();) {
1008: PrivateMessageDecoratedBean dMsg = (PrivateMessageDecoratedBean) iter
1009: .next();
1010: if (dMsg.getMsg().getId().equals(new Long(msgId))) {
1011: this .setDetailMsg(dMsg);
1012:
1013: prtMsgManager.markMessageAsReadForUser(dMsg.getMsg());
1014:
1015: PrivateMessage initPrivateMessage = prtMsgManager
1016: .initMessageWithAttachmentsAndRecipients(dMsg
1017: .getMsg());
1018: this .setDetailMsg(new PrivateMessageDecoratedBean(
1019: initPrivateMessage));
1020:
1021: List recLs = initPrivateMessage.getRecipients();
1022: for (Iterator iterator = recLs.iterator(); iterator
1023: .hasNext();) {
1024: PrivateMessageRecipient element = (PrivateMessageRecipient) iterator
1025: .next();
1026: if (element != null) {
1027: if ((element.getRead().booleanValue())
1028: || (element.getUserId()
1029: .equals(getUserId()))) {
1030: getDetailMsg().setHasRead(true);
1031: }
1032: }
1033: }
1034: //ADD the recipientText here
1035: this .getDetailMsg().getMsg().setRecipientsAsText(
1036: dMsg.getMsg().getRecipientsAsText());
1037: }
1038: }
1039: this .deleteConfirm = false; //reset this as used for multiple action in same JSP
1040:
1041: //prev/next message
1042: if (decoratedPvtMsgs != null) {
1043: for (int i = 0; i < decoratedPvtMsgs.size(); i++) {
1044: PrivateMessageDecoratedBean this Dmb = (PrivateMessageDecoratedBean) decoratedPvtMsgs
1045: .get(i);
1046: if (((PrivateMessageDecoratedBean) decoratedPvtMsgs
1047: .get(i)).getMsg().getId().toString().equals(
1048: msgId)) {
1049: detailMsg.setDepth(this Dmb.getDepth());
1050: detailMsg.setHasNext(this Dmb.getHasNext());
1051: detailMsg.setHasPre(this Dmb.getHasPre());
1052: break;
1053: }
1054: }
1055: }
1056: //default setting for moveTo
1057: moveToTopic = selectedTopicId;
1058: return SELECTED_MESSAGE_PG;
1059: }
1060:
1061: /**
1062: * called from Single delete Page
1063: * @return - pvtMsgReply
1064: */
1065: public String processPvtMsgReply() {
1066: LOG.debug("processPvtMsgReply()");
1067: // //set default userName
1068: // List defName = new ArrayList();
1069: // defName.add(getUserName());
1070: // List d = new ArrayList();
1071: // for (Iterator iter = defName.iterator(); iter.hasNext();)
1072: // {
1073: // String element = (String) iter.next();
1074: // d.add(new SelectItem(element));
1075: // }
1076: // this.setSelectedComposeToList(d);
1077: //set Dafult Subject
1078: if (getDetailMsg() != null) {
1079: if (getDetailMsg().getMsg().getTitle() != null
1080: && !getDetailMsg()
1081: .getMsg()
1082: .getTitle()
1083: .startsWith(
1084: getResourceBundleString(REPLY_SUBJECT_PREFIX)))
1085: replyToSubject = getResourceBundleString(REPLY_SUBJECT_PREFIX)
1086: + ' ' + getDetailMsg().getMsg().getTitle();
1087: else
1088: replyToSubject = getDetailMsg().getMsg().getTitle();
1089: }
1090:
1091: //from message detail screen
1092: this .setDetailMsg(getDetailMsg());
1093: //
1094: // //from compose screen
1095: // this.setComposeSendAs(getComposeSendAs()) ;
1096: // this.setTotalComposeToList(getTotalComposeToList()) ;
1097: // this.setSelectedComposeToList(getSelectedComposeToList()) ;
1098:
1099: return MESSAGE_REPLY_PG;
1100: }
1101:
1102: /**
1103: * called from Single delete Page
1104: * @return - pvtMsgDetail
1105: */
1106: public String processPvtMsgDeleteConfirm() {
1107: LOG.debug("processPvtMsgDeleteConfirm()");
1108:
1109: this .setDeleteConfirm(true);
1110: setErrorMessage(getResourceBundleString(CONFIRM_MSG_DELETE));
1111: /*
1112: * same action is used for delete..however if user presses some other action after first
1113: * delete then 'deleteConfirm' boolean is reset
1114: */
1115: return SELECTED_MESSAGE_PG;
1116: }
1117:
1118: /**
1119: * called from Single delete Page -
1120: * called when 'delete' button pressed second time
1121: * @return - pvtMsg
1122: */
1123: public String processPvtMsgDeleteConfirmYes() {
1124: LOG.debug("processPvtMsgDeleteConfirmYes()");
1125: if (getDetailMsg() != null) {
1126: prtMsgManager.deletePrivateMessage(getDetailMsg().getMsg(),
1127: getPrivateMessageTypeFromContext(msgNavMode));
1128: }
1129: return DISPLAY_MESSAGES_PG;
1130: }
1131:
1132: //RESET form variable - required as the bean is in session and some attributes are used as helper for navigation
1133: public void resetFormVariable() {
1134:
1135: this .msgNavMode = "";
1136: this .deleteConfirm = false;
1137: selectAll = false;
1138: attachments.clear();
1139: oldAttachments.clear();
1140: }
1141:
1142: /**
1143: * process Compose action from different JSP'S
1144: * @return - pvtMsgCompose
1145: */
1146: public String processPvtMsgCompose() {
1147: this .setDetailMsg(new PrivateMessageDecoratedBean(
1148: messageManager.createPrivateMessage()));
1149: setFromMainOrHp();
1150: LOG.debug("processPvtMsgCompose()");
1151: return PVTMSG_COMPOSE;
1152: }
1153:
1154: public String processPvtMsgComposeCancel() {
1155: LOG.debug("processPvtMsgComposeCancel()");
1156: resetComposeContents();
1157: if (("privateMessages").equals(getMsgNavMode())) {
1158: return processPvtMsgReturnToMainOrHp();
1159: } else {
1160: return DISPLAY_MESSAGES_PG;
1161: }
1162: }
1163:
1164: public void resetComposeContents() {
1165: this .setComposeBody("");
1166: this .setComposeSubject("");
1167: this .setComposeSendAsPvtMsg(SET_AS_YES); //set as default
1168: this .getSelectedComposeToList().clear();
1169: this .setReplyToSubject("");
1170: this .setReplyToBody("");
1171: this .getAttachments().clear();
1172: this .getAllAttachments().clear();
1173: //reset label
1174: this .setSelectedLabel("Normal");
1175: }
1176:
1177: /**
1178: * process from Compose screen
1179: * @return - pvtMsg
1180: */
1181: public String processPvtMsgSend() {
1182:
1183: LOG.debug("processPvtMsgSend()");
1184:
1185: if (!hasValue(getComposeSubject())) {
1186: setErrorMessage(getResourceBundleString(MISSING_SUBJECT));
1187: return null;
1188: }
1189: // if(!hasValue(getComposeBody()) )
1190: // {
1191: // setErrorMessage("Please enter message body for this compose message.");
1192: // return null ;
1193: // }
1194: if (getSelectedComposeToList().size() < 1) {
1195: setErrorMessage(getResourceBundleString(SELECT_MSG_RECIPIENT));
1196: return null;
1197: }
1198:
1199: PrivateMessage pMsg = constructMessage();
1200:
1201: if ((SET_AS_YES).equals(getComposeSendAsPvtMsg())) {
1202: prtMsgManager.sendPrivateMessage(pMsg, getRecipients(),
1203: false);
1204: } else {
1205: prtMsgManager.sendPrivateMessage(pMsg, getRecipients(),
1206: true);
1207: }
1208:
1209: //reset contents
1210: resetComposeContents();
1211:
1212: if (fromMainOrHp != null && !fromMainOrHp.equals("")) {
1213: String tmpBackPage = fromMainOrHp;
1214: fromMainOrHp = "";
1215: return tmpBackPage;
1216: } else if (selectedTopic != null) {
1217: msgNavMode = getSelectedTopicTitle();
1218: setPrevNextTopicDetails(msgNavMode);
1219:
1220: return DISPLAY_MESSAGES_PG;
1221: }
1222:
1223: // Return to Messages & Forums page or Messages page
1224: if (isMessagesandForums()) {
1225: return MAIN_PG;
1226: } else {
1227: return MESSAGE_HOME_PG;
1228: }
1229: }
1230:
1231: /**
1232: * process from Compose screen
1233: * @return - pvtMsg
1234: */
1235: public String processPvtMsgSaveDraft() {
1236: LOG.debug("processPvtMsgSaveDraft()");
1237: if (!hasValue(getComposeSubject())) {
1238: setErrorMessage(getResourceBundleString(MISSING_SUBJECT));
1239: return null;
1240: }
1241: // if(!hasValue(getComposeBody()) )
1242: // {
1243: // setErrorMessage("Please enter message body for this compose message.");
1244: // return null ;
1245: // }
1246: if (getSelectedComposeToList().size() < 1) {
1247: setErrorMessage(getResourceBundleString(SELECT_MSG_RECIPIENT));
1248: return null;
1249: }
1250:
1251: PrivateMessage dMsg = constructMessage();
1252: dMsg.setDraft(Boolean.TRUE);
1253:
1254: if ((SET_AS_YES).equals(getComposeSendAsPvtMsg())) {
1255: prtMsgManager.sendPrivateMessage(dMsg, getRecipients(),
1256: false);
1257: }
1258:
1259: //reset contents
1260: resetComposeContents();
1261:
1262: if (getMsgNavMode().equals("")) {
1263: // Return to Messages & Forums page or Messages page
1264: if (isMessagesandForums()) {
1265: return MAIN_PG;
1266: } else {
1267: return MESSAGE_HOME_PG;
1268: }
1269: } else {
1270: return DISPLAY_MESSAGES_PG;
1271: }
1272: }
1273:
1274: // created separate method as to be used with processPvtMsgSend() and processPvtMsgSaveDraft()
1275: public PrivateMessage constructMessage() {
1276: PrivateMessage aMsg;
1277: // in case of compose this is a new message
1278: if (this .getDetailMsg() == null) {
1279: aMsg = messageManager.createPrivateMessage();
1280: }
1281: //if reply to a message then message is existing
1282: else {
1283: aMsg = (PrivateMessage) this .getDetailMsg().getMsg();
1284: }
1285: if (aMsg != null) {
1286: aMsg.setTitle(getComposeSubject());
1287: aMsg.setBody(getComposeBody());
1288: // these are set by the create method above -- you can remove them or keep them if you really want :)
1289: //aMsg.setCreatedBy(getUserId());
1290: //aMsg.setCreated(getTime()) ;
1291:
1292: aMsg.setAuthor(getAuthorString());
1293: aMsg.setDraft(Boolean.FALSE);
1294: aMsg.setApproved(Boolean.FALSE);
1295: aMsg.setLabel(getSelectedLabel());
1296:
1297: // Add the recipientList as String for display in Sent folder
1298: // Any hidden users will be tacked on at the end
1299: String sendToString = "";
1300: String sendToHiddenString = "";
1301:
1302: if (selectedComposeToList.size() == 1) {
1303: MembershipItem membershipItem = (MembershipItem) courseMemberMap
1304: .get(selectedComposeToList.get(0));
1305: if (membershipItem != null) {
1306: sendToString += membershipItem.getName() + "; ";
1307: }
1308: } else {
1309: for (int i = 0; i < selectedComposeToList.size(); i++) {
1310: MembershipItem membershipItem = (MembershipItem) courseMemberMap
1311: .get(selectedComposeToList.get(i));
1312: if (membershipItem != null) {
1313: if (membershipItem.isViewable()) {
1314: sendToString += membershipItem.getName()
1315: + "; ";
1316: } else {
1317: sendToHiddenString += membershipItem
1318: .getName()
1319: + "; ";
1320: }
1321: }
1322: }
1323: }
1324:
1325: if (!"".equals(sendToString)) {
1326: sendToString = sendToString.substring(0, sendToString
1327: .length() - 2); //remove last comma and space
1328: }
1329:
1330: if ("".equals(sendToHiddenString)) {
1331: aMsg.setRecipientsAsText(sendToString);
1332: } else {
1333: sendToHiddenString = sendToHiddenString.substring(0,
1334: sendToHiddenString.length() - 2); //remove last comma and space
1335: aMsg.setRecipientsAsText(sendToString + " ("
1336: + sendToHiddenString + ")");
1337: }
1338:
1339: }
1340: //Add attachments
1341: for (int i = 0; i < attachments.size(); i++) {
1342: prtMsgManager.addAttachToPvtMsg(aMsg,
1343: ((DecoratedAttachment) attachments.get(i))
1344: .getAttachment());
1345: }
1346: //clear
1347: attachments.clear();
1348: oldAttachments.clear();
1349:
1350: return aMsg;
1351: }
1352:
1353: ///////////////////// Previous/Next topic and message on Detail message page
1354: /**
1355: * Set Previous and Next message details with each PrivateMessageDecoratedBean
1356: */
1357: public void setPrevNextMessageDetails() {
1358: List tempMsgs = decoratedPvtMsgs;
1359: for (int i = 0; i < tempMsgs.size(); i++) {
1360: PrivateMessageDecoratedBean dmb = (PrivateMessageDecoratedBean) tempMsgs
1361: .get(i);
1362: if (i == 0) {
1363: dmb.setHasPre(false);
1364: if (i == (tempMsgs.size() - 1)) {
1365: dmb.setHasNext(false);
1366: } else {
1367: dmb.setHasNext(true);
1368: }
1369: } else if (i == (tempMsgs.size() - 1)) {
1370: dmb.setHasPre(true);
1371: dmb.setHasNext(false);
1372: } else {
1373: dmb.setHasNext(true);
1374: dmb.setHasPre(true);
1375: }
1376: }
1377: }
1378:
1379: /**
1380: * processDisplayPreviousMsg()
1381: * Display the previous message from the list of decorated messages
1382: */
1383: public String processDisplayPreviousMsg() {
1384: List tempMsgs = getDecoratedPvtMsgs(); // all messages
1385: int currentMsgPosition = -1;
1386: if (tempMsgs != null) {
1387: for (int i = 0; i < tempMsgs.size(); i++) {
1388: PrivateMessageDecoratedBean this Dmb = (PrivateMessageDecoratedBean) tempMsgs
1389: .get(i);
1390: if (detailMsg.getMsg().getId().equals(
1391: this Dmb.getMsg().getId())) {
1392: currentMsgPosition = i;
1393: break;
1394: }
1395: }
1396: }
1397:
1398: if (currentMsgPosition > 0) {
1399: PrivateMessageDecoratedBean this Dmb = (PrivateMessageDecoratedBean) tempMsgs
1400: .get(currentMsgPosition - 1);
1401: PrivateMessage message = (PrivateMessage) prtMsgManager
1402: .getMessageById(this Dmb.getMsg().getId());
1403:
1404: detailMsg = new PrivateMessageDecoratedBean(message);
1405: //get attachments
1406: prtMsgManager.markMessageAsReadForUser(detailMsg.getMsg());
1407:
1408: PrivateMessage initPrivateMessage = prtMsgManager
1409: .initMessageWithAttachmentsAndRecipients(detailMsg
1410: .getMsg());
1411: this .setDetailMsg(new PrivateMessageDecoratedBean(
1412: initPrivateMessage));
1413:
1414: List recLs = initPrivateMessage.getRecipients();
1415: for (Iterator iterator = recLs.iterator(); iterator
1416: .hasNext();) {
1417: PrivateMessageRecipient element = (PrivateMessageRecipient) iterator
1418: .next();
1419: if (element != null) {
1420: if ((element.getRead().booleanValue())
1421: || (element.getUserId().equals(getUserId()))) {
1422: getDetailMsg().setHasRead(true);
1423: }
1424: }
1425: }
1426: getDetailMsg().setDepth(this Dmb.getDepth());
1427: getDetailMsg().setHasNext(this Dmb.getHasNext());
1428: getDetailMsg().setHasPre(this Dmb.getHasPre());
1429:
1430: }
1431: return null;
1432: }
1433:
1434: /**
1435: * processDisplayNextMsg()
1436: * Display the Next message from the list of decorated messages
1437: */
1438: public String processDisplayNextMsg() {
1439: List tempMsgs = getDecoratedPvtMsgs();
1440: int currentMsgPosition = -1;
1441: if (tempMsgs != null) {
1442: for (int i = 0; i < tempMsgs.size(); i++) {
1443: PrivateMessageDecoratedBean this Dmb = (PrivateMessageDecoratedBean) tempMsgs
1444: .get(i);
1445: if (detailMsg.getMsg().getId().equals(
1446: this Dmb.getMsg().getId())) {
1447: currentMsgPosition = i;
1448: break;
1449: }
1450: }
1451: }
1452:
1453: if (currentMsgPosition > -2
1454: && currentMsgPosition < (tempMsgs.size() - 1)) {
1455: PrivateMessageDecoratedBean this Dmb = (PrivateMessageDecoratedBean) tempMsgs
1456: .get(currentMsgPosition + 1);
1457: PrivateMessage message = (PrivateMessage) prtMsgManager
1458: .getMessageById(this Dmb.getMsg().getId());
1459: //get attachments
1460: prtMsgManager.markMessageAsReadForUser(this Dmb.getMsg());
1461:
1462: PrivateMessage initPrivateMessage = prtMsgManager
1463: .initMessageWithAttachmentsAndRecipients(this Dmb
1464: .getMsg());
1465: this .setDetailMsg(new PrivateMessageDecoratedBean(
1466: initPrivateMessage));
1467:
1468: List recLs = initPrivateMessage.getRecipients();
1469: for (Iterator iterator = recLs.iterator(); iterator
1470: .hasNext();) {
1471: PrivateMessageRecipient element = (PrivateMessageRecipient) iterator
1472: .next();
1473: if (element != null) {
1474: if ((element.getRead().booleanValue())
1475: || (element.getUserId().equals(getUserId()))) {
1476: getDetailMsg().setHasRead(true);
1477: }
1478: }
1479: }
1480:
1481: getDetailMsg().setDepth(this Dmb.getDepth());
1482: getDetailMsg().setHasNext(this Dmb.getHasNext());
1483: getDetailMsg().setHasPre(this Dmb.getHasPre());
1484: }
1485:
1486: return null;
1487: }
1488:
1489: ///////////////////////////////////// DISPLAY NEXT/PREVIOUS TOPIC //////////////////////////////////
1490: private PrivateTopicDecoratedBean selectedTopic;
1491:
1492: /**
1493: * @return Returns the selectedTopic.
1494: */
1495: public PrivateTopicDecoratedBean getSelectedTopic() {
1496: return selectedTopic;
1497: }
1498:
1499: /**
1500: * @param selectedTopic The selectedTopic to set.
1501: */
1502: public void setSelectedTopic(PrivateTopicDecoratedBean selectedTopic) {
1503: this .selectedTopic = selectedTopic;
1504: }
1505:
1506: /**
1507: * Add prev and next topic UUID value and booleans for display of links
1508: *
1509: */
1510: public void setPrevNextTopicDetails(String msgNavMode) {
1511: for (int i = 0; i < pvtTopics.size(); i++) {
1512: Topic el = (Topic) pvtTopics.get(i);
1513: if (el.getTitle().equals(msgNavMode)) {
1514: setSelectedTopic(new PrivateTopicDecoratedBean(el));
1515: if (i == 0) {
1516: getSelectedTopic().setHasPreviousTopic(false);
1517: if (i == (pvtTopics.size() - 1)) {
1518: getSelectedTopic().setHasNextTopic(false);
1519: } else {
1520: getSelectedTopic().setHasNextTopic(true);
1521: Topic nt = (Topic) pvtTopics.get(i + 1);
1522: if (nt != null) {
1523: //getSelectedTopic().setNextTopicId(nt.getUuid());
1524: getSelectedTopic().setNextTopicTitle(
1525: nt.getTitle());
1526: }
1527: }
1528: } else if (i == (pvtTopics.size() - 1)) {
1529: getSelectedTopic().setHasPreviousTopic(true);
1530: getSelectedTopic().setHasNextTopic(false);
1531:
1532: Topic pt = (Topic) pvtTopics.get(i - 1);
1533: if (pt != null) {
1534: //getSelectedTopic().setPreviousTopicId(pt.getUuid());
1535: getSelectedTopic().setPreviousTopicTitle(
1536: pt.getTitle());
1537: }
1538: } else {
1539: getSelectedTopic().setHasNextTopic(true);
1540: getSelectedTopic().setHasPreviousTopic(true);
1541:
1542: Topic nt = (Topic) pvtTopics.get(i + 1);
1543: if (nt != null) {
1544: //getSelectedTopic().setNextTopicId(nt.getUuid());
1545: getSelectedTopic().setNextTopicTitle(
1546: nt.getTitle());
1547: }
1548: Topic pt = (Topic) pvtTopics.get(i - 1);
1549: if (pt != null) {
1550: //getSelectedTopic().setPreviousTopicId(pt.getUuid());
1551: getSelectedTopic().setPreviousTopicTitle(
1552: pt.getTitle());
1553: }
1554: }
1555:
1556: }
1557: }
1558: //create a selected topic and set the topic id for next/prev topic
1559: }
1560:
1561: /**
1562: * processDisplayPreviousFolder()
1563: */
1564: public String processDisplayPreviousTopic() {
1565: String prevTopicTitle = getExternalParameterByKey("previousTopicTitle");
1566: if (hasValue(prevTopicTitle)) {
1567: msgNavMode = prevTopicTitle;
1568:
1569: decoratedPvtMsgs = new ArrayList();
1570:
1571: String typeUuid = getPrivateMessageTypeFromContext(msgNavMode);
1572:
1573: decoratedPvtMsgs = prtMsgManager.getMessagesByType(
1574: typeUuid, PrivateMessageManager.SORT_COLUMN_DATE,
1575: PrivateMessageManager.SORT_DESC);
1576:
1577: decoratedPvtMsgs = createDecoratedDisplay(decoratedPvtMsgs);
1578:
1579: if (selectView != null
1580: && selectView.equalsIgnoreCase(THREADED_VIEW)) {
1581: this .rearrageTopicMsgsThreaded(false);
1582: }
1583:
1584: //set prev/next Topic
1585: setPrevNextTopicDetails(msgNavMode);
1586: //set prev/next message
1587: setPrevNextMessageDetails();
1588:
1589: }
1590: return null;
1591: }
1592:
1593: /**
1594: * processDisplayNextFolder()
1595: */
1596: public String processDisplayNextTopic() {
1597: String nextTitle = getExternalParameterByKey("nextTopicTitle");
1598: if (hasValue(nextTitle)) {
1599: msgNavMode = nextTitle;
1600: decoratedPvtMsgs = new ArrayList();
1601:
1602: String typeUuid = getPrivateMessageTypeFromContext(msgNavMode);
1603:
1604: decoratedPvtMsgs = prtMsgManager.getMessagesByType(
1605: typeUuid, PrivateMessageManager.SORT_COLUMN_DATE,
1606: PrivateMessageManager.SORT_DESC);
1607:
1608: decoratedPvtMsgs = createDecoratedDisplay(decoratedPvtMsgs);
1609:
1610: if (selectView != null
1611: && selectView.equalsIgnoreCase(THREADED_VIEW)) {
1612: this .rearrageTopicMsgsThreaded(false);
1613: }
1614:
1615: //set prev/next Topic
1616: setPrevNextTopicDetails(msgNavMode);
1617: //set prev/next message
1618: setPrevNextMessageDetails();
1619: }
1620: return null;
1621: }
1622:
1623: ///////////////////////////////////// DISPLAY NEXT/PREVIOUS TOPIC //////////////////////////////////
1624:
1625: //////////////////////////////////////////////////////////
1626: /**
1627: * @param externalTopicId
1628: * @return
1629: */
1630: private String processDisplayMsgById(String externalMsgId) {
1631: LOG.debug("processDisplayMsgById()");
1632: String msgId = getExternalParameterByKey(externalMsgId);
1633: if (msgId != null) {
1634: PrivateMessageDecoratedBean dbean = null;
1635: PrivateMessage msg = (PrivateMessage) prtMsgManager
1636: .getMessageById(new Long(msgId));
1637: if (msg != null) {
1638: dbean
1639: .addPvtMessage(new PrivateMessageDecoratedBean(
1640: msg));
1641: detailMsg = dbean;
1642: }
1643: } else {
1644: LOG.debug("processDisplayMsgById() - Error");
1645: return DISPLAY_MESSAGES_PG;
1646: }
1647: return SELECTED_MESSAGE_PG;
1648: }
1649:
1650: //////////////////////REPLY SEND /////////////////
1651: public String processPvtMsgReplySend() {
1652: LOG.debug("processPvtMsgReplySend()");
1653:
1654: PrivateMessage currentMessage = getDetailMsg().getMsg();
1655:
1656: //by default add user who sent original message
1657: for (Iterator i = totalComposeToList.iterator(); i.hasNext();) {
1658: MembershipItem membershipItem = (MembershipItem) i.next();
1659:
1660: if (MembershipItem.TYPE_USER.equals(membershipItem
1661: .getType())) {
1662: if (membershipItem.getUser() != null) {
1663: if (membershipItem.getUser().getId().equals(
1664: currentMessage.getCreatedBy())) {
1665: selectedComposeToList.add(membershipItem
1666: .getId());
1667: }
1668: }
1669: }
1670: }
1671:
1672: if (!hasValue(getReplyToSubject())) {
1673: setErrorMessage(getResourceBundleString(MISSING_SUBJECT));
1674: return null;
1675: }
1676:
1677: if (selectedComposeToList.size() < 1) {
1678: setErrorMessage(getResourceBundleString(SELECT_RECIPIENT_LIST_FOR_REPLY));
1679: return null;
1680: }
1681:
1682: PrivateMessage rrepMsg = messageManager.createPrivateMessage();
1683:
1684: rrepMsg.setTitle(getReplyToSubject()); //rrepMsg.setTitle(rMsg.getTitle()) ;
1685: rrepMsg.setDraft(Boolean.FALSE);
1686:
1687: rrepMsg.setAuthor(getAuthorString());
1688: rrepMsg.setApproved(Boolean.FALSE);
1689: rrepMsg.setBody(getReplyToBody());
1690:
1691: rrepMsg.setLabel(getSelectedLabel());
1692:
1693: rrepMsg.setInReplyTo(currentMessage);
1694:
1695: //Add the recipientList as String for display in Sent folder
1696: // Since some users may be hidden, if some of these are recipients
1697: // filter them out (already checked if no recipients)
1698: // if only 1 recipient no need to check visibility
1699: String sendToString = "";
1700: String sendToHiddenString = "";
1701:
1702: if (selectedComposeToList.size() == 1) {
1703: MembershipItem membershipItem = (MembershipItem) courseMemberMap
1704: .get(selectedComposeToList.get(0));
1705: if (membershipItem != null) {
1706: sendToString += membershipItem.getName() + "; ";
1707: }
1708: } else {
1709: for (int i = 0; i < selectedComposeToList.size(); i++) {
1710: MembershipItem membershipItem = (MembershipItem) courseMemberMap
1711: .get(selectedComposeToList.get(i));
1712: if (membershipItem != null) {
1713: if (membershipItem.isViewable()) {
1714: sendToString += membershipItem.getName() + "; ";
1715: } else {
1716: sendToHiddenString += membershipItem.getName()
1717: + "; ";
1718: }
1719: }
1720: }
1721: }
1722:
1723: if (!"".equals(sendToString)) {
1724: sendToString = sendToString.substring(0, sendToString
1725: .length() - 2); //remove last comma and space
1726: }
1727:
1728: if ("".equals(sendToHiddenString)) {
1729: rrepMsg.setRecipientsAsText(sendToString);
1730: } else {
1731: sendToHiddenString = sendToHiddenString.substring(0,
1732: sendToHiddenString.length() - 2); //remove last comma and space
1733: rrepMsg.setRecipientsAsText(sendToString + " ("
1734: + sendToHiddenString + ")");
1735: }
1736:
1737: //Add attachments
1738: for (int i = 0; i < allAttachments.size(); i++) {
1739: prtMsgManager.addAttachToPvtMsg(rrepMsg,
1740: ((DecoratedAttachment) allAttachments.get(i))
1741: .getAttachment());
1742: }
1743:
1744: if ((SET_AS_YES).equals(getComposeSendAsPvtMsg())) {
1745: prtMsgManager.sendPrivateMessage(rrepMsg, getRecipients(),
1746: false);
1747: } else {
1748: prtMsgManager.sendPrivateMessage(rrepMsg, getRecipients(),
1749: true);
1750: }
1751:
1752: //reset contents
1753: resetComposeContents();
1754:
1755: return DISPLAY_MESSAGES_PG;
1756:
1757: }
1758:
1759: /**
1760: * process from Compose screen
1761: * @return - pvtMsg
1762: */
1763: public String processPvtMsgReplySaveDraft() {
1764: LOG.debug("processPvtMsgReplySaveDraft()");
1765:
1766: if (!hasValue(getReplyToSubject())) {
1767: setErrorMessage(getResourceBundleString(MISSING_SUBJECT));
1768: return null;
1769: }
1770: // if(!hasValue(getReplyToBody()) )
1771: // {
1772: // setErrorMessage("You must enter a message content before you may send this message.");
1773: // return null ;
1774: // }
1775: if (getSelectedComposeToList().size() < 1) {
1776: setErrorMessage(getResourceBundleString(SELECT_RECIPIENT_LIST_FOR_REPLY));
1777: return null;
1778: }
1779:
1780: PrivateMessage drMsg = getDetailMsg().getMsg();
1781: //drMsg.setDraft(Boolean.TRUE);
1782: PrivateMessage drrepMsg = messageManager.createPrivateMessage();
1783: drrepMsg.setTitle(getReplyToSubject());
1784: drrepMsg.setDraft(Boolean.TRUE);
1785:
1786: drrepMsg.setAuthor(getAuthorString());
1787: drrepMsg.setApproved(Boolean.FALSE);
1788: drrepMsg.setBody(getReplyToBody());
1789:
1790: drrepMsg.setInReplyTo(drMsg);
1791: this .getRecipients().add(drMsg.getCreatedBy());
1792:
1793: //Add attachments
1794: for (int i = 0; i < allAttachments.size(); i++) {
1795: prtMsgManager.addAttachToPvtMsg(drrepMsg,
1796: ((DecoratedAttachment) allAttachments.get(i))
1797: .getAttachment());
1798: }
1799:
1800: if ((SET_AS_YES).equals(getComposeSendAsPvtMsg())) {
1801: prtMsgManager.sendPrivateMessage(drrepMsg, getRecipients(),
1802: false);
1803: } else {
1804: prtMsgManager.sendPrivateMessage(drrepMsg, getRecipients(),
1805: true);
1806: }
1807:
1808: //reset contents
1809: resetComposeContents();
1810:
1811: return DISPLAY_MESSAGES_PG;
1812: }
1813:
1814: ////////////////////////////////////////////////////////////////
1815: public String processPvtMsgEmptyDelete() {
1816: LOG.debug("processPvtMsgEmptyDelete()");
1817:
1818: List delSelLs = new ArrayList();
1819: //this.setDisplayPvtMsgs(getDisplayPvtMsgs());
1820: for (Iterator iter = this .decoratedPvtMsgs.iterator(); iter
1821: .hasNext();) {
1822: PrivateMessageDecoratedBean element = (PrivateMessageDecoratedBean) iter
1823: .next();
1824: if (element.getIsSelected()) {
1825: delSelLs.add(element);
1826: }
1827: }
1828: this .setSelectedDeleteItems(delSelLs);
1829: if (delSelLs.size() < 1) {
1830: setErrorMessage(getResourceBundleString(SELECT_MSGS_TO_DELETE));
1831: return null; //stay in the same page if nothing is selected for delete
1832: } else {
1833: setErrorMessage(getResourceBundleString(CONFIRM_PERM_MSG_DELETE));
1834: return DELETE_MESSAGE_PG;
1835: }
1836: }
1837:
1838: //delete private message
1839: public String processPvtMsgMultiDelete() {
1840: LOG.debug("processPvtMsgMultiDelete()");
1841:
1842: for (Iterator iter = getSelectedDeleteItems().iterator(); iter
1843: .hasNext();) {
1844: PrivateMessage element = ((PrivateMessageDecoratedBean) iter
1845: .next()).getMsg();
1846: if (element != null) {
1847: prtMsgManager.deletePrivateMessage(element,
1848: getPrivateMessageTypeFromContext(msgNavMode));
1849: }
1850: }
1851: return DISPLAY_MESSAGES_PG;
1852: }
1853:
1854: public String processPvtMsgDispOtions() {
1855: LOG.debug("processPvtMsgDispOptions()");
1856:
1857: return "pvtMsgOrganize";
1858: }
1859:
1860: /////////////////////////// Process Select All ///////////////////////////////
1861: private boolean selectAll = false;
1862:
1863: public boolean isSelectAll() {
1864: return selectAll;
1865: }
1866:
1867: public void setSelectAll(boolean selectAll) {
1868: this .selectAll = selectAll;
1869: }
1870:
1871: /**
1872: * process isSelected for all decorated messages
1873: * @return same page i.e. will be pvtMsg
1874: */
1875: public String processCheckAll() {
1876: LOG.debug("processCheckAll()");
1877: selectAll = true;
1878:
1879: return null;
1880: }
1881:
1882: ////////////////////////////// ATTACHMENT PROCESSING //////////////////////////
1883: private ArrayList attachments = new ArrayList();
1884:
1885: private String removeAttachId = null;
1886: private ArrayList prepareRemoveAttach = new ArrayList();
1887: private boolean attachCaneled = false;
1888: private ArrayList oldAttachments = new ArrayList();
1889: private List allAttachments = new ArrayList();
1890:
1891: public ArrayList getAttachments() {
1892: ToolSession session = SessionManager.getCurrentToolSession();
1893: if (session.getAttribute(FilePickerHelper.FILE_PICKER_CANCEL) == null
1894: && session
1895: .getAttribute(FilePickerHelper.FILE_PICKER_ATTACHMENTS) != null) {
1896: List refs = (List) session
1897: .getAttribute(FilePickerHelper.FILE_PICKER_ATTACHMENTS);
1898: if (refs != null && refs.size() > 0) {
1899: Reference ref = (Reference) refs.get(0);
1900:
1901: for (int i = 0; i < refs.size(); i++) {
1902: ref = (Reference) refs.get(i);
1903: Attachment this Attach = prtMsgManager
1904: .createPvtMsgAttachment(
1905: ref.getId(),
1906: ref
1907: .getProperties()
1908: .getProperty(
1909: ref
1910: .getProperties()
1911: .getNamePropDisplayName()));
1912:
1913: //TODO - remove this as being set for test only
1914: //thisAttach.setPvtMsgAttachId(new Long(1));
1915:
1916: attachments
1917: .add(new DecoratedAttachment(this Attach));
1918:
1919: }
1920: }
1921: }
1922: session
1923: .removeAttribute(FilePickerHelper.FILE_PICKER_ATTACHMENTS);
1924: session.removeAttribute(FilePickerHelper.FILE_PICKER_CANCEL);
1925:
1926: return attachments;
1927: }
1928:
1929: public List getAllAttachments() {
1930: ToolSession session = SessionManager.getCurrentToolSession();
1931: if (session.getAttribute(FilePickerHelper.FILE_PICKER_CANCEL) == null
1932: && session
1933: .getAttribute(FilePickerHelper.FILE_PICKER_ATTACHMENTS) != null) {
1934: List refs = (List) session
1935: .getAttribute(FilePickerHelper.FILE_PICKER_ATTACHMENTS);
1936: if (refs != null && refs.size() > 0) {
1937: Reference ref = (Reference) refs.get(0);
1938:
1939: for (int i = 0; i < refs.size(); i++) {
1940: ref = (Reference) refs.get(i);
1941: Attachment this Attach = prtMsgManager
1942: .createPvtMsgAttachment(
1943: ref.getId(),
1944: ref
1945: .getProperties()
1946: .getProperty(
1947: ref
1948: .getProperties()
1949: .getNamePropDisplayName()));
1950:
1951: //TODO - remove this as being set for test only
1952: //thisAttach.setPvtMsgAttachId(new Long(1));
1953: allAttachments.add(new DecoratedAttachment(
1954: this Attach));
1955: }
1956: }
1957: }
1958: session
1959: .removeAttribute(FilePickerHelper.FILE_PICKER_ATTACHMENTS);
1960: session.removeAttribute(FilePickerHelper.FILE_PICKER_CANCEL);
1961:
1962: // if( allAttachments == null || (allAttachments.size()<1))
1963: // {
1964: // allAttachments.addAll(this.getDetailMsg().getMsg().getAttachments()) ;
1965: // }
1966: return allAttachments;
1967: }
1968:
1969: public void setAttachments(ArrayList attachments) {
1970: this .attachments = attachments;
1971: }
1972:
1973: public String getRemoveAttachId() {
1974: return removeAttachId;
1975: }
1976:
1977: public final void setRemoveAttachId(String removeAttachId) {
1978: this .removeAttachId = removeAttachId;
1979: }
1980:
1981: public ArrayList getPrepareRemoveAttach() {
1982: if ((removeAttachId != null) && (!removeAttachId.equals(""))) {
1983: prepareRemoveAttach.add(prtMsgManager
1984: .getPvtMsgAttachment(new Long(removeAttachId)));
1985: }
1986:
1987: return prepareRemoveAttach;
1988: }
1989:
1990: public final void setPrepareRemoveAttach(
1991: ArrayList prepareRemoveAttach) {
1992: this .prepareRemoveAttach = prepareRemoveAttach;
1993: }
1994:
1995: //Redirect to File picker
1996: public String processAddAttachmentRedirect() {
1997: LOG.debug("processAddAttachmentRedirect()");
1998: try {
1999: ExternalContext context = FacesContext.getCurrentInstance()
2000: .getExternalContext();
2001: context.redirect("sakai.filepicker.helper/tool");
2002: return null;
2003: } catch (Exception e) {
2004: LOG.debug("processAddAttachmentRedirect() - Exception");
2005: return null;
2006: }
2007: }
2008:
2009: //Process remove attachment
2010: public String processDeleteAttach() {
2011: LOG.debug("processDeleteAttach()");
2012:
2013: ExternalContext context = FacesContext.getCurrentInstance()
2014: .getExternalContext();
2015: String attachId = null;
2016:
2017: Map paramMap = context.getRequestParameterMap();
2018: Iterator itr = paramMap.keySet().iterator();
2019: while (itr.hasNext()) {
2020: Object key = itr.next();
2021: if (key instanceof String) {
2022: String name = (String) key;
2023: int pos = name.lastIndexOf("pvmsg_current_attach");
2024:
2025: if (pos >= 0
2026: && name.length() == pos
2027: + "pvmsg_current_attach".length()) {
2028: attachId = (String) paramMap.get(key);
2029: break;
2030: }
2031: }
2032: }
2033:
2034: if ((attachId != null) && (!attachId.equals(""))) {
2035: for (int i = 0; i < attachments.size(); i++) {
2036: if (attachId
2037: .equalsIgnoreCase(((DecoratedAttachment) attachments
2038: .get(i)).getAttachment()
2039: .getAttachmentId())) {
2040: attachments.remove(i);
2041: break;
2042: }
2043: }
2044: }
2045:
2046: return null;
2047: }
2048:
2049: //Process remove attachments from reply message
2050: public String processDeleteReplyAttach() {
2051: LOG.debug("processDeleteReplyAttach()");
2052:
2053: ExternalContext context = FacesContext.getCurrentInstance()
2054: .getExternalContext();
2055: String attachId = null;
2056:
2057: Map paramMap = context.getRequestParameterMap();
2058: Iterator itr = paramMap.keySet().iterator();
2059: while (itr.hasNext()) {
2060: Object key = itr.next();
2061: if (key instanceof String) {
2062: String name = (String) key;
2063: int pos = name.lastIndexOf("remsg_current_attach");
2064:
2065: if (pos >= 0
2066: && name.length() == pos
2067: + "remsg_current_attach".length()) {
2068: attachId = (String) paramMap.get(key);
2069: break;
2070: }
2071: }
2072: }
2073:
2074: if ((attachId != null) && (!attachId.equals(""))) {
2075: for (int i = 0; i < allAttachments.size(); i++) {
2076: if (attachId
2077: .equalsIgnoreCase(((DecoratedAttachment) allAttachments
2078: .get(i)).getAttachment()
2079: .getAttachmentId())) {
2080: allAttachments.remove(i);
2081: break;
2082: }
2083: }
2084: }
2085:
2086: return null;
2087: }
2088:
2089: //process deleting confirm from separate screen
2090: public String processRemoveAttach() {
2091: LOG.debug("processRemoveAttach()");
2092:
2093: try {
2094: Attachment sa = prtMsgManager.getPvtMsgAttachment(new Long(
2095: removeAttachId));
2096: String id = sa.getAttachmentId();
2097:
2098: for (int i = 0; i < attachments.size(); i++) {
2099: DecoratedAttachment this Attach = (DecoratedAttachment) attachments
2100: .get(i);
2101: if (((Long) this Attach.getAttachment()
2102: .getPvtMsgAttachId()).toString().equals(
2103: removeAttachId)) {
2104: attachments.remove(i);
2105: break;
2106: }
2107: }
2108:
2109: ContentResource cr = ContentHostingService.getResource(id);
2110: prtMsgManager.removePvtMsgAttachment(sa);
2111: if (id.toLowerCase().startsWith("/attachment"))
2112: ContentHostingService.removeResource(id);
2113: } catch (Exception e) {
2114: LOG.debug("processRemoveAttach() - Exception");
2115: }
2116:
2117: removeAttachId = null;
2118: prepareRemoveAttach.clear();
2119: return COMPOSE_MSG_PG;
2120:
2121: }
2122:
2123: public String processRemoveAttachCancel() {
2124: LOG.debug("processRemoveAttachCancel()");
2125:
2126: removeAttachId = null;
2127: prepareRemoveAttach.clear();
2128: return COMPOSE_MSG_PG;
2129: }
2130:
2131: //////////// SETTINGS //////////////////////////////
2132: //Setting Getter and Setter
2133: public String getActivatePvtMsg() {
2134: return activatePvtMsg;
2135: }
2136:
2137: public void setActivatePvtMsg(String activatePvtMsg) {
2138: this .activatePvtMsg = activatePvtMsg;
2139: }
2140:
2141: public String getForwardPvtMsg() {
2142: return forwardPvtMsg;
2143: }
2144:
2145: public void setForwardPvtMsg(String forwardPvtMsg) {
2146: this .forwardPvtMsg = forwardPvtMsg;
2147: }
2148:
2149: public String getForwardPvtMsgEmail() {
2150: return forwardPvtMsgEmail;
2151: }
2152:
2153: public void setForwardPvtMsgEmail(String forwardPvtMsgEmail) {
2154: this .forwardPvtMsgEmail = forwardPvtMsgEmail;
2155: }
2156:
2157: public boolean getSuperUser() {
2158: super User = SecurityService.isSuperUser();
2159: return super User;
2160: }
2161:
2162: //is instructor
2163: public boolean isInstructor() {
2164: return prtMsgManager.isInstructor();
2165: }
2166:
2167: public void setSuperUser(boolean super User) {
2168: this .super User = super User;
2169: }
2170:
2171: public String processPvtMsgOrganize() {
2172: LOG.debug("processPvtMsgOrganize()");
2173: return null;
2174: //return "pvtMsgOrganize";
2175: }
2176:
2177: public String processPvtMsgStatistics() {
2178: LOG.debug("processPvtMsgStatistics()");
2179:
2180: return null;
2181: //return "pvtMsgStatistics";
2182: }
2183:
2184: public String processPvtMsgSettings() {
2185: LOG.debug("processPvtMsgSettings()");
2186: return MESSAGE_SETTING_PG;
2187: }
2188:
2189: public void processPvtMsgSettingsRevise(ValueChangeEvent event) {
2190: LOG.debug("processPvtMsgSettingsRevise()");
2191:
2192: /** block executes when changing value to "no" */
2193: if (SET_AS_YES.equals(forwardPvtMsg)) {
2194: setForwardPvtMsgEmail(null);
2195: }
2196: if (SET_AS_NO.equals(forwardPvtMsg)) {
2197: setValidEmail(true);
2198: }
2199: }
2200:
2201: public String processPvtMsgSettingsSave() {
2202: LOG.debug("processPvtMsgSettingsSave()");
2203:
2204: String email = getForwardPvtMsgEmail();
2205: String activate = getActivatePvtMsg();
2206: String forward = getForwardPvtMsg();
2207: if (email != null && (!SET_AS_NO.equals(forward))
2208: && (!email.matches(".+@.+\\..+"))) {
2209: setValidEmail(false);
2210: setErrorMessage(getResourceBundleString(PROVIDE_VALID_EMAIL));
2211: setActivatePvtMsg(activate);
2212: return MESSAGE_SETTING_PG;
2213: } else {
2214: Area area = prtMsgManager.getPrivateMessageArea();
2215:
2216: Boolean formAreaEnabledValue = (SET_AS_YES.equals(activate)) ? Boolean.TRUE
2217: : Boolean.FALSE;
2218: area.setEnabled(formAreaEnabledValue);
2219:
2220: Boolean formAutoForward = (SET_AS_YES.equals(forward)) ? Boolean.TRUE
2221: : Boolean.FALSE;
2222: forum.setAutoForward(formAutoForward);
2223: if (Boolean.TRUE.equals(formAutoForward)) {
2224: forum.setAutoForwardEmail(email);
2225: } else {
2226: forum.setAutoForwardEmail(null);
2227: }
2228:
2229: prtMsgManager.saveAreaAndForumSettings(area, forum);
2230:
2231: if (isMessagesandForums()) {
2232: return MAIN_PG;
2233: } else {
2234: return MESSAGE_HOME_PG;
2235: }
2236: }
2237:
2238: }
2239:
2240: /////////////////// FOLDER SETTINGS ///////////////////////
2241: private String addFolder;
2242: private boolean ismutable;
2243: private int totalMsgInFolder;
2244:
2245: public String getAddFolder() {
2246: return addFolder;
2247: }
2248:
2249: public void setAddFolder(String addFolder) {
2250: this .addFolder = addFolder;
2251: }
2252:
2253: public boolean getIsmutable() {
2254: return prtMsgManager.isMutableTopicFolder(getSelectedTopicId());
2255: }
2256:
2257: public int getTotalMsgInFolder() {
2258: return totalMsgInFolder;
2259: }
2260:
2261: public void setTotalMsgInFolder(int totalMsgInFolder) {
2262: this .totalMsgInFolder = totalMsgInFolder;
2263: }
2264:
2265: //navigated from header pagecome from Header page
2266: public String processPvtMsgFolderSettings() {
2267: LOG.debug("processPvtMsgFolderSettings()");
2268: //String topicTitle= getExternalParameterByKey("pvtMsgTopicTitle");
2269: String topicTitle = forumManager.getTopicByUuid(
2270: getExternalParameterByKey("pvtMsgTopicId")).getTitle();
2271: setSelectedTopicTitle(topicTitle);
2272: String topicId = getExternalParameterByKey("pvtMsgTopicId");
2273: setSelectedTopicId(topicId);
2274:
2275: setFromMainOrHp();
2276:
2277: return MESSAGE_FOLDER_SETTING_PG;
2278: }
2279:
2280: public String processPvtMsgFolderSettingRevise() {
2281: LOG.debug("processPvtMsgFolderSettingRevise()");
2282:
2283: if (this .ismutable) {
2284: return null;
2285: } else {
2286: selectedNewTopicTitle = selectedTopicTitle;
2287: return REVISE_FOLDER_PG;
2288: }
2289: }
2290:
2291: public String processPvtMsgFolderSettingAdd() {
2292: LOG.debug("processPvtMsgFolderSettingAdd()");
2293:
2294: setFromMainOrHp();
2295: this .setAddFolder(""); // make sure the input box is empty
2296:
2297: return ADD_MESSAGE_FOLDER_PG;
2298: }
2299:
2300: public String processPvtMsgFolderSettingDelete() {
2301: LOG.debug("processPvtMsgFolderSettingDelete()");
2302:
2303: setFromMainOrHp();
2304:
2305: String typeUuid = getPrivateMessageTypeFromContext(selectedTopicTitle);
2306:
2307: setTotalMsgInFolder(prtMsgManager.findMessageCount(typeUuid));
2308:
2309: if (ismutable) {
2310: setErrorMessage(getResourceBundleString(CANNOT_DEL_REVISE_FOLDER));
2311: return null;
2312: } else {
2313: setErrorMessage(getResourceBundleString(CONFIRM_FOLDER_DELETE));
2314: return DELETE_FOLDER_PG;
2315: }
2316: }
2317:
2318: public String processPvtMsgReturnToMainOrHp() {
2319: LOG.debug("processPvtMsgReturnToMainOrHp()");
2320: if (fromMainOrHp != null
2321: && (fromMainOrHp.equals(MESSAGE_HOME_PG) || (fromMainOrHp
2322: .equals(MAIN_PG)))) {
2323: String returnToPage = fromMainOrHp;
2324: fromMainOrHp = "";
2325: return returnToPage;
2326: } else {
2327: return MAIN_PG;
2328: }
2329: }
2330:
2331: public String processPvtMsgReturnToFolderView() {
2332: return MESSAGE_FOLDER_SETTING_PG;
2333: }
2334:
2335: //Create a folder within a forum
2336: public String processPvtMsgFldCreate() {
2337: LOG.debug("processPvtMsgFldCreate()");
2338:
2339: String createFolder = getAddFolder();
2340: if (createFolder == null || createFolder.trim().length() == 0) {
2341: setErrorMessage(getResourceBundleString(ENTER_FOLDER_NAME));
2342: return null;
2343: } else {
2344: if (PVTMSG_MODE_RECEIVED.equals(createFolder)
2345: || PVTMSG_MODE_SENT.equals(createFolder)
2346: || PVTMSG_MODE_DELETE.equals(createFolder)
2347: || PVTMSG_MODE_DRAFT.equals(createFolder)) {
2348: setErrorMessage(getResourceBundleString(CREATE_DIFF_FOLDER_NAME));
2349: } else {
2350: prtMsgManager.createTopicFolderInForum(forum,
2351: createFolder);
2352: //create a typeUUID in commons
2353: String newTypeUuid = typeManager
2354: .getCustomTopicType(createFolder);
2355: }
2356: //since PrivateMessagesTool has a session scope,
2357: //reset addFolder to blank for new form
2358: addFolder = "";
2359: return processPvtMsgReturnToMainOrHp();
2360: }
2361: }
2362:
2363: private String selectedNewTopicTitle = selectedTopicTitle; //default
2364:
2365: public String getSelectedNewTopicTitle() {
2366: return selectedNewTopicTitle;
2367: }
2368:
2369: public void setSelectedNewTopicTitle(String selectedNewTopicTitle) {
2370: this .selectedNewTopicTitle = selectedNewTopicTitle;
2371: }
2372:
2373: /**
2374: * revise
2375: **/
2376: public String processPvtMsgFldRevise() {
2377: LOG.debug("processPvtMsgFldRevise()");
2378:
2379: String newTopicTitle = this .getSelectedNewTopicTitle();
2380:
2381: if (!hasValue(newTopicTitle)) {
2382: setErrorMessage(getResourceBundleString(FOLDER_NAME_BLANK));
2383: return REVISE_FOLDER_PG;
2384: } else {
2385: List tmpMsgList = prtMsgManager.getMessagesByType(
2386: typeManager
2387: .getCustomTopicType(prtMsgManager
2388: .getTopicByUuid(selectedTopicId)
2389: .getTitle()),
2390: PrivateMessageManager.SORT_COLUMN_DATE,
2391: PrivateMessageManager.SORT_ASC);
2392: prtMsgManager.renameTopicFolder(forum, selectedTopicId,
2393: newTopicTitle);
2394: //rename topic in commons -- as messages are linked through commons type
2395: //TODO - what if more than one type objects are returned-- We need to switch from title
2396: String newTypeUuid = typeManager.renameCustomTopicType(
2397: selectedTopicTitle, newTopicTitle);
2398: for (int i = 0; i < tmpMsgList.size(); i++) {
2399: PrivateMessage tmpPM = (PrivateMessage) tmpMsgList
2400: .get(i);
2401: List tmpRecipList = tmpPM.getRecipients();
2402: tmpPM.setTypeUuid(newTypeUuid);
2403: String currentUserId = SessionManager
2404: .getCurrentSessionUserId();
2405: Iterator iter = tmpRecipList.iterator();
2406: while (iter.hasNext()) {
2407: PrivateMessageRecipient tmpPMR = (PrivateMessageRecipient) iter
2408: .next();
2409: if (tmpPMR != null
2410: && tmpPMR.getUserId().equals(currentUserId)) {
2411: tmpPMR.setTypeUuid(newTypeUuid);
2412: }
2413: }
2414: tmpPM.setRecipients(tmpRecipList);
2415: prtMsgManager.savePrivateMessage(tmpPM);
2416: }
2417: }
2418: setSelectedTopicTitle(newTopicTitle);
2419: return MESSAGE_FOLDER_SETTING_PG;
2420: }
2421:
2422: //Delete
2423: public String processPvtMsgFldDelete() {
2424: LOG.debug("processPvtMsgFldDelete()");
2425:
2426: prtMsgManager.deleteTopicFolder(forum, getSelectedTopicId());
2427:
2428: //delete the messages
2429: String typeUuid = getPrivateMessageTypeFromContext(selectedTopicTitle);
2430: List allPvtMsgs = prtMsgManager.getMessagesByType(typeUuid,
2431: PrivateMessageManager.SORT_COLUMN_DATE,
2432: PrivateMessageManager.SORT_DESC);
2433: for (Iterator iter = allPvtMsgs.iterator(); iter.hasNext();) {
2434: PrivateMessage element = (PrivateMessage) iter.next();
2435: prtMsgManager.deletePrivateMessage(element, typeUuid);
2436: }
2437: return processPvtMsgReturnToMainOrHp();
2438: }
2439:
2440: //create folder within folder
2441: public String processPvtMsgFolderInFolderAdd() {
2442: LOG.debug("processPvtMsgFolderSettingAdd()");
2443:
2444: setFromMainOrHp();
2445: this .setAddFolder("");
2446:
2447: return ADD_FOLDER_IN_FOLDER_PG;
2448: }
2449:
2450: //create folder within Folder
2451: //TODO - add parent fodler id for this
2452: public String processPvtMsgFldInFldCreate() {
2453: LOG.debug("processPvtMsgFldCreate()");
2454:
2455: PrivateTopic parentTopic = (PrivateTopic) prtMsgManager
2456: .getTopicByUuid(selectedTopicId);
2457:
2458: String createFolder = getAddFolder();
2459: if (createFolder == null || createFolder.trim().length() == 0) {
2460: setErrorMessage(getResourceBundleString(ENTER_FOLDER_NAME));
2461: return null;
2462: } else {
2463: if (PVTMSG_MODE_RECEIVED.equals(createFolder)
2464: || PVTMSG_MODE_SENT.equals(createFolder)
2465: || PVTMSG_MODE_DELETE.equals(createFolder)
2466: || PVTMSG_MODE_DRAFT.equals(createFolder)) {
2467: setErrorMessage(CREATE_DIFF_FOLDER_NAME);
2468: } else {
2469: prtMsgManager.createTopicFolderInTopic(forum,
2470: parentTopic, createFolder);
2471: //create a typeUUID in commons
2472: String newTypeUuid = typeManager
2473: .getCustomTopicType(createFolder);
2474: }
2475:
2476: addFolder = "";
2477: return processPvtMsgReturnToMainOrHp();
2478: }
2479: }
2480:
2481: ///////////////////// MOVE //////////////////////
2482: private String moveToTopic = "";
2483: private String moveToNewTopic = "";
2484:
2485: public String getMoveToTopic() {
2486: if (hasValue(moveToNewTopic)) {
2487: moveToTopic = moveToNewTopic;
2488: }
2489: return moveToTopic;
2490: }
2491:
2492: public void setMoveToTopic(String moveToTopic) {
2493: this .moveToTopic = moveToTopic;
2494: }
2495:
2496: /**
2497: * called from Single delete Page
2498: * @return - pvtMsgMove
2499: */
2500: public String processPvtMsgMove() {
2501: LOG.debug("processPvtMsgMove()");
2502: return MOVE_MESSAGE_PG;
2503: }
2504:
2505: public void processPvtMsgParentFolderMove(ValueChangeEvent event) {
2506: LOG.debug("processPvtMsgSettingsRevise()");
2507: if ((String) event.getNewValue() != null) {
2508: moveToNewTopic = (String) event.getNewValue();
2509: }
2510: }
2511:
2512: public String processPvtMsgMoveMessage() {
2513: LOG.debug("processPvtMsgMoveMessage()");
2514: String moveTopicTitle = getMoveToTopic(); //this is uuid of new topic
2515: if (moveTopicTitle == null
2516: || moveTopicTitle.trim().length() == 0) {
2517: setErrorMessage(getResourceBundleString(MOVE_MSG_ERROR));
2518: return null;
2519: }
2520:
2521: Topic newTopic = prtMsgManager.getTopicByUuid(moveTopicTitle);
2522: Topic oldTopic = selectedTopic.getTopic();
2523: if (newTopic.getUuid() == oldTopic.getUuid()) {
2524: //error
2525: setErrorMessage(getResourceBundleString(MOVE_MSG_ERROR));
2526: return null;
2527: } else {
2528: prtMsgManager.movePvtMsgTopic(detailMsg.getMsg(), oldTopic,
2529: newTopic);
2530:
2531: //reset
2532: moveToTopic = "";
2533: moveToNewTopic = "";
2534:
2535: // Return to Messages & Forums page or Messages page
2536: // TODO: once message moved, where to return to?
2537: if (isMessagesandForums()) {
2538: return MAIN_PG;
2539: } else {
2540: return MESSAGE_HOME_PG;
2541: }
2542: }
2543: }
2544:
2545: /**
2546: *
2547: * @return
2548: */
2549: public String processPvtMsgCancelToDetailView() {
2550: LOG.debug("processPvtMsgCancelToDetailView()");
2551: this .deleteConfirm = false;
2552: return SELECTED_MESSAGE_PG;
2553: }
2554:
2555: /////////////// SEARCH ///////////////////////
2556: private List searchPvtMsgs;
2557:
2558: public List getSearchPvtMsgs() {
2559: if (selectView != null
2560: && selectView.equalsIgnoreCase(THREADED_VIEW)) {
2561: this .rearrageTopicMsgsThreaded(true);
2562: }
2563: // If "check all", update the decorated pmb to show selected
2564: if (selectAll) {
2565: Iterator searchIter = searchPvtMsgs.iterator();
2566: while (searchIter.hasNext()) {
2567: PrivateMessageDecoratedBean searchMsg = (PrivateMessageDecoratedBean) searchIter
2568: .next();
2569: searchMsg.setIsSelected(true);
2570: }
2571:
2572: selectAll = false;
2573: }
2574: return searchPvtMsgs;
2575: }
2576:
2577: public void setSearchPvtMsgs(List searchPvtMsgs) {
2578: this .searchPvtMsgs = searchPvtMsgs;
2579: }
2580:
2581: public String processSearch() {
2582: LOG.debug("processSearch()");
2583:
2584: List newls = new ArrayList();
2585: // for (Iterator iter = getDecoratedPvtMsgs().iterator(); iter.hasNext();)
2586: // {
2587: // PrivateMessageDecoratedBean element = (PrivateMessageDecoratedBean) iter.next();
2588: //
2589: // String message=element.getMsg().getTitle();
2590: // String searchText = getSearchText();
2591: // //if search on subject is set - default is true
2592: // if(searchOnSubject)
2593: // {
2594: // StringTokenizer st = new StringTokenizer(message);
2595: // while (st.hasMoreTokens())
2596: // {
2597: // if(st.nextToken().matches("(?i).*getSearchText().*")) //matches anywhere
2598: // //if(st.nextToken().equalsIgnoreCase(getSearchText()))
2599: // {
2600: // newls.add(element) ;
2601: // break;
2602: // }
2603: // }
2604: // }
2605: // //is search
2606: //
2607: // }
2608:
2609: /**TODO -
2610: * In advance srearch as there can be ANY type of combination like selection of
2611: * ANY 1 or 2 or 3 or 4 or 5 options like - subject, Author By, label, body and date
2612: * so all possible cases are taken care off.
2613: * This doesn't look nice, but good this is that we are using same method - our backend is cleaner
2614: * First - checked if date is selected then purmutation of 4 options
2615: * ELSE - permutations of other 4 options
2616: */
2617: List tempPvtMsgLs = new ArrayList();
2618:
2619: if (searchOnDate && searchFromDate == null
2620: && searchToDate == null) {
2621: setErrorMessage(getResourceBundleString(MISSING_BEG_END_DATE));
2622: }
2623:
2624: if (!hasValue(searchText)) {
2625: setErrorMessage(getResourceBundleString(ENTER_SEARCH_TEXT));
2626: }
2627:
2628: tempPvtMsgLs = prtMsgManager.searchPvtMsgs(
2629: getPrivateMessageTypeFromContext(msgNavMode),
2630: getSearchText(), getSearchFromDate(),
2631: getSearchToDate(), searchOnSubject, searchOnAuthor,
2632: searchOnBody, searchOnLabel, searchOnDate);
2633:
2634: newls = createDecoratedDisplay(tempPvtMsgLs);
2635: //
2636: // for (Iterator iter = tempPvtMsgLs.iterator(); iter.hasNext();)
2637: // {
2638: // PrivateMessage element = (PrivateMessage) iter.next();
2639: // PrivateMessageDecoratedBean dbean = new PrivateMessageDecoratedBean(element);
2640: //
2641: // //getRecipients() is filtered for this perticular user i.e. returned list of only one PrivateMessageRecipient object
2642: // for (Iterator iterator = element.getRecipients().iterator(); iterator.hasNext();)
2643: // {
2644: // PrivateMessageRecipient el = (PrivateMessageRecipient) iterator.next();
2645: // if (el != null){
2646: // if(!el.getRead().booleanValue())
2647: // {
2648: // dbean.setHasRead(el.getRead().booleanValue());
2649: // break;
2650: // }
2651: // }
2652: // }
2653: // //Add decorate 'TO' String for sent message
2654: // if(PVTMSG_MODE_SENT.equals(msgNavMode))
2655: // {
2656: // dbean.setSendToStringDecorated(createDecoratedSentToDisplay(dbean));
2657: // }
2658: // newls.add(dbean);
2659: // }
2660: //set threaded view as false in search
2661: selectView = "";
2662:
2663: if (newls.size() > 0) {
2664: this .setSearchPvtMsgs(newls);
2665: return SEARCH_RESULT_MESSAGES_PG;
2666: } else {
2667: setErrorMessage(getResourceBundleString(NO_MATCH_FOUND));
2668: return null;
2669: }
2670: }
2671:
2672: /**
2673: * Clear Search text
2674: */
2675: public String processClearSearch() {
2676: searchText = "";
2677: if (searchPvtMsgs != null) {
2678: searchPvtMsgs.clear();
2679: //searchPvtMsgs= decoratedPvtMsgs;
2680: }
2681:
2682: searchOnBody = false;
2683: searchOnSubject = true;
2684: searchOnLabel = false;
2685: searchOnAuthor = false;
2686: searchOnDate = false;
2687: searchFromDate = null;
2688: searchToDate = null;
2689:
2690: return DISPLAY_MESSAGES_PG;
2691: }
2692:
2693: public boolean searchOnBody = false;
2694: public boolean searchOnSubject = true; //default is search on Subject
2695: public boolean searchOnLabel = false;
2696: public boolean searchOnAuthor = false;
2697: public boolean searchOnDate = false;
2698: public Date searchFromDate;
2699: public Date searchToDate;
2700:
2701: public boolean isSearchOnAuthor() {
2702: return searchOnAuthor;
2703: }
2704:
2705: public void setSearchOnAuthor(boolean searchOnAuthor) {
2706: this .searchOnAuthor = searchOnAuthor;
2707: }
2708:
2709: public boolean isSearchOnBody() {
2710: return searchOnBody;
2711: }
2712:
2713: public void setSearchOnBody(boolean searchOnBody) {
2714: this .searchOnBody = searchOnBody;
2715: }
2716:
2717: public boolean isSearchOnLabel() {
2718: return searchOnLabel;
2719: }
2720:
2721: public void setSearchOnLabel(boolean searchOnLabel) {
2722: this .searchOnLabel = searchOnLabel;
2723: }
2724:
2725: public boolean isSearchOnSubject() {
2726: return searchOnSubject;
2727: }
2728:
2729: public void setSearchOnSubject(boolean searchOnSubject) {
2730: this .searchOnSubject = searchOnSubject;
2731: }
2732:
2733: public boolean isSearchOnDate() {
2734: return searchOnDate;
2735: }
2736:
2737: public void setSearchOnDate(boolean searchOnDate) {
2738: this .searchOnDate = searchOnDate;
2739: }
2740:
2741: public Date getSearchFromDate() {
2742: return searchFromDate;
2743: }
2744:
2745: public void setSearchFromDate(Date searchFromDate) {
2746: this .searchFromDate = searchFromDate;
2747: }
2748:
2749: public Date getSearchToDate() {
2750: return searchToDate;
2751: }
2752:
2753: public void setSearchToDate(Date searchToDate) {
2754: this .searchToDate = searchToDate;
2755: }
2756:
2757: ////////////// HELPER //////////////////////////////////
2758: /**
2759: * @return
2760: */
2761: private String getExternalParameterByKey(String parameterId) {
2762: ExternalContext context = FacesContext.getCurrentInstance()
2763: .getExternalContext();
2764: Map paramMap = context.getRequestParameterMap();
2765:
2766: return (String) paramMap.get(parameterId);
2767: }
2768:
2769: /**
2770: * decorated display - from List of Message
2771: */
2772: public List createDecoratedDisplay(List msg) {
2773: List decLs = new ArrayList();
2774: for (Iterator iter = msg.iterator(); iter.hasNext();) {
2775: PrivateMessage element = (PrivateMessage) iter.next();
2776:
2777: PrivateMessageDecoratedBean dbean = new PrivateMessageDecoratedBean(
2778: element);
2779: //if processSelectAll is set, then set isSelected true for all messages,
2780: if (selectAll) {
2781: dbean.setIsSelected(true);
2782: }
2783:
2784: //getRecipients() is filtered for this perticular user i.e. returned list of only one PrivateMessageRecipient object
2785: for (Iterator iterator = element.getRecipients().iterator(); iterator
2786: .hasNext();) {
2787: PrivateMessageRecipient el = (PrivateMessageRecipient) iterator
2788: .next();
2789: if (el != null) {
2790: dbean.setHasRead(el.getRead().booleanValue());
2791: }
2792: }
2793: //Add decorate 'TO' String for sent message
2794: if (PVTMSG_MODE_SENT.equals(msgNavMode)) {
2795: dbean
2796: .setSendToStringDecorated(createDecoratedSentToDisplay(dbean));
2797: }
2798:
2799: decLs.add(dbean);
2800: }
2801: //reset selectAll flag, for future use
2802: selectAll = false;
2803: return decLs;
2804: }
2805:
2806: /**
2807: * create decorated display for Sent To display for Sent folder
2808: * @param dbean
2809: * @return
2810: */
2811: public String createDecoratedSentToDisplay(
2812: PrivateMessageDecoratedBean dbean) {
2813: String deocratedToDisplay = "";
2814: if (dbean.getMsg().getRecipientsAsText() != null) {
2815: if (dbean.getMsg().getRecipientsAsText().length() > 25) {
2816: deocratedToDisplay = (dbean.getMsg()
2817: .getRecipientsAsText()).substring(0, 20)
2818: + " (..)";
2819: } else {
2820: deocratedToDisplay = dbean.getMsg()
2821: .getRecipientsAsText();
2822: }
2823: }
2824: return deocratedToDisplay;
2825: }
2826:
2827: /**
2828: * get recipients
2829: * @return a set of recipients (User objects)
2830: */
2831: private Set getRecipients() {
2832: List selectedList = getSelectedComposeToList();
2833: Set returnSet = new HashSet();
2834:
2835: /** get List of unfiltered course members */
2836: List allCourseUsers = membershipManager.getAllCourseUsers();
2837:
2838: for (Iterator i = selectedList.iterator(); i.hasNext();) {
2839: String selectedItem = (String) i.next();
2840:
2841: /** lookup item in map */
2842: MembershipItem item = (MembershipItem) courseMemberMap
2843: .get(selectedItem);
2844: if (item == null) {
2845: LOG.warn("getRecipients() could not resolve uuid: "
2846: + selectedItem);
2847: } else {
2848: if (MembershipItem.TYPE_ALL_PARTICIPANTS.equals(item
2849: .getType())) {
2850: for (Iterator a = allCourseUsers.iterator(); a
2851: .hasNext();) {
2852: MembershipItem member = (MembershipItem) a
2853: .next();
2854: returnSet.add(member.getUser());
2855: }
2856: } else if (MembershipItem.TYPE_ROLE.equals(item
2857: .getType())) {
2858: for (Iterator r = allCourseUsers.iterator(); r
2859: .hasNext();) {
2860: MembershipItem member = (MembershipItem) r
2861: .next();
2862: if (member.getRole().equals(item.getRole())) {
2863: returnSet.add(member.getUser());
2864: }
2865: }
2866: } else if (MembershipItem.TYPE_GROUP.equals(item
2867: .getType())) {
2868: for (Iterator g = allCourseUsers.iterator(); g
2869: .hasNext();) {
2870: MembershipItem member = (MembershipItem) g
2871: .next();
2872: Set groupMemberSet = item.getGroup()
2873: .getMembers();
2874: for (Iterator s = groupMemberSet.iterator(); s
2875: .hasNext();) {
2876: Member m = (Member) s.next();
2877: if (m.getUserId() != null
2878: && m.getUserId().equals(
2879: member.getUser().getId())) {
2880: returnSet.add(member.getUser());
2881: }
2882: }
2883: }
2884: } else if (MembershipItem.TYPE_USER.equals(item
2885: .getType())) {
2886: returnSet.add(item.getUser());
2887: } else {
2888: LOG
2889: .warn("getRecipients() could not resolve membership type: "
2890: + item.getType());
2891: }
2892: }
2893: }
2894: return returnSet;
2895: }
2896:
2897: /**
2898: * getUserRecipients
2899: * @param courseMembers
2900: * @return set of all User objects for course
2901: */
2902: private Set getUserRecipients(Set courseMembers) {
2903: Set returnSet = new HashSet();
2904:
2905: for (Iterator i = courseMembers.iterator(); i.hasNext();) {
2906: MembershipItem item = (MembershipItem) i.next();
2907: returnSet.add(item.getUser());
2908: }
2909: return returnSet;
2910: }
2911:
2912: /**
2913: * getUserRecipientsForRole
2914: * @param roleName
2915: * @param courseMembers
2916: * @return set of all User objects for role
2917: */
2918: private Set getUserRecipientsForRole(String roleName,
2919: Set courseMembers) {
2920: Set returnSet = new HashSet();
2921:
2922: for (Iterator i = courseMembers.iterator(); i.hasNext();) {
2923: MembershipItem item = (MembershipItem) i.next();
2924: if (item.getRole().getId().equalsIgnoreCase(roleName)) {
2925: returnSet.add(item.getUser());
2926: }
2927: }
2928: return returnSet;
2929: }
2930:
2931: private String getPrivateMessageTypeFromContext(String navMode) {
2932:
2933: if (PVTMSG_MODE_RECEIVED.equalsIgnoreCase(navMode)) {
2934: return typeManager.getReceivedPrivateMessageType();
2935: } else if (PVTMSG_MODE_SENT.equalsIgnoreCase(navMode)) {
2936: return typeManager.getSentPrivateMessageType();
2937: } else if (PVTMSG_MODE_DELETE.equalsIgnoreCase(navMode)) {
2938: return typeManager.getDeletedPrivateMessageType();
2939: } else if (PVTMSG_MODE_DRAFT.equalsIgnoreCase(navMode)) {
2940: return typeManager.getDraftPrivateMessageType();
2941: } else {
2942: return typeManager.getCustomTopicType(navMode);
2943: }
2944: }
2945:
2946: //////// GETTER AND SETTER ///////////////////
2947: public String processUpload(ValueChangeEvent event) {
2948: return DISPLAY_MESSAGES_PG;
2949: }
2950:
2951: public String processUploadConfirm() {
2952: return DISPLAY_MESSAGES_PG;
2953: }
2954:
2955: public String processUploadCancel() {
2956: return DISPLAY_MESSAGES_PG;
2957: }
2958:
2959: public void setForumManager(MessageForumsForumManager forumManager) {
2960: this .forumManager = forumManager;
2961: }
2962:
2963: public PrivateForum getForum() {
2964: return forum;
2965: }
2966:
2967: public void setForum(PrivateForum forum) {
2968: this .forum = forum;
2969: }
2970:
2971: // public String processActionAreaSettingEmailFwd()
2972: // {
2973: //
2974: // }
2975:
2976: /**
2977: * Check String has value, not null
2978: * @return boolean
2979: */
2980: protected boolean hasValue(String eval) {
2981: if (eval != null && !eval.trim().equals("")) {
2982: return true;
2983: } else {
2984: return false;
2985: }
2986: }
2987:
2988: /**
2989: * @param errorMsg
2990: */
2991: private void setErrorMessage(String errorMsg) {
2992: LOG.debug("setErrorMessage(String " + errorMsg + ")");
2993: FacesContext.getCurrentInstance().addMessage(
2994: null,
2995: new FacesMessage(getResourceBundleString(ALERT) + ' '
2996: + errorMsg));
2997: }
2998:
2999: /**
3000: * Enable privacy message
3001: * @return
3002: */
3003: public boolean getRenderPrivacyAlert() {
3004: if (ServerConfigurationService
3005: .getString(MESSAGECENTER_PRIVACY_TEXT) != null
3006: && ServerConfigurationService.getString(
3007: MESSAGECENTER_PRIVACY_TEXT).trim().length() > 0) {
3008: return true;
3009: }
3010: return false;
3011: }
3012:
3013: /**
3014: * Get Privacy message link from sakai.properties
3015: * @return
3016: */
3017: public String getPrivacyAlertUrl() {
3018: return ServerConfigurationService
3019: .getString(MESSAGECENTER_PRIVACY_URL);
3020: }
3021:
3022: /**
3023: * Get Privacy message from sakai.properties
3024: * @return
3025: */
3026: public String getPrivacyAlert() {
3027: return ServerConfigurationService
3028: .getString(MESSAGECENTER_PRIVACY_TEXT);
3029: }
3030:
3031: public boolean isAtMain() {
3032: HttpServletRequest req = (HttpServletRequest) FacesContext
3033: .getCurrentInstance().getExternalContext().getRequest();
3034:
3035: String servletPath = req.getServletPath();
3036: if (servletPath != null) {
3037: if (servletPath.startsWith("/jsp/main")) {
3038: return true;
3039: }
3040: }
3041: return false;
3042: }
3043:
3044: public String getSortType() {
3045: return sortType;
3046: }
3047:
3048: public void setSortType(String sortType) {
3049: this .sortType = sortType;
3050: }
3051:
3052: public static String getResourceBundleString(String key) {
3053: return rb.getString(key);
3054: }
3055:
3056: public String getAuthorString() {
3057: String authorString = getUserId();
3058:
3059: try {
3060: authorString = UserDirectoryService.getUser(getUserId())
3061: .getSortName();
3062:
3063: } catch (Exception e) {
3064: e.printStackTrace();
3065: }
3066:
3067: return authorString;
3068: }
3069:
3070: public String getPlacementId() {
3071: return Validator.escapeJavascript("Main"
3072: + ToolManager.getCurrentPlacement().getId());
3073: }
3074:
3075: public void setMsgNavMode(String msgNavMode) {
3076: this .msgNavMode = msgNavMode;
3077: }
3078:
3079: /**
3080: * @return
3081: */
3082: public String processActionMarkCheckedAsRead() {
3083: return markCheckedMessages(true);
3084: }
3085:
3086: /**
3087: *
3088: * @param readStatus
3089: * @return
3090: */
3091: private String markCheckedMessages(boolean readStatus) {
3092: List pvtMsgList = new ArrayList();
3093: boolean msgSelected = false;
3094: boolean searchMode = false;
3095:
3096: // determine if we are looking at search results or the main listing
3097: if (searchPvtMsgs != null && !searchPvtMsgs.isEmpty()) {
3098: searchMode = true;
3099: pvtMsgList = searchPvtMsgs;
3100: } else {
3101: pvtMsgList = decoratedPvtMsgs;
3102: }
3103:
3104: Iterator pvtMsgListIter = pvtMsgList.iterator();
3105: while (pvtMsgListIter.hasNext()) {
3106: PrivateMessageDecoratedBean decoMessage = (PrivateMessageDecoratedBean) pvtMsgListIter
3107: .next();
3108: if (decoMessage.getIsSelected()) {
3109: msgSelected = true;
3110: prtMsgManager.markMessageAsReadForUser(decoMessage
3111: .getMsg());
3112:
3113: if (searchMode) {
3114: // Although the change was made in the db, the search
3115: // view needs to be refreshed (it doesn't return to db)
3116: decoMessage.setHasRead(true);
3117: decoMessage.setIsSelected(false);
3118: }
3119: }
3120: }
3121:
3122: if (!msgSelected) {
3123: setErrorMessage(getResourceBundleString(NO_MARKED_READ_MESSAGE));
3124: return null;
3125: }
3126:
3127: if (searchMode) {
3128: return SEARCH_RESULT_MESSAGES_PG;
3129: }
3130:
3131: return DISPLAY_MESSAGES_PG;
3132: }
3133:
3134: private void setFromMainOrHp() {
3135: String fromPage = getExternalParameterByKey(COMPOSE_FROM_PG);
3136: if (fromPage != null
3137: && (fromPage.equals(MESSAGE_HOME_PG) || (fromPage
3138: .equals(MAIN_PG)))) {
3139: fromMainOrHp = fromPage;
3140: }
3141: }
3142:
3143: /**
3144: * @return TRUE if within Messages & Forums tool, FALSE otherwise
3145: */
3146: public boolean isMessagesandForums() {
3147: return messageManager.currentToolMatch(MESSAGECENTER_TOOL_ID);
3148: }
3149:
3150: /**
3151: * @return TRUE if within Messages tool, FALSE otherwise
3152: */
3153: public boolean isMessages() {
3154: return messageManager.currentToolMatch(MESSAGES_TOOL_ID);
3155: }
3156:
3157: /**
3158: * @return TRUE if Message Forums (Message Center) exists in this site,
3159: * FALSE otherwise
3160: */
3161: public boolean isMessageForumsPageInSite() {
3162: return isMessageForumsPageInSite(getSiteId());
3163: }
3164:
3165: /**
3166: * @return TRUE if Messages & Forums (Message Center) exists in this site,
3167: * FALSE otherwise
3168: */
3169: private boolean isMessageForumsPageInSite(String siteId) {
3170: return messageManager.isToolInSite(siteId,
3171: MESSAGECENTER_TOOL_ID);
3172: }
3173:
3174: /**
3175: * @return TRUE if Messages tool exists in this site,
3176: * FALSE otherwise
3177: */
3178: public boolean isMessagesPageInSite() {
3179: return isMessagesPageInSite(getSiteId());
3180: }
3181:
3182: /**
3183: * @return TRUE if Messages tool exists in this site,
3184: * FALSE otherwise
3185: */
3186: private boolean isMessagesPageInSite(String siteId) {
3187: return messageManager.isToolInSite(siteId, MESSAGES_TOOL_ID);
3188: }
3189: }
|