--- /dev/null
+package com.sample.jsp.portlet;
+
+import java.io.UnsupportedEncodingException;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.apache.commons.lang.math.RandomUtils;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import com.liferay.portal.kernel.exception.PortalException;
+import com.liferay.portal.kernel.exception.SystemException;
+import com.liferay.portal.model.Group;
+import com.liferay.portal.model.Organization;
+import com.liferay.portal.model.User;
+import com.liferay.portal.service.OrganizationLocalServiceUtil;
+import com.liferay.portal.service.ServiceContext;
+import com.liferay.portal.service.UserLocalServiceUtil;
+import com.pentila.entSavoie.cahierDeTexte.model.EventCDT;
+import com.pentila.entSavoie.cahierDeTexte.model.Matiere;
+import com.pentila.entSavoie.cahierDeTexte.service.EventCDTLocalServiceUtil;
+import com.pentila.entSavoie.cahierDeTexte.service.MatiereEtabLocalServiceUtil;
+import com.pentila.entSavoie.cahierDeTexte.service.MatiereLocalServiceUtil;
+import com.pentila.entSavoie.cahierDeTexte.util.CDTUtil;
+import com.pentila.entSavoie.directory.OrganizationFinderServiceUtil;
+import com.pentila.entSavoie.internalMessaging.InternalMessagingConstants;
+import com.pentila.entSavoie.internalMessaging.model.InternalFolderMessage;
+import com.pentila.entSavoie.internalMessaging.model.InternalMessage;
+import com.pentila.entSavoie.internalMessaging.service.InternalFolderMessageLocalServiceUtil;
+import com.pentila.entSavoie.internalMessaging.service.InternalMessageLocalServiceUtil;
+import com.pentila.entSavoie.internalMessaging.service.InternalReceiverLocalServiceUtil;
+import com.pentila.entSavoie.internalMessaging.service.InternalReceiversLocalServiceUtil;
+import com.pentila.export.composite.NeroCDTComposite;
+import com.pentila.export.composite.NeroIMComposite;
+import com.pentila.export.composite.NeroUserComposite;
+import com.pentila.export.impl.EventCDTXstreamImpl;
+import com.pentila.export.impl.InternalFolderMessageXstreamImpl;
+import com.pentila.export.impl.InternalMessageXstreamImpl;
+import com.pentila.export.impl.InternalReceiversXstreamImpl;
+import com.pentila.export.wrapper.CDTAnnotationList;
+import com.pentila.export.wrapper.CDTEvtList;
+import com.pentila.export.wrapper.CDTGroupMap;
+import com.pentila.export.wrapper.CDTMatiereMap;
+import com.pentila.export.wrapper.CDTNeroUsersMap;
+import com.pentila.export.wrapper.InternalAttachFileList;
+import com.pentila.export.wrapper.InternalFolderMessageList;
+import com.pentila.export.wrapper.InternalMessageList;
+import com.pentila.export.wrapper.InternalReceiversList;
+import com.pentila.export.wrapper.NeroUserMap;
+import com.thoughtworks.xstream.XStream;
+import com.thoughtworks.xstream.io.xml.DomDriver;
+
+public class NeroImport {
+
+ private static Log logger = LogFactory.getLog(NeroImport.class);
+
+ Map<Long, Long> messageIdMap;
+ InternalAttachFileList iafObj;
+
+ Map<Long, Long> eventIdMap;
+
+ SimpleDateFormat classicDateFormat = new SimpleDateFormat("yyyyMMdd");
+
+ public NeroImport() {
+ messageIdMap = new HashMap<Long, Long>();
+ eventIdMap = new HashMap<Long, Long>();
+ }
+
+ /**
+ * Import CDT events in XML format, from startDate to endDate, for user user
+ * @param user
+ * @param startDate
+ * @param endDate
+ * @param xmlContent
+ * @return the import report
+ * @throws PortalException
+ * @throws SystemException
+ * @throws UnsupportedEncodingException
+ */
+ public String importNeroCDT(User user, Date startDate, Date endDate, String xmlContent) throws PortalException, SystemException, UnsupportedEncodingException{
+
+ final Long userId = user.getUserId();
+
+ // Variables for CDT search
+ final Integer showFilter = 0;
+ final Long calendarIdShow = new Long(-1);
+ final String filterSubjectIds = "[-1]";
+ final Boolean onlyCreatorEvent = false;
+
+ // Variables for reporting
+ int nbImportedEvents = 0;
+ int nbExistingEvents = 0;
+ int nbImportedHomeworks = 0;
+ int nbNonImportedHomeworks = 0;
+ int nbImportedGroups = 0;
+ int nbNonImportedGroups = 0;
+ String nonImportedGroupsReport = "";
+ int nbImportedSubjects = 0;
+ int nbCreatedSubjects = 0;
+ String subjectsCreatedReport = "";
+ String errorsReport = "";
+
+ logger.info("Importing CDT ...");
+
+ // Get user's attached etab
+ long etabId = 0;
+ try {
+ etabId = OrganizationFinderServiceUtil.getEtabRatachement(user).getOrganizationId();
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+
+ // Use Xstream to get the NeroCDTComposite object from the read XML content
+ XStream xstream = new XStream(new DomDriver("UTF-8"));
+ xstream.addImplicitCollection(CDTAnnotationList.class, "annotationList");
+ xstream.addImplicitCollection(CDTMatiereMap.class, "matiereMap");
+ xstream.addImplicitCollection(CDTGroupMap.class, "groupMap");
+ xstream.addImplicitCollection(CDTEvtList.class, "evtList");
+ xstream.addImplicitCollection(CDTNeroUsersMap.class, "neroUsersMap");
+ xstream.alias("InternalFolderMessage", InternalFolderMessage.class);
+ xstream.alias("InternalFolderMessageImpl", InternalFolderMessage.class);
+ NeroCDTComposite returnCDTComposite = (NeroCDTComposite)xstream.fromXML(xmlContent);
+
+
+ // Get target groupId from the source group name, using the organization
+ logger.info("Mapping groups ...");
+ Map<Long, String> importedGroupMap = returnCDTComposite.getGroupMap().getGroupMap();
+ Map<Long, String> newGroupMap = new HashMap<Long, String>();
+ Map<Long, Long> groupIdMap = new HashMap<Long, Long>();
+
+ if (importedGroupMap == null) {
+ importedGroupMap = new HashMap<Long, String>();
+ }
+ for (Long groupId : importedGroupMap.keySet()) {
+ String groupName = importedGroupMap.get(groupId);
+ Organization orga = OrganizationLocalServiceUtil.getOrganization(user.getCompanyId(), groupName);
+ if (orga != null) {
+ Group newGroup = orga.getGroup();
+ newGroupMap.put(newGroup.getGroupId(), groupName);
+ groupIdMap.put(groupId, newGroup.getGroupId());
+ nbImportedGroups++;
+ } else {
+ nbNonImportedGroups++;
+ errorsReport += "Le groupe "+groupName+" n'a pas été trouvé.";
+ }
+ }
+
+ // Get the 'new' subject id from the 'old' subject long label
+
+ // The subject's map that comes the zip file
+ Map<Long, String> importedMatiereMap = returnCDTComposite.getMatiereMap().getMatiereMap();
+
+ // The built map : newMatiereId / longLabel
+ Map<Long, String> newMatiereMap = new HashMap<Long, String>();
+
+ // Build the subject's map : source MatiereId / target MatiereId
+ Map<Long, Long> matiereIdMap = new HashMap<Long, Long>();
+
+ for (Long matiereId : importedMatiereMap.keySet()) {
+ String matiereName = importedMatiereMap.get(matiereId);
+
+ Matiere newMatiere = null;
+
+ List<Matiere> listMatiere = MatiereLocalServiceUtil.getMatiereByLabelLong(matiereName);
+ if (listMatiere != null) {
+ for (Matiere _matiere : listMatiere) {
+ newMatiere = _matiere;
+ break;
+ }
+ }
+
+ if (newMatiere != null) {
+ nbImportedSubjects++;
+ } else {
+ // Create subject
+ newMatiere = MatiereLocalServiceUtil.getOrCreateMatiereByLabelLong(matiereName);
+ nbCreatedSubjects++;
+
+ // Add subject into organization
+ int colorIndex = RandomUtils.nextInt(6);
+ MatiereEtabLocalServiceUtil.getOrCreateMatiereEtabByEtabIdMatiereId(etabId, newMatiere.getMatiereId(), colorsPool[colorIndex]);
+
+ if (subjectsCreatedReport.equals("")) {
+ subjectsCreatedReport += matiereName;
+ } else {
+ subjectsCreatedReport += ", " + matiereName;
+ }
+ }
+ newMatiereMap.put(newMatiere.getMatiereId(), matiereName);
+ matiereIdMap.put(matiereId, newMatiere.getMatiereId());
+ }
+
+
+ // List of homeworks linked to events, that we'll have to update in a second pass with the generated new event ids
+ List<EventCDT> devoirEvtToUpdateList = new ArrayList<EventCDT>();
+
+ // Loop over the imported events that we need to insert in the DB
+ logger.info("Importing events ...");
+ List<EventCDTXstreamImpl> eventCDTXstreamImplList = returnCDTComposite.getEvtList().getEvtList();
+
+ // Get min and max dates of import
+ Date minDate = null;
+ Date maxDate = null;
+ try {
+ minDate = classicDateFormat.parse("29990101");
+ maxDate = classicDateFormat.parse("20000101");
+ } catch (ParseException e) {
+ e.printStackTrace();
+ }
+
+ for (EventCDTXstreamImpl eventToImport : eventCDTXstreamImplList) {
+
+ Date startEvtToInsert = eventToImport.get_startDay();
+ Date endEvtToInsert = eventToImport.get_endDay();
+ if (startEvtToInsert.before(minDate)) {
+ minDate = startEvtToInsert;
+ }
+ if (endEvtToInsert.after(maxDate)) {
+ maxDate = endEvtToInsert;
+ }
+ }
+
+ // Get the list of existing events between minDate and maxDate, in order to avoid inserting duplicates
+ logger.info("Get existing events from "+classicDateFormat.format(minDate)+" to "+classicDateFormat.format(maxDate));
+ List<EventCDT> existingEvtList = CDTUtil.calendarEvent_list(userId, showFilter, calendarIdShow, filterSubjectIds, onlyCreatorEvent, minDate, maxDate, 0);
+ logger.info("Retrieved "+ existingEvtList.size()+ " events");
+
+
+ for (EventCDTXstreamImpl eventToImport : eventCDTXstreamImplList) {
+
+ // Before inserting each event, check that no other event exists in the CDT
+ // with the same startDate, endDate, subject and groupId
+ String startDayStr = classicDateFormat.format(eventToImport.get_startDay());
+ String endDayStr = classicDateFormat.format(eventToImport.get_endDay());
+ String startEvtToInsert = eventToImport.get_startEvtTime();
+ String endEvtToInsert = eventToImport.get_endEvtTime();
+ Long subjectCDTEvtToInsert = eventToImport.get_subjectCDT();
+ long groupIdEvtToInsert = eventToImport.get_groupId();
+ boolean foundSameExistingEvent = false;
+
+ for (EventCDT existingEvent : existingEvtList) {
+
+ if (classicDateFormat.format(existingEvent.getStartDay()).equals(startDayStr)
+ && classicDateFormat.format(existingEvent.getEndDay()).equals(endDayStr)
+ && existingEvent.getStartEvtTime().equals(startEvtToInsert)
+ && existingEvent.getEndEvtTime().equals(endEvtToInsert)
+ && existingEvent.getSubjectCDT() == matiereIdMap.get(subjectCDTEvtToInsert)
+ && existingEvent.getGroupId() == groupIdMap.get(groupIdEvtToInsert) ) {
+ foundSameExistingEvent = true;
+ break;
+ }
+ }
+
+ if (foundSameExistingEvent) {
+ nbExistingEvents++;
+ logger.info ("Found existing identical event => skip insertion");
+ } else {
+
+ // Create the event object and insert it
+ EventCDT newEvent = EventCDTLocalServiceUtil.addEventCDT();
+ newEvent.setAlertFlag(eventToImport.get_alertFlag());
+ newEvent.setBroadcast(eventToImport.get_broadcast());
+ newEvent.setCompanyId(user.getCompanyId()); // Use the new user's company
+ newEvent.setCreator(userId); // The creator is the user that imports
+ newEvent.setDescription(eventToImport.get_description());
+ newEvent.setEndDay(eventToImport.get_endDay());
+ newEvent.setEndEvtTime(eventToImport.get_endEvtTime());
+ newEvent.setEstimatedTime(eventToImport.get_estimatedTime());
+ newEvent.setFromDate(eventToImport.get_fromDate());
+
+ // Group id
+ if (groupIdMap.containsKey(eventToImport.get_groupId())) {
+ newEvent.setGroupId(groupIdMap.get(eventToImport.get_groupId()));
+ } else {
+ errorsReport += "Le groupe de nom '" + importedGroupMap.get(eventToImport.get_groupId()) + "' n'a pas été trouvé.</br>";
+ }
+
+
+ newEvent.setLocked(eventToImport.get_locked());
+
+ newEvent.setRepeatEvt(eventToImport.get_repeatEvt()); // TODO
+ newEvent.setRepeatEvtGroup(eventToImport.get_repeatEvtGroup()); // TODO
+
+ newEvent.setRepeatEvtModified(eventToImport.get_repeatEvtModified());
+ newEvent.setStartDay(eventToImport.get_startDay());
+ newEvent.setStartEvtTime(eventToImport.get_startEvtTime());
+ newEvent.setSubject(eventToImport.get_subject());
+
+ // Matiere id
+ if (matiereIdMap.containsKey(eventToImport.get_subjectCDT())) {
+ newEvent.setSubjectCDT(matiereIdMap.get(eventToImport.get_subjectCDT()));
+ } else {
+ errorsReport += "La matière '" + importedGroupMap.get(eventToImport.get_groupId()) + "' n'a pas été trouvée.</br>";
+ }
+
+ // kind : 1 --> cours / 2 --> devoir
+ newEvent.setKindEvt(eventToImport.get_kindEvt());
+ if (eventToImport.get_kindEvt() == 1) {
+ // Cet evenement est un cours
+ newEvent.setFromEvt(0);
+ newEvent.setToEvt(0);
+ }
+
+ newEvent.setTypeEvt(eventToImport.get_typeEvt());
+ newEvent.setVisa(eventToImport.get_visa());
+ newEvent.setWaitForChange(eventToImport.get_waitForChange());
+ newEvent.setWgave(eventToImport.get_wgave());
+ newEvent.setWtodo(eventToImport.get_wtodo());
+
+ EventCDT updatedEvent = EventCDTLocalServiceUtil.updateEventCDT(newEvent);
+
+ // Update eventId map
+ eventIdMap.put(eventToImport.get_evtId(), updatedEvent.getEvtId());
+
+ // If event is a homework, we'll update it in a second phase to setup 'fromEvt' and 'toEvt'
+ if (eventToImport.get_kindEvt() == 2) {
+ newEvent.setFromEvt(eventToImport.get_fromEvt());
+ newEvent.setToEvt(eventToImport.get_toEvt());
+ devoirEvtToUpdateList.add(newEvent);
+ } else {
+ nbImportedEvents++;
+ }
+ }
+ }
+
+
+ // Second pass over homeworks to setup 'fromEvt' and 'toEvt'
+ for (EventCDT devoirToUpdate : devoirEvtToUpdateList) {
+
+ // From Evt
+ if (eventIdMap.containsKey(devoirToUpdate.getFromEvt())) {
+ devoirToUpdate.setFromEvt(eventIdMap.get(devoirToUpdate.getFromEvt()));
+ EventCDTLocalServiceUtil.updateEventCDT(devoirToUpdate);
+ } else {
+ errorsReport += "Le devoir (id=" + devoirToUpdate.getEvtId() + ") n'a pas été correctement importé car le cours d'origine (" + devoirToUpdate.getFromEvt() + ") n'a pas été trouvé (sûrement antérieur à la date de début d'export)</br>";
+ nbNonImportedHomeworks++;
+ EventCDTLocalServiceUtil.deleteEvent(devoirToUpdate);
+ }
+
+ // To Evt
+ if (eventIdMap.containsKey(devoirToUpdate.getToEvt())) {
+ devoirToUpdate.setToEvt(eventIdMap.get(devoirToUpdate.getToEvt()));
+ EventCDTLocalServiceUtil.updateEventCDT(devoirToUpdate);
+ }
+ nbImportedHomeworks++;
+ }
+
+ logger.info("Generating report ...");
+ StringBuilder report = new StringBuilder();
+ report.append("Rapport de la restauration du cahier de texte:</br></br>");
+ report.append("MATIERES</br>");
+ report.append(" - " + nbImportedSubjects + " matières importées</br>");
+ if (nbCreatedSubjects != 0) {
+ report.append(" - " + nbCreatedSubjects + " matières créées : "+subjectsCreatedReport+"</br>");
+ }
+
+ report.append("</br>GROUPES</br>");
+ report.append(" - " + nbImportedGroups + " groupes importés</br>");
+ if (nbNonImportedGroups != 0) {
+ report.append(" - " + nbNonImportedGroups + " groupes n'ont pas été importés : "+nonImportedGroupsReport+"</br>");
+ }
+
+ report.append("</br>EVENEMENTS</br>");
+ report.append(" - " + nbImportedEvents + " cours importés</br>");
+ report.append(" - " + nbImportedHomeworks + " devoirs importés</br>");
+ if (nbExistingEvents != 0) {
+ report.append(" - " + nbExistingEvents + " cours n'ont pas été importés car un cours existe déjà aux mêmes heures, pour la même matière et la même classe.</br>");
+ }
+ if (nbNonImportedHomeworks != 0) {
+ report.append(" - " + nbNonImportedHomeworks + " devoirs n'ont pas été importés (voir le rapport d'erreur)</br>");
+ }
+ report.append("</br></br>");
+ report.append("Erreurs d'importation:</br>");
+ if (errorsReport.equals("")) {
+ report.append("Aucune.");
+ } else {
+ report.append(errorsReport);
+ }
+ report.append("</br></br>");
+
+ return report.toString();
+ }
+
+
+ /**
+ * Import all internal messaging objects from an xml content : folders, messages, receivers and attached files
+ * @param user
+ * @param xmlContent
+ * @return the import report as a string
+ * @throws PortalException
+ * @throws SystemException
+ * @throws UnsupportedEncodingException
+ */
+ public String importNeroMessagerie(User user, String xmlContent) throws PortalException, SystemException, UnsupportedEncodingException {
+
+ logger.info("Restoring internal messaging...");
+
+ Long userId = user.getUserId();
+ long companyId = user.getCompanyId();
+
+ // Reporting variables
+ int nbFolders = 0;
+ int nbUsers = 0;
+ int nbNotFoundUsers = 0;
+ int nbReceivers = 0;
+ int nbNotFoundReceivers = 0;
+ int nbMessages = 0;
+ int nbNonImportedMessages = 0;
+
+ // Use Xstream for export to XML
+ XStream xstream = new XStream(new DomDriver("UTF-8"));
+ xstream.addImplicitCollection(InternalFolderMessageList.class, "ifmList");
+ xstream.addImplicitCollection(InternalMessageList.class, "imList");
+ xstream.addImplicitCollection(InternalReceiversList.class, "irList");
+ xstream.addImplicitCollection(InternalAttachFileList.class, "iafList");
+ xstream.addImplicitCollection(NeroUserMap.class, "neroUsersMap");
+ NeroIMComposite returnIMComposite = (NeroIMComposite)xstream.fromXML(xmlContent);
+
+ // Attached files
+ iafObj = returnIMComposite.getIafList();
+
+
+ // Get folders
+ Map<Long,Long> ifmIdMap = new HashMap<Long,Long>();
+ List<InternalFolderMessage> foldersTmp;
+ for (InternalFolderMessageXstreamImpl ifmX: returnIMComposite.getIfmList().getIfmList()) {
+
+ // Incoming
+ if (ifmX.getFolderType().equals(InternalMessagingConstants.INCOMMING_FOLDER_TYPE)) {
+ foldersTmp = InternalFolderMessageLocalServiceUtil.getUserFolderTypeMessages(userId, InternalMessagingConstants.INCOMMING_FOLDER_TYPE);
+ ifmIdMap.put(ifmX.getFolderMessageId(), foldersTmp.get(0).getFolderMessageId());
+ }
+
+ // Sent messages
+ else if (ifmX.getFolderType().equals(InternalMessagingConstants.SENDING_FOLDER_TYPE)) {
+ foldersTmp = InternalFolderMessageLocalServiceUtil.getUserFolderTypeMessages(userId, InternalMessagingConstants.SENDING_FOLDER_TYPE);
+ ifmIdMap.put(ifmX.getFolderMessageId(), foldersTmp.get(0).getFolderMessageId());
+ }
+
+ // Trash
+ else if (ifmX.getFolderType().equals(InternalMessagingConstants.TRASH_FOLDER_TYPE)) {
+ foldersTmp = InternalFolderMessageLocalServiceUtil.getUserFolderTypeMessages(userId, InternalMessagingConstants.TRASH_FOLDER_TYPE);
+ ifmIdMap.put(ifmX.getFolderMessageId(), foldersTmp.get(0).getFolderMessageId());
+ }
+
+ // Draft
+ else if (ifmX.getFolderType().equals(InternalMessagingConstants.DRAFT_FOLDER_TYPE)) {
+ foldersTmp = InternalFolderMessageLocalServiceUtil.getUserFolderTypeMessages(userId, InternalMessagingConstants.DRAFT_FOLDER_TYPE);
+ ifmIdMap.put(ifmX.getFolderMessageId(), foldersTmp.get(0).getFolderMessageId());
+ }
+
+ // Personal folder
+ else if (ifmX.getFolderType().equals(InternalMessagingConstants.PERSONNAL_FOLDER_TYPE)) {
+
+ // Does a personal folder with same type and name exist ?
+ List<InternalFolderMessage> myNodePathFolders = InternalFolderMessageLocalServiceUtil.getUserFolderMessages(userId, ifmX.getNodePath());
+ boolean exist = false;
+ for (InternalFolderMessage imf: myNodePathFolders) {
+ if (imf.getFolderType().equals(InternalMessagingConstants.PERSONNAL_FOLDER_TYPE) && imf.getFolderName().equals(ifmX.getFolderName())) {
+ exist = true;
+ ifmIdMap.put(ifmX.getFolderMessageId(), imf.getFolderMessageId());
+ break;
+ }
+ }
+ // If not, let's create it
+ if (!exist) {
+ InternalFolderMessage myPersonalFolder = InternalFolderMessageLocalServiceUtil.addFolderMessage();
+ myPersonalFolder.setFolderName(ifmX.getFolderName());
+ myPersonalFolder.setFolderType(InternalMessagingConstants.PERSONNAL_FOLDER_TYPE);
+ myPersonalFolder.setIsDeletable(ifmX.getIsDeletable());
+ myPersonalFolder.setNodePath(ifmX.getNodePath());
+ myPersonalFolder.setOrderEntity(ifmX.getOrderEntity());
+ myPersonalFolder.setUserId(ifmX.getUserId());
+ InternalFolderMessageLocalServiceUtil.updateInternalFolderMessage(myPersonalFolder);
+ ifmIdMap.put(ifmX.getFolderMessageId(), myPersonalFolder.getFolderMessageId());
+ }
+ }
+ nbFolders++;
+ }
+
+
+ // Map users with their email adress
+ logger.info("Mapping users ...");
+ String userEmailNotFoundReport = "";
+ Map<Long, NeroUserComposite> nuMap = returnIMComposite.getNeroUsers().getNeroUsersMap();
+ Map<Long,Long> userIdMap = new HashMap<Long,Long>();
+ for (Long _userId : nuMap.keySet()) {
+ NeroUserComposite userComposite = nuMap.get(_userId);
+ try {
+ User targetUser = UserLocalServiceUtil.getUserByEmailAddress(companyId, userComposite.getEmail());
+ logger.info("Mapped source userId "+_userId+" with "+targetUser.getUserId());
+ userIdMap.put(_userId, targetUser.getUserId());
+ nbUsers++;
+ } catch (Exception e) {
+ nbNotFoundUsers++;
+ userEmailNotFoundReport += userComposite.getSn() + " " + userComposite.getGivenName() + " (" +userComposite.getEmail()+ "), ";
+ logger.warn("Could not get source user email "+userComposite.getEmail()+" in the target environment");
+ continue;
+ }
+ }
+
+ // Receivers
+ logger.info("Mapping receivers ...");
+ InternalReceiversList irObj = returnIMComposite.getIrList();
+ Map<Long, Set<Long>> receiversMap = new HashMap<Long, Set<Long>>();
+ List<InternalReceiversXstreamImpl> irList = irObj.getIrList();
+
+ String receiverReport = "";
+ for (InternalReceiversXstreamImpl ir : irList) {
+ long messageId = ir.getMessageId();
+ String receivers = ir.getReceivers();
+ String[] receiversTab = receivers.split(",");
+ Set<Long> receiversList = new HashSet<Long>();
+ if (receiversTab != null) {
+ for (String receiverStr : receiversTab) {
+ if (!receiverStr.equals("")) {
+ try {
+ long receiverLong = Integer.parseInt(receiverStr);
+ // Convert source receiver id to target receiver id
+ if (userIdMap.containsKey(new Long(receiverLong))) {
+ receiversList.add(userIdMap.get(new Long(receiverLong)));
+ nbReceivers++;
+ } else {
+ receiverReport += "Le destinataire '"+receiverStr+"' n'a pas pu etre identifié</br>";
+ nbNotFoundReceivers++;
+ }
+ } catch (NumberFormatException nfe) {
+ receiverReport += "Le destinataire '"+receiverStr+"' n'a pas pu etre identifié</br>";
+ nbNotFoundReceivers++;
+ }
+ }
+ }
+ }
+ receiversMap.put(messageId, receiversList);
+ }
+
+ ServiceContext serviceContext = new ServiceContext();
+ serviceContext.setAddCommunityPermissions(true);
+ serviceContext.setAddGuestPermissions(true);
+
+ // Messages
+ logger.info("Importing messages ...");
+ InternalMessageList imObj = returnIMComposite.getImList();
+ List<InternalMessageXstreamImpl> imList = imObj.getImList();
+ String messageFolderReport = "";
+ String messageSenderReport = "";
+
+ for (InternalMessageXstreamImpl imToImport : imList) {
+
+ InternalMessage internalMessage = InternalMessageLocalServiceUtil.addMessage();
+
+ // Folder id : link with the target folder id
+ long sourceFolderId = imToImport.getFolderMessageId();
+ if (ifmIdMap.containsKey(new Long(sourceFolderId))) {
+ internalMessage.setFolderMessageId(ifmIdMap.get(new Long(sourceFolderId)));
+ } else {
+ messageFolderReport += "Le dossier (id="+sourceFolderId+") n'a pas été créé dans l'environnement cible.</br>";
+ nbNonImportedMessages++;
+ continue;
+ }
+
+ // Message send id : map with current user
+ long sourceSenderId = imToImport.getMessageSendId();
+ if (userIdMap.containsKey(new Long(sourceSenderId))) {
+ internalMessage.setMessageSendId(userIdMap.get(sourceSenderId));
+ } else {
+ internalMessage.setMessageSendId(0);
+ //messageSenderReport += "L'expéditeur (id="+sourceSenderId+") n'a pas été trouvé (warning).\n";
+ }
+
+ // Pj Folder id set to 0. Will be overriden in ThreadImportMessage when processing the attached files
+// DLFolder rootFolder = FoldersUtil.getIMBox(user.getUserId());
+// DLFolder pjFolder = DLFolderLocalServiceUtil.addFolder(user.getUserId(), user.getGroup().getGroupId(), rootFolder.getFolderId(), "PJ du message "+imToImport.getMessageId(), "PJ du message "+imToImport.getMessageId(), serviceContext);
+ internalMessage.setPjFolderId(0);
+
+ // Sender id
+ long senderId = imToImport.getSenderId();
+ if (userIdMap.containsKey(new Long(senderId))) {
+ internalMessage.setSenderId(userIdMap.get(senderId));
+ } else {
+ internalMessage.setSenderId(0);
+ messageSenderReport += "L'expéditeur (id="+senderId+") n'a pas été trouvé (warning).</br>";
+ }
+
+ internalMessage.setFirstReceiverName(imToImport.getFirstReceiverName());
+ internalMessage.setFlags(imToImport.getFlags());
+ internalMessage.setIsNew(imToImport.getIsNew());
+ internalMessage.setMessageContent(imToImport.getMessageContent());
+ internalMessage.setMessageSubject(imToImport.getMessageSubject());
+ internalMessage.setSendDate(imToImport.getSendDate());
+ internalMessage.setSenderName(imToImport.getSenderName());
+
+ InternalMessageLocalServiceUtil.updateInternalMessage(internalMessage);
+
+ // Receivers
+ if (receiversMap.containsKey(imToImport.getMessageId())) {
+ logger.info("Adding messageid "+internalMessage.getMessageId()+" receivers "+receiversMap.get(imToImport.getMessageId()));
+ InternalReceiversLocalServiceUtil.addInternalReceivers(internalMessage.getMessageId(), receiversMap.get(imToImport.getMessageId()));
+
+ // Internal receiver
+ InternalReceiverLocalServiceUtil.addReceivers(internalMessage.getMessageId(), receiversMap.get(imToImport.getMessageId()));
+ nbReceivers += receiversMap.get(imToImport.getMessageId()).size();
+ } else {
+ receiverReport += "Les destinataires du message (id="+imToImport.getMessageId()+") n'ont pas été trouvés.\n";
+ nbNotFoundReceivers++;
+ }
+
+
+ // Fill messageId map
+ messageIdMap.put(new Long(imToImport.getMessageId()), new Long(internalMessage.getMessageId()));
+
+ }
+
+ logger.info("Generating import report ...");
+ StringBuilder report = new StringBuilder();
+ report.append("Rapport de la restauration de la messagerie interne</br></br>");
+ report.append(nbFolders + " dossiers ont été importés.</br>");
+ report.append(nbUsers + "utilisateurs liés ont été identifiés.</br>");
+ if (nbNotFoundUsers > 0) {
+ report.append(nbNotFoundUsers + "utilisateurs liés n'ont pas été identifiés ");
+ report.append(userEmailNotFoundReport + "</br>");
+ }
+
+ report.append(nbReceivers + " destinataires ont été identifiés.</br>");
+ if (nbNotFoundReceivers >0) {
+ report.append(nbNotFoundReceivers + " destinataires n'ont pas été identifiés.</br>");
+ }
+
+ report.append(nbMessages + " messages ont été importés.</br>");
+ if (nbNonImportedMessages > 0) {
+ report.append(nbNonImportedMessages + "messages n'ont pas été importés.</br>");
+ }
+ report.append("</br>Les erreurs suivantes sont apparues lors de la restauration:</br>");
+ report.append(messageFolderReport + "</br>");
+ report.append(messageSenderReport + "</br>");
+ report.append(receiverReport + "</br>");
+
+ return report.toString();
+ }
+
+
+
+ static String[] colorsPool = new String[]{
+ "blue",
+ "red",
+ "cyan",
+ "orange",
+ "green",
+ "purple"
+ };
+
+ public Map<Long, Long> getMessageIdMap() {
+ return messageIdMap;
+ }
+
+ public void setMessageIdMap(Map<Long, Long> messageIdMap) {
+ this.messageIdMap = messageIdMap;
+ }
+
+ public InternalAttachFileList getIafObj() {
+ return iafObj;
+ }
+
+ public void setIafObj(InternalAttachFileList iafObj) {
+ this.iafObj = iafObj;
+ }
+
+ public Map<Long, Long> getEventIdMap() {
+ return eventIdMap;
+ }
+
+
+
+
+}