KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > mvnforum > user > MessageWebHandler


1 /*
2  * $Header: /cvsroot/mvnforum/mvnforum/src/com/mvnforum/user/MessageWebHandler.java,v 1.91 2006/04/14 17:05:27 minhnn Exp $
3  * $Author: minhnn $
4  * $Revision: 1.91 $
5  * $Date: 2006/04/14 17:05:27 $
6  *
7  * ====================================================================
8  *
9  * Copyright (C) 2002-2006 by MyVietnam.net
10  *
11  * All copyright notices regarding mvnForum MUST remain
12  * intact in the scripts and in the outputted HTML.
13  * The "powered by" text/logo with a link back to
14  * http://www.mvnForum.com and http://www.MyVietnam.net in
15  * the footer of the pages MUST remain visible when the pages
16  * are viewed on the internet or intranet.
17  *
18  * This program is free software; you can redistribute it and/or modify
19  * it under the terms of the GNU General Public License as published by
20  * the Free Software Foundation; either version 2 of the License, or
21  * any later version.
22  *
23  * This program is distributed in the hope that it will be useful,
24  * but WITHOUT ANY WARRANTY; without even the implied warranty of
25  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26  * GNU General Public License for more details.
27  *
28  * You should have received a copy of the GNU General Public License
29  * along with this program; if not, write to the Free Software
30  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
31  *
32  * Support can be obtained from support forums at:
33  * http://www.mvnForum.com/mvnforum/index
34  *
35  * Correspondence and Marketing Questions can be sent to:
36  * info at MyVietnam net
37  *
38  * @author: Minh Nguyen
39  * @author: Mai Nguyen
40  */

41 package com.mvnforum.user;
42
43 import java.sql.Timestamp JavaDoc;
44 import java.util.*;
45
46 import com.mvnforum.*;
47 import com.mvnforum.auth.*;
48 import com.mvnforum.common.PrivateMessageUtil;
49 import com.mvnforum.db.*;
50 import net.myvietnam.mvncore.exception.*;
51 import net.myvietnam.mvncore.filter.DisableHtmlTagFilter;
52 import net.myvietnam.mvncore.interceptor.InterceptorService;
53 import net.myvietnam.mvncore.security.FloodControl;
54 import net.myvietnam.mvncore.util.*;
55 import net.myvietnam.mvncore.web.GenericRequest;
56 import net.myvietnam.mvncore.web.GenericResponse;
57 import org.apache.commons.logging.Log;
58 import org.apache.commons.logging.LogFactory;
59
60 public class MessageWebHandler {
61
62     private static Log log = LogFactory.getLog(MessageWebHandler.class);
63
64     private OnlineUserManager onlineUserManager = OnlineUserManager.getInstance();
65
66     public MessageWebHandler() {
67     }
68
69     public void prepareAdd(GenericRequest request, GenericResponse response)
70         throws AssertionException, DatabaseException, AuthenticationException,
71         BadInputException, ObjectNotFoundException {
72
73         Locale locale = I18nUtil.getLocaleInRequest(request);
74
75         if (MVNForumConfig.getEnablePrivateMessage() == false) {
76             String JavaDoc localizedMessage = MVNForumResourceBundle.getString(locale, "mvncore.exception.AssertionException.private_message_disabled");
77             throw new AssertionException(localizedMessage);
78             //throw new AssertionException("Cannot operate with private messages. Because the private message feature is disabled");
79
}
80
81         MyUtil.saveVNTyperMode(request, response);
82
83         OnlineUser onlineUser = onlineUserManager.getOnlineUser(request);
84         MVNForumPermission permission = onlineUser.getPermission();
85         permission.ensureIsAuthenticated();
86         permission.ensureCanUseMessage();
87
88         boolean isPreviewing = GenericParamUtil.getParameterBoolean(request, "preview");
89         boolean isForward = GenericParamUtil.getParameterBoolean(request, "forward");
90
91         int parentMessageID = 0;
92         try {
93             parentMessageID = GenericParamUtil.getParameterInt(request, "parent");
94         } catch (Exception JavaDoc ex) {
95             // do nothing
96
// NOTE: we cannot return here since user can have a parameter parent = 0
97
}
98
99         if (parentMessageID != 0) { // Reply
100
MessageBean parentMessageBean = null;
101             try {
102                 parentMessageBean = DAOFactory.getMessageDAO().getMessage(parentMessageID);
103             } catch (ObjectNotFoundException e) {
104                 String JavaDoc localizedMessage = MVNForumResourceBundle.getString(locale, "mvncore.exception.ObjectNotFoundException.messageid_not_exists", new Object JavaDoc[] {new Integer JavaDoc(parentMessageID)});
105                 throw new ObjectNotFoundException(localizedMessage);
106             }
107             if (parentMessageBean.getMemberID() != onlineUser.getMemberID()) {
108                 String JavaDoc localizedMessage = MVNForumResourceBundle.getString(locale, "mvncore.exception.BadInputException.pm_not_belongs_to_you");
109                 throw new BadInputException(localizedMessage);
110                 //throw new BadInputException("This Private Message does not belong to you");
111
}
112             request.setAttribute("ParentMessageBean", parentMessageBean);
113
114             // We prepare showing attached files (if any), it's used for Forward Method
115
if (isForward) {
116                 //MessageBean should have AttachBeans value as default
117
Collection attachBeans = DAOFactory.getPmAttachmentDAO().getPmAttachments_inMessage(parentMessageID);
118                 request.setAttribute("AttachBeans", attachBeans);
119             }
120         }
121
122         if (isPreviewing) {
123
124             boolean sendAll = false;
125             if (MVNForumConfig.getEnablePublicMessage() && permission.canAdminSystem()) {
126                 sendAll = GenericParamUtil.getParameterBoolean(request, "sendall");
127             }
128
129             int logonMemberID = onlineUser.getMemberID();
130
131             String JavaDoc messageToList = GenericParamUtil.getParameterSafe(request, "MessageToList", !(sendAll));
132             messageToList = messageToList.replace(',', ';');
133             messageToList = DisableHtmlTagFilter.filter(messageToList);// always disable HTML
134

135             String JavaDoc messageCcList = GenericParamUtil.getParameterSafe(request, "MessageCcList", false);
136             messageCcList = messageCcList.replace(',', ';');
137             messageCcList = DisableHtmlTagFilter.filter(messageCcList);// always disable HTML
138

139             String JavaDoc messageBccList = GenericParamUtil.getParameterSafe(request, "MessageBccList", false);
140             messageBccList = messageBccList.replace(',', ';');
141             messageBccList = DisableHtmlTagFilter.filter(messageBccList);// always disable HTML
142

143             GenericParamUtil.getParameter(request, "MessageTopic", true);
144             GenericParamUtil.getParameter(request, "message", true);// use message instead of MessageBody
145

146             MemberBean memberBean = null;
147             try {
148                 memberBean = MemberCache.getInstance().getMember_forPublic(logonMemberID);
149             } catch (ObjectNotFoundException e) {
150                 String JavaDoc localizedMessage = MVNForumResourceBundle.getString(locale, "mvncore.exception.ObjectNotFoundException.memberid_not_exists", new Object JavaDoc[] {new Integer JavaDoc(logonMemberID)});
151                 throw new ObjectNotFoundException(localizedMessage);
152             }
153
154             String JavaDoc[] receivedMembers = StringUtil.getStringArrays(messageToList, messageCcList, messageBccList, ";");
155
156             if (sendAll == false) {
157                 if (receivedMembers.length == 0) {
158                     String JavaDoc localizedMessage = MVNForumResourceBundle.getString(locale, "mvncore.exception.AssertionException.cannot_send_message.no_receivers");
159                     throw new AssertionException(localizedMessage);
160                 }
161                 MyUtil.checkMembers(receivedMembers, locale);//check to make sure that members are existed
162
}
163
164             request.setAttribute("MemberBean", memberBean);
165         }
166
167         //Get MemberTutor (only for Netmama's), it uses to check permision for send message
168
// First, we will check if LoginID is a tutor or Admin
169
boolean isTutorAdmin = true;
170         try {
171             if (MVNForumConfig.getEnableCompany()) {
172                 DAOFactory.getMemberGroupDAO().isTutor(onlineUser.getMemberID());
173             }
174         } catch (ObjectNotFoundException ex) {
175             isTutorAdmin = false;
176         }
177
178         if (permission.canAdminSystem()) { /*This member is an admin*/
179             isTutorAdmin = true;
180         }
181
182         if ((isTutorAdmin == false) && MVNForumConfig.getEnableCompany()) {
183             MemberTutorBean memberTutorBean = null;
184             try {
185                 memberTutorBean = DAOFactory.getMemberTutorDAO().getBean(onlineUser.getMemberID());
186             } catch (ObjectNotFoundException ex) {
187                 // it means memberTutorBean is null and this user doesn't have tutor
188
}
189             request.setAttribute("MemberTutorBean", memberTutorBean);
190         }
191         request.setAttribute("IsTutorAdmin", new Boolean JavaDoc(isTutorAdmin));
192     }
193
194     public void processAdd(GenericRequest request, GenericResponse response)
195         throws ObjectNotFoundException, AssertionException, DatabaseException, CreateException,
196         BadInputException, ForeignKeyNotFoundException, AuthenticationException, InterceptorException, FloodException {
197
198         Locale locale = I18nUtil.getLocaleInRequest(request);
199
200         if (MVNForumConfig.getEnablePrivateMessage() == false) {
201             String JavaDoc localizedMessage = MVNForumResourceBundle.getString(locale, "mvncore.exception.AssertionException.private_message_disabled");
202             throw new AssertionException(localizedMessage);
203             //throw new AssertionException("Cannot operate with private messages. Because the private message feature is disabled");
204
}
205
206         OnlineUser onlineUser = onlineUserManager.getOnlineUser(request);
207         MVNForumPermission permission = onlineUser.getPermission();
208         permission.ensureIsAuthenticated();
209         permission.ensureCanUseMessage();
210
211         String JavaDoc currentIP = request.getRemoteAddr();
212         try {
213             FloodControl.ensureNotReachMaximum(MVNForumGlobal.FLOOD_ID_NEW_MESSAGE, currentIP);
214         } catch (FloodException fe) {
215             //throw new FloodException("You have reached the maximum number of the private message adding actions for this page. Please try this page later. This is to prevent forum from being flooded.");
216
Integer JavaDoc maxMessages = new Integer JavaDoc(FloodControl.getActionsPerHour(MVNForumGlobal.FLOOD_ID_NEW_MESSAGE));
217             String JavaDoc localizedMessage = MVNForumResourceBundle.getString(locale, "mvncore.exception.FloodException.send_message_too_many_times", new Object JavaDoc[] {maxMessages});
218             throw new FloodException(localizedMessage);
219         }
220
221         MyUtil.saveVNTyperMode(request, response);
222
223         int logonMemberID = onlineUser.getMemberID();
224         String JavaDoc memberName = onlineUser.getMemberName();
225
226         boolean sendAll = false;
227
228         if (MVNForumConfig.getEnablePublicMessage() && permission.canAdminSystem()) {
229             sendAll = GenericParamUtil.getParameterBoolean(request, "sendall");
230         }
231
232         // if messageToList == null permit null value
233
String JavaDoc messageToList = GenericParamUtil.getParameterSafe(request, "MessageToList", !(sendAll));
234         messageToList = messageToList.replace(',', ';');
235         messageToList = DisableHtmlTagFilter.filter(messageToList);// always disable HTML
236

237         String JavaDoc messageCcList = GenericParamUtil.getParameterSafe(request, "MessageCcList", false);
238         messageCcList = messageCcList.replace(',', ';');
239         messageCcList = DisableHtmlTagFilter.filter(messageCcList);// always disable HTML
240

241         String JavaDoc messageBccList = GenericParamUtil.getParameterSafe(request, "MessageBccList", false);
242         messageBccList = messageBccList.replace(',', ';');
243         messageBccList = DisableHtmlTagFilter.filter(messageBccList);// always disable HTML
244

245         String JavaDoc messageTopic = GenericParamUtil.getParameter(request, "MessageTopic", true);
246         messageTopic = DisableHtmlTagFilter.filter(messageTopic);// always disable HTML
247
messageTopic = InterceptorService.getInstance().validateContent(messageTopic);
248
249         String JavaDoc messageBody = GenericParamUtil.getParameter(request, "message", true);// use message instead of MessageBody
250
messageBody = DisableHtmlTagFilter.filter(messageBody);// always disable HTML
251
messageBody = InterceptorService.getInstance().validateContent(messageBody);
252
253         String JavaDoc messageIcon = GenericParamUtil.getParameter(request, "MessageIcon");
254         messageIcon = DisableHtmlTagFilter.filter(messageIcon);// always disable HTML
255

256         if (sendAll) {
257             messageToList = onlineUser.getMemberName();
258             messageBccList = "";
259             messageCcList = "";
260         }
261
262         Timestamp JavaDoc now = DateUtil.getCurrentGMTTimestamp();
263         int messageSenderID = logonMemberID;
264         String JavaDoc messageSenderName = memberName;
265         String JavaDoc folderName = MVNForumConstant.MESSAGE_FOLDER_INBOX;
266         // NOTE: in this step, type = quote is not possible since it needs attachment
267
int messageType = (sendAll) ? MessageBean.MESSAGE_TYPE_PUBLIC : MessageBean.MESSAGE_TYPE_DEFAULT;
268         int messageOption = 0;//GenericParamUtil.getParameterInt(request, "MessageOption");
269
int messageStatus = 0;//GenericParamUtil.getParameterInt(request, "MessageStatus");
270
int messageReadStatus = MessageBean.MESSAGE_READ_STATUS_DEFAULT;
271         int messageNotify = 0;//GenericParamUtil.getParameterInt(request, "MessageNotify");
272
int messageAttachCount = 0;
273         String JavaDoc messageIP = currentIP;
274         Timestamp JavaDoc messageCreateDate = now; // Get Current time
275

276         int parentMessageID = 0;
277
278         boolean isDraft = GenericParamUtil.getParameterBoolean(request, "draft");
279         boolean isForward = GenericParamUtil.getParameterBoolean(request, "forward");
280         boolean attachMore = GenericParamUtil.getParameterBoolean(request, "AttachMore");
281         boolean addToSentFolder = GenericParamUtil.getParameterBoolean(request, "AddToSentFolder");
282
283         String JavaDoc[] receivedMembers = StringUtil.getStringArrays(messageToList, messageCcList, messageBccList, ";");
284         if (sendAll == false) {
285             if (receivedMembers.length == 0) {
286                 String JavaDoc localizedMessage = MVNForumResourceBundle.getString(locale, "mvncore.exception.AssertionException.cannot_send_message.no_receivers");
287                 throw new AssertionException(localizedMessage);
288             }
289         }
290
291         Hashtable receivers = MyUtil.checkMembers(receivedMembers, locale);
292
293         if (isForward) {
294             parentMessageID = GenericParamUtil.getParameterInt(request, "parent");
295         }
296
297         Collection attachBeans = null;
298         if (isForward) {
299             MessageBean parentMessageBean = null;
300             try {
301                 parentMessageBean = DAOFactory.getMessageDAO().getMessage(parentMessageID);
302             } catch (ObjectNotFoundException e) {
303                 String JavaDoc localizedMessage = MVNForumResourceBundle.getString(locale, "mvncore.exception.ObjectNotFoundException.messageid_not_exists", new Object JavaDoc[] {new Integer JavaDoc(parentMessageID)});
304                 throw new ObjectNotFoundException(localizedMessage);
305             }
306
307             //actually, the jsp does not allow forward a public message
308
boolean isPublicMessage = false;
309             if (MVNForumConfig.getEnablePublicMessage()) {
310                 isPublicMessage = (permission.canAdminSystem() && (parentMessageBean.getMessageType() == MessageBean.MESSAGE_TYPE_PUBLIC));
311             }
312
313             if ((parentMessageBean.getMemberID() != logonMemberID) && !isPublicMessage) {
314                 String JavaDoc localizedMessage = MVNForumResourceBundle.getString(locale, "mvncore.exception.BadInputException.pm_not_belongs_to_you");
315                 throw new BadInputException(localizedMessage);
316                 //throw new BadInputException("This Private Message does not belong to you");
317
}
318             attachBeans = DAOFactory.getPmAttachmentDAO().getPmAttachments_inMessage(parentMessageID);
319             messageAttachCount = attachBeans.size();// in case forward, the attachcount could > 0 so we call this method
320
} // end forward
321

322         int maxPrivateMessage = MVNForumConfig.getMaxPrivateMessage();
323         if (isDraft) { // Click to Draft Button
324
folderName = MVNForumConstant.MESSAGE_FOLDER_DRAFT;
325             // We will save message to folder Draft with memberID = SenderID
326
// @todo: in next version: when user click to draft message we will open
327
// AddMessage window and display all of its previous data
328

329             int senderMessageCount = DAOFactory.getMessageDAO().getNumberOfNonPublicMessages_inMember(logonMemberID);
330             if (senderMessageCount >= maxPrivateMessage) {
331                 String JavaDoc localizedMessage = MVNForumResourceBundle.getString(locale, "mvncore.exception.BadInputException.over_private_message_quota", new Object JavaDoc[] {new Integer JavaDoc(maxPrivateMessage)});
332                 throw new BadInputException(localizedMessage);
333                 //throw new BadInputException("You cannot push the message into the draft folder. You have already use all your private message quota (" + maxFavorites + ").");
334
}
335
336             int draftMessageID = DAOFactory.getMessageDAO().create(folderName, messageSenderID, messageSenderID,
337                                                 messageSenderName, messageToList, messageCcList,
338                                                 messageBccList, messageTopic, messageBody,
339                                                 messageType, messageOption, messageStatus,
340                                                 messageReadStatus, messageNotify, messageIcon,
341                                                 messageAttachCount, messageIP, messageCreateDate);
342             if (isForward) {
343                 // We must move PmAttachment from parent to new Message
344
for (Iterator attachIter = attachBeans.iterator(); attachIter.hasNext(); ) {
345                     PmAttachmentBean pmAttachBean = (PmAttachmentBean)attachIter.next();
346                     try {
347                         DAOFactory.getPmAttachMessageDAO().create(draftMessageID, pmAttachBean.getPmAttachID(), 0/*type*/, 0/*option*/, 0/*status*/);
348                     } catch (DuplicateKeyException ex) {
349                         // this should never happen
350
throw new AssertionException("DuplicateKeyException when create PmAttachMessage");
351                     }
352                 }
353             }// end of isForward
354

355             attachMore = false;
356         } else { // end draft
357
// click to Send button
358
// test the receiver's quota
359
if (attachMore) {
360
361                 int senderMessageCount = DAOFactory.getMessageDAO().getNumberOfNonPublicMessages_inMember(logonMemberID);
362                 if (senderMessageCount >= maxPrivateMessage) {
363                     String JavaDoc localizedMessage = MVNForumResourceBundle.getString(locale, "mvncore.exception.BadInputException.over_private_message_quota", new Object JavaDoc[] {new Integer JavaDoc(maxPrivateMessage)});
364                     throw new BadInputException(localizedMessage);
365                     //throw new BadInputException("You cannot push the message into the draft folder. You have already use all your private message quota (" + maxFavorites + ").");
366
}
367
368                 folderName = MVNForumConstant.MESSAGE_FOLDER_DRAFT;// it means sending process is not finished
369
// Create but save it as temporary message in Draft folder
370
int messageID = DAOFactory.getMessageDAO().create(folderName, messageSenderID, messageSenderID,
371                                                 messageSenderName, messageToList, messageCcList,
372                                                 messageBccList, messageTopic, messageBody,
373                                                 messageType, messageOption, messageStatus,
374                                                 messageReadStatus, messageNotify, messageIcon,
375                                                 messageAttachCount, messageIP, messageCreateDate);
376                 if (isForward) {
377                     // We must move PmAttachment from parent to new Message
378
for (Iterator attachIter = attachBeans.iterator(); attachIter.hasNext(); ) {
379                         PmAttachmentBean pmAttachBean = (PmAttachmentBean)attachIter.next();
380                         try {
381                             DAOFactory.getPmAttachMessageDAO().create(messageID, pmAttachBean.getPmAttachID(), 0/*type*/, 0/*option*/, 0/*status*/);
382                         } catch (DuplicateKeyException ex) {
383                             // this should never happen
384
throw new AssertionException("DuplicateKeyException when create PmAttachMessage");
385                         }
386                     }
387                 }// end of isForward
388

389                 // When attach more, we must put attribute for MessageID
390
request.setAttribute("MessageID", new Integer JavaDoc(messageID));
391             } else { // NO Attachment
392
// no attachment means we will send this message now
393
StringBuffer JavaDoc overQuotaReceivers = new StringBuffer JavaDoc(128);
394                 for (Enumeration enumeration = receivers.keys(); enumeration.hasMoreElements(); ) {
395                     int receivedMemberID = ((Integer JavaDoc)enumeration.nextElement()).intValue();
396                     String JavaDoc receivedMemberName = (String JavaDoc)receivers.get(new Integer JavaDoc(receivedMemberID));
397
398                     int receiverMessageCount = DAOFactory.getMessageDAO().getNumberOfNonPublicMessages_inMember(receivedMemberID);
399                     if (receiverMessageCount >= maxPrivateMessage) {
400                         if (overQuotaReceivers.length() > 0) {
401                             overQuotaReceivers.append(", ");
402                         }
403                         overQuotaReceivers.append(receivedMemberName);
404                         continue;
405                     }
406
407                     // We need to get MessageID for attached page
408
int eachMessageID = DAOFactory.getMessageDAO().create(folderName, receivedMemberID, messageSenderID,
409                                                         messageSenderName, messageToList, messageCcList,
410                                                         messageBccList, messageTopic, messageBody,
411                                                         messageType, messageOption, messageStatus,
412                                                         messageReadStatus, messageNotify, messageIcon,
413                                                         messageAttachCount, messageIP, messageCreateDate);
414
415                     // Add to statistics
416
if (messageSenderID != receivedMemberID) {
417                         DAOFactory.getMessageStatisticsDAO().create(messageSenderID, receivedMemberID, messageCreateDate,
418                                                                     messageAttachCount, messageType, messageOption, messageStatus);
419                     }
420
421                     if (isForward) {
422                         // We must move PmAttachment from parent to new Message
423
for (Iterator attachIter = attachBeans.iterator(); attachIter.hasNext(); ) {
424                             PmAttachmentBean pmAttachBean = (PmAttachmentBean)attachIter.next();
425                             try {
426                                 DAOFactory.getPmAttachMessageDAO().create(eachMessageID, pmAttachBean.getPmAttachID(), 0/*type*/, 0/*option*/, 0/*status*/);
427                             } catch (DuplicateKeyException ex) {
428                                 // this should never happen
429
throw new AssertionException("DuplicateKeyException when create PmAttachMessage");
430                             }
431                         }
432                     }// end of isForward
433
} // end of for on received members
434
request.setAttribute("OverQuotaReceivers", overQuotaReceivers.toString());
435
436                 // after that, we create another record to save it in Sent. (if user wants)
437
if (addToSentFolder) {
438                     int senderMessageCount = DAOFactory.getMessageDAO().getNumberOfNonPublicMessages_inMember(logonMemberID);
439                     if (senderMessageCount < maxPrivateMessage) {
440                         folderName = MVNForumConstant.MESSAGE_FOLDER_SENT;
441                         messageType = MessageBean.MESSAGE_TYPE_DEFAULT;// always a default type in the Sent folder
442
int sentMessageID = DAOFactory.getMessageDAO().create(folderName, messageSenderID, messageSenderID,
443                                 messageSenderName, messageToList, messageCcList,
444                                 messageBccList, messageTopic, messageBody,
445                                 messageType, messageOption, messageStatus,
446                                 messageReadStatus, messageNotify, messageIcon,
447                                 messageAttachCount, messageIP, messageCreateDate);
448                         if (isForward) {
449                             // We must move PmAttachment from parent to new Message
450
for (Iterator attachIter = attachBeans.iterator(); attachIter.hasNext(); ) {
451                                 PmAttachmentBean pmAttachBean = (PmAttachmentBean)attachIter.next();
452                                 try {
453                                     DAOFactory.getPmAttachMessageDAO().create(sentMessageID, pmAttachBean.getPmAttachID(), 0/*type*/, 0/*option*/, 0/*status*/);
454                                 } catch (DuplicateKeyException ex) {
455                                     // this should never happen
456
throw new AssertionException("DuplicateKeyException when create PmAttachMessage");
457                                 }
458                             }
459                         }// end of isForward
460
} else {
461                         request.setAttribute("AddSentFolderOverQuota", Boolean.TRUE);
462                     }
463                 }// end of addToSentFolder
464
}// else of No Attachment
465
} // end of click to button Send
466

467         request.setAttribute("AttachMore", new Boolean JavaDoc(attachMore));
468         request.setAttribute("AddToSentFolder", new Boolean JavaDoc(addToSentFolder));
469
470         FloodControl.increaseCount(MVNForumGlobal.FLOOD_ID_NEW_MESSAGE, currentIP);
471     }
472
473     public void prepareViewMessage(GenericRequest request)
474         throws ObjectNotFoundException, DatabaseException, BadInputException,
475         AuthenticationException, AssertionException {
476
477         Locale locale = I18nUtil.getLocaleInRequest(request);
478
479         if (MVNForumConfig.getEnablePrivateMessage() == false) {
480             String JavaDoc localizedMessage = MVNForumResourceBundle.getString(locale, "mvncore.exception.AssertionException.private_message_disabled");
481             throw new AssertionException(localizedMessage);
482             //throw new AssertionException("Cannot operate with private messages. Because the private message feature is disabled");
483
}
484
485         OnlineUser onlineUser = onlineUserManager.getOnlineUser(request);
486         MVNForumPermission permission = onlineUser.getPermission();
487         permission.ensureIsAuthenticated();
488         permission.ensureCanUseMessage();
489
490         int logonMemberID = onlineUser.getMemberID();
491
492         int messageID = GenericParamUtil.getParameterInt(request, "message");
493
494         MessageBean messageBean = null;
495         try {
496             messageBean = DAOFactory.getMessageDAO().getMessage(messageID);
497         } catch (ObjectNotFoundException e) {
498             String JavaDoc localizedMessage = MVNForumResourceBundle.getString(locale, "mvncore.exception.ObjectNotFoundException.messageid_not_exists", new Object JavaDoc[] {new Integer JavaDoc(messageID)});
499             throw new ObjectNotFoundException(localizedMessage);
500         }
501
502         // Check if this message doesn't belong to current user
503
boolean isPublicMessage = ((messageBean.getMessageType() == MessageBean.MESSAGE_TYPE_PUBLIC) && MVNForumConfig.getEnablePublicMessage());
504         if ((messageBean.getMemberID() != logonMemberID) && !isPublicMessage) {
505             String JavaDoc localizedMessage = MVNForumResourceBundle.getString(locale, "mvncore.exception.BadInputException.pm_not_belongs_to_you");
506             throw new BadInputException(localizedMessage);
507             //throw new BadInputException("This Private Message does not belong to you");
508
}
509
510         MemberBean memberSenderBean = null;
511         int messageSenderID = messageBean.getMessageSenderID();
512         try {
513             memberSenderBean = MemberCache.getInstance().getMember_forPublic(messageSenderID);
514         } catch (ObjectNotFoundException e) {
515             // In this case, member has been deleted but his message is still there, so we just ignore
516
// Note that currently the viewmessage.jsp accept null value of memberSenderBean
517
}
518
519         if (isPublicMessage) {
520             DAOFactory.getMessageDAO().updateMessageReadStatus(messageID, messageBean.getMemberID(), MessageBean.MESSAGE_READ_STATUS_READ);
521         } else {// private message
522
DAOFactory.getMessageDAO().updateMessageReadStatus(messageID, logonMemberID, MessageBean.MESSAGE_READ_STATUS_READ);
523         }
524
525         // We get attachment of this message
526
Collection attachBeans = DAOFactory.getPmAttachmentDAO().getPmAttachments_inMessage(messageID);
527         messageBean.setAttachmentBeans(attachBeans);
528
529         // always update the number of new private message count in this case
530
onlineUser.updateNewMessageCount(true);
531
532         request.setAttribute("MessageBean", messageBean);
533         request.setAttribute("MemberSenderBean", memberSenderBean);
534     }
535
536     public void prepareList(GenericRequest request)
537         throws BadInputException, DatabaseException, ObjectNotFoundException,
538         AuthenticationException, AssertionException {
539
540         Locale locale = I18nUtil.getLocaleInRequest(request);
541
542         if (MVNForumConfig.getEnablePrivateMessage() == false) {
543             String JavaDoc localizedMessage = MVNForumResourceBundle.getString(locale, "mvncore.exception.AssertionException.private_message_disabled");
544             throw new AssertionException(localizedMessage);
545             //throw new AssertionException("Cannot operate with private messages. Because the private message feature is disabled");
546
}
547
548         OnlineUser onlineUser = onlineUserManager.getOnlineUser(request);
549         MVNForumPermission permission = onlineUser.getPermission();
550         permission.ensureIsAuthenticated();
551         permission.ensureCanUseMessage();
552
553         // always update the number of new private message count in this case
554
onlineUser.updateNewMessageCount(true);
555
556         // @todo: We must check folder to make a correct list
557
String JavaDoc folderName = GenericParamUtil.getParameter(request, "folder");
558         if (folderName.length() == 0) {
559             folderName = MVNForumConstant.MESSAGE_FOLDER_INBOX; // Default as Inbox
560
}
561         StringUtil.checkGoodName(folderName);
562
563         // for sort and order stuff
564
String JavaDoc sort = GenericParamUtil.getParameter(request, "sort");
565         String JavaDoc order = GenericParamUtil.getParameter(request, "order");
566         if (sort.length() == 0) sort = "MessageCreationDate";
567         if (order.length()== 0) order = "DESC";
568
569         //Process of Show Messages of login member
570
int messagePerPage = onlineUser.getMessagesPerPage();
571         int offset = 0;
572         try {
573             offset = GenericParamUtil.getParameterInt(request, "offset");
574         } catch (BadInputException ex) {
575             // do nothing
576
}
577         int logonMemberID = onlineUser.getMemberID();
578
579         try {
580             DAOFactory.getMessageFolderDAO().findByPrimaryKey(folderName, logonMemberID);
581         } catch (ObjectNotFoundException onf) {
582             String JavaDoc localizedMessage = MVNForumResourceBundle.getString(locale, "mvncore.exception.ObjectNotFoundException.messagefolder_not_exists", new Object JavaDoc[] {folderName});
583             throw new ObjectNotFoundException(localizedMessage);
584         }
585
586         int numberOfMessages = DAOFactory.getMessageDAO().getNumberOfNonPublicMessages_inMember_inFolder(logonMemberID, folderName);
587         if (offset > numberOfMessages) {
588             String JavaDoc localizedMessage = MVNForumResourceBundle.getString(locale, "mvncore.exception.BadInputException.offset_greater_than_total_rows");
589             throw new BadInputException(localizedMessage);
590             //throw new BadInputException("The offset is not allowed to be greater than total rows.");
591
}
592
593         Collection messageBeans = null;
594         if (folderName.equalsIgnoreCase(MVNForumConstant.MESSAGE_FOLDER_DRAFT)) {
595             // also get the draft public messages
596
messageBeans = DAOFactory.getMessageDAO().getAllMessages_inMember_inFolder_withSortSupport_limit(logonMemberID, folderName, offset, messagePerPage, sort, order);
597         } else {
598             messageBeans = DAOFactory.getMessageDAO().getNonPublicMessages_inMember_inFolder_withSortSupport_limit(logonMemberID, folderName, offset, messagePerPage, sort, order);
599         }
600
601         Collection messagePublicBeans = null;
602         if (MVNForumConfig.getEnablePublicMessage()) {
603             messagePublicBeans = DAOFactory.getMessageDAO().getPublicMessages();
604         }
605
606         // for folder table
607
Collection messageFolderBeans = DAOFactory.getMessageFolderDAO().getMessageFolders_inMember(logonMemberID);
608         for (Iterator iter = messageFolderBeans.iterator(); iter.hasNext(); ) {
609             MessageFolderBean messageFolder = (MessageFolderBean) iter.next();
610             int messageCount;
611             int unreadMessageCount;
612             if (messageFolder.getFolderName().equalsIgnoreCase(MVNForumConstant.MESSAGE_FOLDER_DRAFT)) {
613                 // also get the draft public messages
614
messageCount = DAOFactory.getMessageDAO().getNumberOfAllMessages_inMember_inFolder(logonMemberID, messageFolder.getFolderName());
615                 unreadMessageCount = DAOFactory.getMessageDAO().getNumberOfUnreadAllMessages_inMember_inFolder(logonMemberID, messageFolder.getFolderName());
616             } else {
617                 messageCount = DAOFactory.getMessageDAO().getNumberOfNonPublicMessages_inMember_inFolder(logonMemberID, messageFolder.getFolderName());
618                 unreadMessageCount = DAOFactory.getMessageDAO().getNumberOfUnreadNonPublicMessages_inMember_inFolder(logonMemberID, messageFolder.getFolderName());
619             }
620             messageFolder.setMessageCount(messageCount);
621             messageFolder.setUnreadMessageCount(unreadMessageCount);
622         } // end for on folders
623

624         // for the quota bar
625
int max = MVNForumConfig.getMaxPrivateMessage();
626         int messageCount = DAOFactory.getMessageDAO().getNumberOfNonPublicMessages_inMember(logonMemberID);
627         double ratio = 0;
628         if (max == 0) {
629             ratio = 1.0;
630         } else {
631             ratio = (double)messageCount / max;
632         }
633         // for the quota bar
634

635         request.setAttribute("QuotaRatio", new Double JavaDoc(ratio*100));
636         request.setAttribute("MessagePublicBeans", messagePublicBeans);
637         request.setAttribute("MessageFolderBeans", messageFolderBeans);
638         request.setAttribute("MessageBeans", messageBeans);
639         request.setAttribute("TotalMessages", new Integer JavaDoc(numberOfMessages));
640     }
641
642     public void processMessage(GenericRequest request)
643         throws ObjectNotFoundException, DatabaseException, BadInputException,
644         AuthenticationException, AssertionException {
645
646         Locale locale = I18nUtil.getLocaleInRequest(request);
647
648         if (MVNForumConfig.getEnablePrivateMessage() == false) {
649             String JavaDoc localizedMessage = MVNForumResourceBundle.getString(locale, "mvncore.exception.AssertionException.private_message_disabled");
650             throw new AssertionException(localizedMessage);
651             //throw new AssertionException("Cannot operate with private messages. Because the private message feature is disabled");
652
}
653
654         OnlineUser onlineUser = onlineUserManager.getOnlineUser(request);
655         MVNForumPermission permission = onlineUser.getPermission();
656         permission.ensureIsAuthenticated();
657         permission.ensureCanUseMessage();
658
659         String JavaDoc btnDelete = request.getParameter("btnDelete");
660         String JavaDoc btnUnreadMark = request.getParameter("btnUnreadMark");
661         String JavaDoc btnMoveFolder = request.getParameter("btnMoveFolder");
662
663         int logonMemberID = onlineUser.getMemberID();
664         int action = 0; // it's better than true-false, expand function later
665
/*
666          * action = 1; // Delete action
667          * action = 2; // Mark unread action
668          * action = 3; // move to another folder
669          */

670         if ((btnDelete != null)) {
671             action = 1;
672         } else if (btnUnreadMark != null) {
673             action = 2;
674         } else if (btnMoveFolder != null) {
675             action = 3;
676         } else {
677             String JavaDoc localizedMessage = MVNForumResourceBundle.getString(locale, "mvncore.exception.BadInputException.cannot_specify_action");
678             throw new BadInputException(localizedMessage);
679             //throw new BadInputException("Cannot specify the action");
680
}
681
682         if (action == 1) {// delete
683
//log.debug("ListDelete Message:" + btnDelete);
684
String JavaDoc[] deleteList = request.getParameterValues("selectedmessage");
685             for (int i = 0; (deleteList != null) && (i < deleteList.length); i++) {
686                 int messageID = Integer.parseInt(deleteList[i]);
687
688                 MessageBean messageBean = null;
689                 try {
690                     messageBean = DAOFactory.getMessageDAO().getMessage(messageID);
691                 } catch (ObjectNotFoundException e) {
692                     String JavaDoc localizedMessage = MVNForumResourceBundle.getString(locale, "mvncore.exception.ObjectNotFoundException.messageid_not_exists", new Object JavaDoc[] {new Integer JavaDoc(messageID)});
693                     throw new ObjectNotFoundException(localizedMessage);
694                 }
695
696                 // Check if this message doesn't belong to current user
697
if (messageBean.getMessageType() == MessageBean.MESSAGE_TYPE_PUBLIC) {
698                     // this is a public message, only Admin can delete it
699
if (permission.canAdminSystem() == false) {
700                         throw new AssertionException("Only Admin can delete public message.");
701                     }
702                     PrivateMessageUtil.deleteMessageInDatabase(messageID, messageBean.getMemberID());
703                 } else {
704                     // not a public message, only the owner can delete it
705
if (messageBean.getMemberID() != logonMemberID) {
706                         String JavaDoc localizedMessage = MVNForumResourceBundle.getString(locale, "mvncore.exception.BadInputException.pm_not_belongs_to_you");
707                         throw new BadInputException(localizedMessage);
708                         //throw new BadInputException("This Private Message does not belong to you");
709
}
710                     PrivateMessageUtil.deleteMessageInDatabase(messageID, logonMemberID);
711                 }
712             }
713             request.setAttribute("Status", "Delete");
714         } else if (action == 2 ) {// mark as unread
715
//log.debug("Unread Message:" + btnUnreadMark);
716
String JavaDoc[] unreadList = request.getParameterValues("selectedmessage");
717             for (int i = 0; (unreadList != null) && (i < unreadList.length); i++) {
718                 int messageID = Integer.parseInt(unreadList[i]);
719                 MessageBean messageBean = null;
720                 try {
721                     messageBean = DAOFactory.getMessageDAO().getMessage(messageID);
722                 } catch (ObjectNotFoundException e) {
723                     String JavaDoc localizedMessage = MVNForumResourceBundle.getString(locale, "mvncore.exception.ObjectNotFoundException.messageid_not_exists", new Object JavaDoc[] {new Integer JavaDoc(messageID)});
724                     throw new ObjectNotFoundException(localizedMessage);
725                 }
726                 if (messageBean.getMessageType() != MessageBean.MESSAGE_TYPE_PUBLIC) {
727                     // not a public message, only the owner can mark as unread it
728
if (messageBean.getMemberID() != logonMemberID) {
729                         String JavaDoc localizedMessage = MVNForumResourceBundle.getString(locale, "mvncore.exception.BadInputException.pm_not_belongs_to_you");
730                         throw new BadInputException(localizedMessage);
731                         //throw new BadInputException("This Private Message does not belong to you");
732
}
733                     //log.debug("Unread MessageID = " + messageID);
734
DAOFactory.getMessageDAO().updateMessageReadStatus(messageID, logonMemberID, MessageBean.MESSAGE_READ_STATUS_DEFAULT);
735                 }
736             }
737             request.setAttribute("Status", "Unread");
738         } else if (action == 3) { // move to another folder
739
//log.debug("Move Message:" + btnMoveFolder);
740
String JavaDoc[] movingList = request.getParameterValues("selectedmessage");
741             String JavaDoc destinationFolder = GenericParamUtil.getParameterSafe(request, "DestinationFolder", true);
742             StringUtil.checkGoodName(destinationFolder);
743
744             for (int i = 0; (movingList != null) && (i < movingList.length); i++) {
745                 int messageID = Integer.parseInt(movingList[i]);
746                 MessageBean messageBean = null;
747                 try {
748                     messageBean = DAOFactory.getMessageDAO().getMessage(messageID);
749                 } catch (ObjectNotFoundException e) {
750                     String JavaDoc localizedMessage = MVNForumResourceBundle.getString(locale, "mvncore.exception.ObjectNotFoundException.messageid_not_exists", new Object JavaDoc[] {new Integer JavaDoc(messageID)});
751                     throw new ObjectNotFoundException(localizedMessage);
752                 }
753                 if (messageBean.getMessageType() != MessageBean.MESSAGE_TYPE_PUBLIC) {
754                     // not a public message, only the owner can move it
755
if (messageBean.getMemberID() != logonMemberID) {
756                         String JavaDoc localizedMessage = MVNForumResourceBundle.getString(locale, "mvncore.exception.BadInputException.pm_not_belongs_to_you");
757                         throw new BadInputException(localizedMessage);
758                         //throw new BadInputException("This Private Message does not belong to you");
759
}
760                     //log.debug("Move MessageID = " + messageID);
761
DAOFactory.getMessageDAO().updateFolderName(messageID, logonMemberID, destinationFolder);
762                 }
763             }
764             request.setAttribute("Status", "MoveFolder");
765         }
766     }
767
768     public void processSendMessage(GenericRequest request)
769         throws ObjectNotFoundException, DatabaseException, BadInputException,
770         CreateException, ForeignKeyNotFoundException, AuthenticationException, AssertionException {
771
772         Locale locale = I18nUtil.getLocaleInRequest(request);
773
774         if (MVNForumConfig.getEnablePrivateMessage() == false) {
775             String JavaDoc localizedMessage = MVNForumResourceBundle.getString(locale, "mvncore.exception.AssertionException.private_message_disabled");
776             throw new AssertionException(localizedMessage);
777             //throw new AssertionException("Cannot operate with private messages. Because the private message feature is disabled");
778
}
779
780         OnlineUser onlineUser = onlineUserManager.getOnlineUser(request);
781         MVNForumPermission permission = onlineUser.getPermission();
782         permission.ensureIsAuthenticated();
783         permission.ensureCanUseMessage();
784
785         int logonMemberID = onlineUser.getMemberID();
786         int messageID = GenericParamUtil.getParameterInt(request, "message");
787
788         MessageBean messageBean = null;
789         try {
790             messageBean = DAOFactory.getMessageDAO().getMessage(messageID);
791         } catch (ObjectNotFoundException e) {
792             String JavaDoc localizedMessage = MVNForumResourceBundle.getString(locale, "mvncore.exception.ObjectNotFoundException.messageid_not_exists", new Object JavaDoc[] {new Integer JavaDoc(messageID)});
793             throw new ObjectNotFoundException(localizedMessage);
794         }
795
796         // Check if this message doesn't belong to current user
797
if (messageBean.getMemberID() != logonMemberID ) {
798             String JavaDoc localizedMessage = MVNForumResourceBundle.getString(locale, "mvncore.exception.BadInputException.pm_not_belongs_to_you");
799             throw new BadInputException(localizedMessage);
800             //throw new BadInputException("This Private Message does not belong to you");
801
}
802
803         if (messageBean.getFolderName().equalsIgnoreCase(MVNForumConstant.MESSAGE_FOLDER_DRAFT) == false) {
804             String JavaDoc localizedMessage = MVNForumResourceBundle.getString(locale, "mvncore.exception.BadInputException.cannot_add_attachment.pm_does_not_in_folder_draft");
805             throw new BadInputException(localizedMessage);
806             //throw new BadInputException("Cannot add attachment because this Private Message does not in the folder Draft");
807
}
808
809         // Check if the message is from this logon member
810
if (messageBean.getMessageSenderID() != logonMemberID ) {
811             throw new AssertionException("Assertion: The MessageSenderID must equals the current logined user.");
812         }
813         if (messageBean.getMessageSenderName().equals(onlineUser.getMemberName()) == false) {
814             throw new AssertionException("Assertion: The MessageSenderName must equals the current logined user.");
815         }
816
817         Timestamp JavaDoc now = DateUtil.getCurrentGMTTimestamp();
818         Collection attachBeans = DAOFactory.getPmAttachmentDAO().getPmAttachments_inMessage(messageBean.getMessageID()); //messageBean is original message
819

820         int maxPrivateMessage = MVNForumConfig.getMaxPrivateMessage();
821
822         String JavaDoc[] receivedMembers = StringUtil.getStringArrays(messageBean.getMessageToList(), messageBean.getMessageCcList(), messageBean.getMessageBccList(), ";");
823         Hashtable receivers = MyUtil.checkMembers(receivedMembers, locale);
824
825         StringBuffer JavaDoc overQuotaReceivers = new StringBuffer JavaDoc(128);
826         for (Enumeration enumeration = receivers.keys(); enumeration.hasMoreElements(); ) {
827             int receivedMemberID = ((Integer JavaDoc)enumeration.nextElement()).intValue();
828             String JavaDoc receivedMemberName = (String JavaDoc)receivers.get(new Integer JavaDoc(receivedMemberID));
829
830             int receiverMessageCount = DAOFactory.getMessageDAO().getNumberOfNonPublicMessages_inMember(receivedMemberID);
831             if (receiverMessageCount >= maxPrivateMessage) {
832                 if (overQuotaReceivers.length() > 0) {
833                     overQuotaReceivers.append(", ");
834                 }
835                 overQuotaReceivers.append(receivedMemberName);
836                 continue;
837             }
838
839             // Create REAL message for receivers when finish. It means we have new messageID for each new receiver
840
// We need to get MessageID for attached page
841
int eachMessageID = DAOFactory.getMessageDAO().create(MVNForumConstant.MESSAGE_FOLDER_INBOX, receivedMemberID, logonMemberID,
842                                                 messageBean.getMessageSenderName(), messageBean.getMessageToList(), messageBean.getMessageCcList(),
843                                                 messageBean.getMessageBccList(), messageBean.getMessageTopic(), messageBean.getMessageBody(),
844                                                 messageBean.getMessageType(), messageBean.getMessageOption(), messageBean.getMessageStatus(),
845                                                 MessageBean.MESSAGE_READ_STATUS_DEFAULT, messageBean.getMessageNotify(), messageBean.getMessageIcon(),
846                                                 messageBean.getMessageAttachCount(), request.getRemoteAddr(), now);
847
848             // Add to statistics
849
if (logonMemberID != receivedMemberID) {
850                 DAOFactory.getMessageStatisticsDAO().create(logonMemberID, receivedMemberID, now,
851                         messageBean.getMessageAttachCount(), messageBean.getMessageType(),
852                         messageBean.getMessageOption(), messageBean.getMessageStatus());
853             }
854
855             // We must create a loop to create Attach for many receivers and many attachments
856
for (Iterator attachIter = attachBeans.iterator(); attachIter.hasNext(); ) {
857                 PmAttachmentBean pmAttachBean = (PmAttachmentBean)attachIter.next();
858                 try {
859                     DAOFactory.getPmAttachMessageDAO().create(eachMessageID, pmAttachBean.getPmAttachID(), 0/*type*/, 0/*option*/, 0/*status*/);
860                 } catch (DuplicateKeyException ex) {
861                     // this should never happen
862
throw new AssertionException("DuplicateKeyException when create PmAttachMessage");
863                 }
864             }
865         } // end of for on receivers
866
request.setAttribute("OverQuotaReceivers", overQuotaReceivers.toString());
867
868         // Now delete the message in the draft
869
PrivateMessageUtil.deleteMessageInDatabase(messageID, logonMemberID);
870
871         request.setAttribute("MessageID", new Integer JavaDoc(messageID));
872         request.setAttribute("AttachMore", new Boolean JavaDoc(false));
873         request.setAttribute("AddToSentFolder", new Boolean JavaDoc(false));
874     }
875
876     public void processDelete(GenericRequest request)
877         throws ObjectNotFoundException, DatabaseException, BadInputException,
878         AuthenticationException, AssertionException {
879
880         Locale locale = I18nUtil.getLocaleInRequest(request);
881
882         if (MVNForumConfig.getEnablePrivateMessage() == false) {
883             String JavaDoc localizedMessage = MVNForumResourceBundle.getString(locale, "mvncore.exception.AssertionException.private_message_disabled");
884             throw new AssertionException(localizedMessage);
885             //throw new AssertionException("Cannot operate with private messages. Because the private message feature is disabled");
886
}
887
888         OnlineUser onlineUser = onlineUserManager.getOnlineUser(request);
889         MVNForumPermission permission = onlineUser.getPermission();
890         permission.ensureIsAuthenticated();
891         permission.ensureCanUseMessage();
892
893         int logonMemberID = onlineUser.getMemberID();
894
895         int messageID = GenericParamUtil.getParameterInt(request, "message");
896
897         MessageBean messageBean = null;
898         try {
899             messageBean = DAOFactory.getMessageDAO().getMessage(messageID);
900         } catch (ObjectNotFoundException e) {
901             String JavaDoc localizedMessage = MVNForumResourceBundle.getString(locale, "mvncore.exception.ObjectNotFoundException.messageid_not_exists", new Object JavaDoc[] {new Integer JavaDoc(messageID)});
902             throw new ObjectNotFoundException(localizedMessage);
903         }
904
905         // Check if this message doesn't belong to current user
906
// Please note that we dont allow to delete public in this case
907
if (messageBean.getMemberID() != logonMemberID) {
908             String JavaDoc localizedMessage = MVNForumResourceBundle.getString(locale, "mvncore.exception.BadInputException.pm_not_belongs_to_you");
909             throw new BadInputException(localizedMessage);
910             //throw new BadInputException("This Private Message does not belong to you");
911
}
912
913         // Now delete the message
914
PrivateMessageUtil.deleteMessageInDatabase(messageID, logonMemberID);
915
916         request.setAttribute("FolderName", messageBean.getFolderName());
917     }
918
919 }
920
Popular Tags