| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License") + you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package org.apache.openmeetings.servlet.outputhandler; |
| |
| import static org.apache.commons.transaction.util.FileHelper.copyRec; |
| import static org.apache.openmeetings.utils.OmFileHelper.getStreamsHibernateDir; |
| import static org.apache.openmeetings.utils.OmFileHelper.getUploadDir; |
| import static org.apache.openmeetings.utils.OmFileHelper.getUploadProfilesUserDir; |
| import static org.apache.openmeetings.utils.OmFileHelper.getUploadRoomDir; |
| import static org.apache.openmeetings.utils.OmFileHelper.profilesPrefix; |
| |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.StringReader; |
| import java.io.StringWriter; |
| import java.util.ArrayList; |
| import java.util.Date; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.zip.ZipEntry; |
| import java.util.zip.ZipInputStream; |
| |
| import javax.servlet.ServletException; |
| import javax.servlet.http.HttpServletRequest; |
| import javax.servlet.http.HttpServletResponse; |
| import javax.xml.parsers.DocumentBuilder; |
| import javax.xml.parsers.DocumentBuilderFactory; |
| import javax.xml.transform.Transformer; |
| import javax.xml.transform.TransformerFactory; |
| import javax.xml.transform.dom.DOMSource; |
| import javax.xml.transform.stream.StreamResult; |
| |
| import org.apache.commons.transaction.util.FileHelper; |
| import org.apache.openmeetings.OpenmeetingsVariables; |
| import org.apache.openmeetings.backup.AppointmentCategoryConverter; |
| import org.apache.openmeetings.backup.AppointmentConverter; |
| import org.apache.openmeetings.backup.AppointmentReminderTypeConverter; |
| import org.apache.openmeetings.backup.DateConverter; |
| import org.apache.openmeetings.backup.IntegerTransform; |
| import org.apache.openmeetings.backup.LongTransform; |
| import org.apache.openmeetings.backup.OmTimeZoneConverter; |
| import org.apache.openmeetings.backup.OrganisationConverter; |
| import org.apache.openmeetings.backup.PollTypeConverter; |
| import org.apache.openmeetings.backup.RoomConverter; |
| import org.apache.openmeetings.backup.RoomTypeConverter; |
| import org.apache.openmeetings.backup.StateConverter; |
| import org.apache.openmeetings.backup.UserConverter; |
| import org.apache.openmeetings.data.basic.dao.ConfigurationDao; |
| import org.apache.openmeetings.data.basic.dao.LdapConfigDao; |
| import org.apache.openmeetings.data.basic.dao.OmTimeZoneDao; |
| import org.apache.openmeetings.data.calendar.daos.AppointmentCategoryDao; |
| import org.apache.openmeetings.data.calendar.daos.AppointmentDao; |
| import org.apache.openmeetings.data.calendar.daos.AppointmentReminderTypDao; |
| import org.apache.openmeetings.data.calendar.daos.MeetingMemberDao; |
| import org.apache.openmeetings.data.conference.PollManager; |
| import org.apache.openmeetings.data.conference.RoomManager; |
| import org.apache.openmeetings.data.conference.dao.RoomDao; |
| import org.apache.openmeetings.data.file.dao.FileExplorerItemDao; |
| import org.apache.openmeetings.data.flvrecord.FlvRecordingDao; |
| import org.apache.openmeetings.data.user.OrganisationManager; |
| import org.apache.openmeetings.data.user.dao.OrganisationDao; |
| import org.apache.openmeetings.data.user.dao.PrivateMessageFolderDao; |
| import org.apache.openmeetings.data.user.dao.PrivateMessagesDao; |
| import org.apache.openmeetings.data.user.dao.StateDao; |
| import org.apache.openmeetings.data.user.dao.UserContactsDao; |
| import org.apache.openmeetings.data.user.dao.UsersDao; |
| import org.apache.openmeetings.documents.beans.UploadCompleteMessage; |
| import org.apache.openmeetings.persistence.beans.basic.Configuration; |
| import org.apache.openmeetings.persistence.beans.basic.LdapConfig; |
| import org.apache.openmeetings.persistence.beans.basic.OmTimeZone; |
| import org.apache.openmeetings.persistence.beans.calendar.Appointment; |
| import org.apache.openmeetings.persistence.beans.calendar.AppointmentCategory; |
| import org.apache.openmeetings.persistence.beans.calendar.AppointmentReminderTyps; |
| import org.apache.openmeetings.persistence.beans.calendar.MeetingMember; |
| import org.apache.openmeetings.persistence.beans.domain.Organisation; |
| import org.apache.openmeetings.persistence.beans.files.FileExplorerItem; |
| import org.apache.openmeetings.persistence.beans.flvrecord.FlvRecording; |
| import org.apache.openmeetings.persistence.beans.flvrecord.FlvRecordingMetaData; |
| import org.apache.openmeetings.persistence.beans.poll.PollType; |
| import org.apache.openmeetings.persistence.beans.poll.RoomPoll; |
| import org.apache.openmeetings.persistence.beans.poll.RoomPollAnswers; |
| import org.apache.openmeetings.persistence.beans.room.Room; |
| import org.apache.openmeetings.persistence.beans.room.RoomModerator; |
| import org.apache.openmeetings.persistence.beans.room.RoomOrganisation; |
| import org.apache.openmeetings.persistence.beans.room.RoomType; |
| import org.apache.openmeetings.persistence.beans.user.Address; |
| import org.apache.openmeetings.persistence.beans.user.PrivateMessage; |
| import org.apache.openmeetings.persistence.beans.user.PrivateMessageFolder; |
| import org.apache.openmeetings.persistence.beans.user.State; |
| import org.apache.openmeetings.persistence.beans.user.User; |
| import org.apache.openmeetings.persistence.beans.user.UserContact; |
| import org.apache.openmeetings.remote.red5.ScopeApplicationAdapter; |
| import org.apache.openmeetings.utils.OmFileHelper; |
| import org.apache.openmeetings.utils.crypt.MD5Implementation; |
| import org.apache.openmeetings.utils.math.CalendarPatterns; |
| import org.red5.logging.Red5LoggerFactory; |
| import org.simpleframework.xml.Serializer; |
| import org.simpleframework.xml.convert.Registry; |
| import org.simpleframework.xml.convert.RegistryStrategy; |
| import org.simpleframework.xml.core.Persister; |
| import org.simpleframework.xml.strategy.Strategy; |
| import org.simpleframework.xml.stream.InputNode; |
| import org.simpleframework.xml.stream.NodeBuilder; |
| import org.simpleframework.xml.transform.RegistryMatcher; |
| import org.slf4j.Logger; |
| import org.springframework.beans.factory.annotation.Autowired; |
| import org.springframework.stereotype.Controller; |
| import org.springframework.web.bind.annotation.RequestMapping; |
| import org.springframework.web.bind.annotation.RequestMethod; |
| import org.springframework.web.multipart.MultipartFile; |
| import org.w3c.dom.Document; |
| import org.w3c.dom.Node; |
| import org.w3c.dom.NodeList; |
| import org.xml.sax.InputSource; |
| |
| @Controller |
| public class BackupImportController extends AbstractUploadController { |
| |
| private static final Logger log = Red5LoggerFactory.getLogger( |
| BackupImportController.class, OpenmeetingsVariables.webAppRootKey); |
| |
| @Autowired |
| private AppointmentDao appointmentDao; |
| @Autowired |
| private StateDao statemanagement; |
| @Autowired |
| private OmTimeZoneDao omTimeZoneDaoImpl; |
| @Autowired |
| private OrganisationManager organisationManager; |
| @Autowired |
| private OrganisationDao orgDao; |
| @Autowired |
| private RoomManager roomManager; |
| @Autowired |
| private RoomDao roomDao; |
| @Autowired |
| private AppointmentCategoryDao appointmentCategoryDaoImpl; |
| @Autowired |
| private AppointmentReminderTypDao appointmentReminderTypDaoImpl; |
| @Autowired |
| private UsersDao usersDao; |
| @Autowired |
| private FlvRecordingDao flvRecordingDao; |
| @Autowired |
| private PrivateMessageFolderDao privateMessageFolderDao; |
| @Autowired |
| private PrivateMessagesDao privateMessagesDao; |
| @Autowired |
| private MeetingMemberDao meetingMemberDao; |
| @Autowired |
| private LdapConfigDao ldapConfigDao; |
| @Autowired |
| private FileExplorerItemDao fileExplorerItemDao; |
| @Autowired |
| private UserContactsDao userContactsDao; |
| @Autowired |
| private ScopeApplicationAdapter scopeApplicationAdapter; |
| @Autowired |
| private PollManager pollManager; |
| @Autowired |
| private ConfigurationDao configurationDao; |
| |
| private final HashMap<Long, Long> usersMap = new HashMap<Long, Long>(); |
| private final HashMap<Long, Long> organisationsMap = new HashMap<Long, Long>(); |
| private final HashMap<Long, Long> appointmentsMap = new HashMap<Long, Long>(); |
| private final HashMap<Long, Long> roomsMap = new HashMap<Long, Long>(); |
| private final HashMap<Long, Long> messageFoldersMap = new HashMap<Long, Long>(); |
| private final HashMap<Long, Long> userContactsMap = new HashMap<Long, Long>(); |
| |
| private enum Maps { |
| USERS, ORGANISATIONS, APPOINTMENTS, ROOMS, MESSAGEFOLDERS, USERCONTACTS |
| }; |
| |
| public void performImport(InputStream is) throws Exception { |
| File working_dir = OmFileHelper.getUploadImportDir(); |
| if (!working_dir.exists()) { |
| working_dir.mkdir(); |
| } |
| |
| File f = OmFileHelper.getNewDir(working_dir, "import_" + CalendarPatterns.getTimeForStreamId(new Date())); |
| |
| log.debug("##### WRITE FILE TO: " + f); |
| |
| ZipInputStream zipinputstream = new ZipInputStream(is); |
| ZipEntry zipentry = zipinputstream.getNextEntry(); |
| while (zipentry != null) { |
| String fName = zipentry.getName(); |
| if (File.pathSeparatorChar != '\\' && fName.indexOf('\\') > -1) { |
| fName = fName.replace('\\', '/'); |
| } |
| // for each entry to be extracted |
| File fentry = new File(f, fName); |
| File dir = fentry.isDirectory() ? fentry : fentry.getParentFile(); |
| dir.mkdirs(); |
| if (fentry.isDirectory()) { |
| zipentry = zipinputstream.getNextEntry(); |
| continue; |
| } |
| |
| FileHelper.copy(zipinputstream, fentry); |
| zipinputstream.closeEntry(); |
| zipentry = zipinputstream.getNextEntry(); |
| |
| } |
| zipinputstream.close(); |
| |
| /* |
| * ##################### Import Organizations |
| */ |
| Serializer simpleSerializer = new Persister(); |
| { |
| List<Organisation> list = readList(simpleSerializer, f, "organizations.xml", "organisations", Organisation.class); |
| for (Organisation o : list) { |
| long oldId = o.getOrganisation_id(); |
| o.setOrganisation_id(null); |
| Long newId = organisationManager.addOrganisationObj(o); |
| organisationsMap.put(oldId, newId); |
| } |
| } |
| |
| log.info("Organizations import complete, starting user import"); |
| /* |
| * ##################### Import Users |
| */ |
| { |
| List<User> list = readUserList(f, "users.xml", "users"); |
| for (User u : list) { |
| OmTimeZone tz = u.getOmTimeZone(); |
| if (tz == null || tz.getJname() == null) { |
| String jNameTimeZone = configurationDao.getConfValue( |
| "default.timezone", String.class, "Europe/Berlin"); |
| OmTimeZone omTimeZone = omTimeZoneDaoImpl.getOmTimeZone(jNameTimeZone); |
| u.setOmTimeZone(omTimeZone); |
| u.setForceTimeZoneCheck(true); |
| } else { |
| u.setForceTimeZoneCheck(false); |
| } |
| |
| u.setStarttime(new Date()); |
| long userId = u.getUser_id(); |
| u.setUser_id(null); |
| if (u.getSipUser() != null && u.getSipUser().getId() != 0) { |
| u.getSipUser().setId(0); |
| } |
| usersDao.update(u, -1L); |
| usersMap.put(userId, u.getUser_id()); |
| } |
| } |
| |
| log.info("Users import complete, starting room import"); |
| /* |
| * ##################### Import Rooms |
| */ |
| { |
| Registry registry = new Registry(); |
| Strategy strategy = new RegistryStrategy(registry); |
| RegistryMatcher matcher = new RegistryMatcher(); //TODO need to be removed in the later versions |
| Serializer serializer = new Persister(strategy, matcher); |
| |
| matcher.bind(Long.class, LongTransform.class); |
| matcher.bind(Integer.class, IntegerTransform.class); |
| registry.bind(User.class, new UserConverter(usersDao, usersMap)); |
| registry.bind(RoomType.class, new RoomTypeConverter(roomManager)); |
| |
| List<Room> list = readList(serializer, f, "rooms.xml", "rooms", Room.class); |
| for (Room r : list) { |
| Long roomId = r.getRooms_id(); |
| |
| // We need to reset ids as openJPA reject to store them otherwise |
| r.setRooms_id(null); |
| if (r.getModerators() != null) { |
| for (Iterator<RoomModerator> i = r.getModerators().iterator(); i.hasNext();) { |
| RoomModerator rm = i.next(); |
| if (rm.getUser().getUser_id() == null) { |
| i.remove(); |
| } |
| } |
| } |
| r = roomDao.update(r, null); |
| roomsMap.put(roomId, r.getRooms_id()); |
| } |
| } |
| |
| log.info("Room import complete, starting room organizations import"); |
| /* |
| * ##################### Import Room Organisations |
| */ |
| { |
| Registry registry = new Registry(); |
| Strategy strategy = new RegistryStrategy(registry); |
| Serializer serializer = new Persister(strategy); |
| |
| registry.bind(Organisation.class, new OrganisationConverter(orgDao, organisationsMap)); |
| registry.bind(Room.class, new RoomConverter(roomDao, roomsMap)); |
| |
| List<RoomOrganisation> list = readList(serializer, f, "rooms_organisation.xml", "room_organisations", RoomOrganisation.class); |
| for (RoomOrganisation ro : list) { |
| if (!ro.getDeleted()) { |
| // We need to reset this as openJPA reject to store them otherwise |
| ro.setRooms_organisation_id(null); |
| roomManager.addRoomOrganisation(ro); |
| } |
| } |
| } |
| |
| log.info("Room organizations import complete, starting appointement import"); |
| /* |
| * ##################### Import Appointements |
| */ |
| { |
| Registry registry = new Registry(); |
| Strategy strategy = new RegistryStrategy(registry); |
| Serializer serializer = new Persister(strategy); |
| |
| registry.bind(AppointmentCategory.class, new AppointmentCategoryConverter(appointmentCategoryDaoImpl)); |
| registry.bind(User.class, new UserConverter(usersDao, usersMap)); |
| registry.bind(AppointmentReminderTyps.class, new AppointmentReminderTypeConverter(appointmentReminderTypDaoImpl)); |
| registry.bind(Room.class, new RoomConverter(roomDao, roomsMap)); |
| registry.bind(Date.class, DateConverter.class); |
| |
| List<Appointment> list = readList(serializer, f, "appointements.xml", "appointments", Appointment.class); |
| for (Appointment a : list) { |
| Long appId = a.getAppointmentId(); |
| |
| // We need to reset this as openJPA reject to store them otherwise |
| a.setAppointmentId(null); |
| if (a.getUserId() != null && a.getUserId().getUser_id() == null) { |
| a.setUserId(null); |
| } |
| Long newAppId = appointmentDao.addAppointmentObj(a); |
| appointmentsMap.put(appId, newAppId); |
| } |
| } |
| |
| log.info("Appointement import complete, starting meeting members import"); |
| /* |
| * ##################### Import MeetingMembers |
| * |
| * Reminder Invitations will be NOT send! |
| */ |
| { |
| Registry registry = new Registry(); |
| Strategy strategy = new RegistryStrategy(registry); |
| Serializer serializer = new Persister(strategy); |
| |
| registry.bind(User.class, new UserConverter(usersDao, usersMap)); |
| registry.bind(Appointment.class, new AppointmentConverter(appointmentDao, appointmentsMap)); |
| |
| List<MeetingMember> list = readList(serializer, f, "meetingmembers.xml", "meetingmembers", MeetingMember.class); |
| for (MeetingMember ma : list) { |
| if (ma.getUserid() != null && ma.getUserid().getUser_id() == null) { |
| ma.setUserid(null); |
| } |
| if (!ma.getDeleted()) { |
| // We need to reset this as openJPA reject to store them otherwise |
| ma.setMeetingMemberId(null); |
| meetingMemberDao.addMeetingMemberByObject(ma); |
| } |
| } |
| } |
| |
| log.info("Meeting members import complete, starting ldap config import"); |
| /* |
| * ##################### Import LDAP Configs |
| */ |
| { |
| List<LdapConfig> list = readList(simpleSerializer, f, "ldapconfigs.xml", "ldapconfigs", LdapConfig.class, true); |
| for (LdapConfig c : list) { |
| ldapConfigDao.addLdapConfigByObject(c); |
| } |
| } |
| |
| log.info("Ldap config import complete, starting recordings import"); |
| /* |
| * ##################### Import Recordings |
| */ |
| { |
| Registry registry = new Registry(); |
| Strategy strategy = new RegistryStrategy(registry); |
| RegistryMatcher matcher = new RegistryMatcher(); //TODO need to be removed in the later versions |
| Serializer serializer = new Persister(strategy, matcher); |
| |
| matcher.bind(Long.class, LongTransform.class); |
| matcher.bind(Integer.class, IntegerTransform.class); |
| registry.bind(Date.class, DateConverter.class); |
| |
| List<FlvRecording> list = readList(serializer, f, "flvRecordings.xml", "flvrecordings", FlvRecording.class, true); |
| for (FlvRecording fr : list) { |
| fr.setFlvRecordingId(0); |
| if (fr.getRoom_id() != null) { |
| fr.setRoom_id(roomsMap.get(fr.getRoom_id())); |
| } |
| if (fr.getOwnerId() != null) { |
| fr.setOwnerId(usersMap.get(fr.getOwnerId())); |
| } |
| if (fr.getFlvRecordingMetaData() != null) { |
| for (FlvRecordingMetaData meta : fr.getFlvRecordingMetaData()) { |
| meta.setFlvRecordingMetaDataId(0); |
| meta.setFlvRecording(fr); |
| } |
| } |
| flvRecordingDao.addFlvRecordingObj(fr); |
| } |
| } |
| |
| log.info("FLVrecording import complete, starting private message folder import"); |
| /* |
| * ##################### Import Private Message Folders |
| */ |
| { |
| List<PrivateMessageFolder> list = readList(simpleSerializer, f, "privateMessageFolder.xml" |
| , "privatemessagefolders", PrivateMessageFolder.class, true); |
| for (PrivateMessageFolder p : list) { |
| Long folderId = p.getPrivateMessageFolderId(); |
| PrivateMessageFolder storedFolder = privateMessageFolderDao |
| .getPrivateMessageFolderById(folderId); |
| if (storedFolder == null) { |
| p.setPrivateMessageFolderId(0); |
| Long newFolderId = privateMessageFolderDao |
| .addPrivateMessageFolderObj(p); |
| messageFoldersMap.put(folderId, newFolderId); |
| } |
| } |
| } |
| |
| log.info("Private message folder import complete, starting user contacts import"); |
| /* |
| * ##################### Import User Contacts |
| */ |
| { |
| Registry registry = new Registry(); |
| Strategy strategy = new RegistryStrategy(registry); |
| Serializer serializer = new Persister(strategy); |
| |
| registry.bind(User.class, new UserConverter(usersDao, usersMap)); |
| |
| List<UserContact> list = readList(serializer, f, "userContacts.xml", "usercontacts", UserContact.class, true); |
| for (UserContact uc : list) { |
| Long ucId = uc.getUserContactId(); |
| UserContact storedUC = userContactsDao.getUserContacts(ucId); |
| |
| if (storedUC == null && uc.getContact() != null && uc.getContact().getUser_id() != null) { |
| uc.setUserContactId(0); |
| Long newId = userContactsDao.addUserContactObj(uc); |
| userContactsMap.put(ucId, newId); |
| } |
| } |
| } |
| |
| log.info("Usercontact import complete, starting private messages item import"); |
| /* |
| * ##################### Import Private Messages |
| */ |
| { |
| Registry registry = new Registry(); |
| Strategy strategy = new RegistryStrategy(registry); |
| Serializer serializer = new Persister(strategy); |
| |
| registry.bind(User.class, new UserConverter(usersDao, usersMap)); |
| registry.bind(Room.class, new RoomConverter(roomDao, roomsMap)); |
| registry.bind(Date.class, DateConverter.class); |
| |
| List<PrivateMessage> list = readList(serializer, f, "privateMessages.xml", "privatemessages", PrivateMessage.class, true); |
| for (PrivateMessage p : list) { |
| p.setPrivateMessageId(0); |
| p.setPrivateMessageFolderId( |
| getNewId(p.getPrivateMessageFolderId(), Maps.MESSAGEFOLDERS)); |
| p.setUserContactId( |
| getNewId(p.getUserContactId(), Maps.USERCONTACTS)); |
| if (p.getRoom() != null && p.getRoom().getRooms_id() == null) { |
| p.setRoom(null); |
| } |
| if (p.getTo() != null && p.getTo().getUser_id() == null) { |
| p.setTo(null); |
| } |
| if (p.getFrom() != null && p.getFrom().getUser_id() == null) { |
| p.setFrom(null); |
| } |
| if (p.getOwner() != null && p.getOwner().getUser_id() == null) { |
| p.setOwner(null); |
| } |
| privateMessagesDao.addPrivateMessageObj(p); |
| } |
| } |
| |
| log.info("Private message import complete, starting file explorer item import"); |
| /* |
| * ##################### Import File-Explorer Items |
| */ |
| { |
| Registry registry = new Registry(); |
| Strategy strategy = new RegistryStrategy(registry); |
| RegistryMatcher matcher = new RegistryMatcher(); //TODO need to be removed in the later versions |
| Serializer serializer = new Persister(strategy, matcher); |
| |
| matcher.bind(Long.class, LongTransform.class); |
| matcher.bind(Integer.class, IntegerTransform.class); |
| registry.bind(Date.class, DateConverter.class); |
| |
| List<FileExplorerItem> list = readList(serializer, f, "fileExplorerItems.xml", "fileExplorerItems", FileExplorerItem.class, true); |
| for (FileExplorerItem file : list) { |
| // We need to reset this as openJPA reject to store them otherwise |
| file.setFileExplorerItemId(0); |
| Long roomId = file.getRoom_id(); |
| file.setRoom_id(roomsMap.containsKey(roomId) ? roomsMap.get(roomId) : null); |
| if (file.getOwnerId() != null) { |
| file.setOwnerId(usersMap.get(file.getOwnerId())); |
| } |
| fileExplorerItemDao.addFileExplorerItem(file); |
| } |
| } |
| |
| log.info("File explorer item import complete, starting file poll import"); |
| /* |
| * ##################### Import Room Polls |
| */ |
| { |
| Registry registry = new Registry(); |
| Strategy strategy = new RegistryStrategy(registry); |
| RegistryMatcher matcher = new RegistryMatcher(); //TODO need to be removed in the later versions |
| Serializer serializer = new Persister(strategy, matcher); |
| |
| matcher.bind(Integer.class, IntegerTransform.class); |
| registry.bind(User.class, new UserConverter(usersDao, usersMap)); |
| registry.bind(Room.class, new RoomConverter(roomDao, roomsMap)); |
| registry.bind(PollType.class, new PollTypeConverter(pollManager)); |
| registry.bind(Date.class, DateConverter.class); |
| |
| List<RoomPoll> list = readList(serializer, f, "roompolls.xml", "roompolls", RoomPoll.class, true); |
| for (RoomPoll rp : list) { |
| if (rp.getRoom() == null || rp.getRoom().getRooms_id() == null) { |
| //room was deleted |
| continue; |
| } |
| if (rp.getCreatedBy() == null || rp.getCreatedBy().getUser_id() == null) { |
| rp.setCreatedBy(null); |
| } |
| for (RoomPollAnswers rpa : rp.getRoomPollAnswerList()) { |
| if (rpa.getVotedUser() == null || rpa.getVotedUser().getUser_id() == null) { |
| rpa.setVotedUser(null); |
| } |
| } |
| pollManager.savePollBackup(rp); |
| } |
| } |
| |
| log.info("Poll import complete, starting configs import"); |
| /* |
| * ##################### Import Configs |
| */ |
| { |
| Registry registry = new Registry(); |
| Strategy strategy = new RegistryStrategy(registry); |
| RegistryMatcher matcher = new RegistryMatcher(); //TODO need to be removed in the later versions |
| Serializer serializer = new Persister(strategy, matcher); |
| |
| matcher.bind(Long.class, LongTransform.class); |
| registry.bind(Date.class, DateConverter.class); |
| registry.bind(User.class, new UserConverter(usersDao, usersMap)); |
| |
| List<Configuration> list = readList(serializer, f, "configs.xml", "configs", Configuration.class, true); |
| for (Configuration c : list) { |
| if (c.getConf_key() == null) { |
| continue; |
| } |
| Configuration cfg = configurationDao.get(c.getConf_key()); |
| c.setConfiguration_id(cfg == null ? null : cfg.getConfiguration_id()); |
| if (c.getUser() != null && c.getUser().getUser_id() == null) { |
| c.setUser(null); |
| } |
| if ("crypt_ClassName".equals(c.getConf_key())) { |
| try { |
| Class.forName(c.getConf_value()); |
| } catch (ClassNotFoundException e) { |
| c.setConf_value(MD5Implementation.class.getCanonicalName()); |
| } |
| } |
| configurationDao.update(c, -1L); |
| } |
| } |
| |
| log.info("Configs import complete, starting copy of files and folders"); |
| /* |
| * ##################### Import real files and folders |
| */ |
| importFolders(f); |
| |
| log.info("File explorer item import complete, clearing temp files"); |
| |
| FileHelper.removeRec(f); |
| } |
| |
| @RequestMapping(value = "/backup.upload", method = RequestMethod.POST) |
| public void service(HttpServletRequest request, |
| HttpServletResponse httpServletResponse) |
| throws ServletException, IOException { |
| |
| UploadInfo info = validate(request, true); |
| try { |
| MultipartFile multipartFile = info.file; |
| InputStream is = multipartFile.getInputStream(); |
| performImport(is); |
| |
| UploadCompleteMessage uploadCompleteMessage = new UploadCompleteMessage( |
| info.userId, |
| "library", //message |
| "import", //action |
| "", //error |
| info.filename); |
| |
| scopeApplicationAdapter.sendUploadCompletMessageByPublicSID( |
| uploadCompleteMessage, info.publicSID); |
| |
| } catch (Exception e) { |
| log.error("[ImportExport]", e); |
| throw new ServletException(e); |
| } |
| |
| return; |
| } |
| |
| private <T> List<T> readList(Serializer ser, File baseDir, String fileName, String listNodeName, Class<T> clazz) throws Exception { |
| return readList(ser, baseDir, fileName, listNodeName, clazz, false); |
| } |
| |
| private <T> List<T> readList(Serializer ser, File baseDir, String fileName, String listNodeName, Class<T> clazz, boolean notThow) throws Exception { |
| List<T> list = new ArrayList<T>(); |
| File xml = new File(baseDir, fileName); |
| if (!xml.exists()) { |
| final String msg = fileName + " missing"; |
| if (notThow) { |
| log.debug(msg); |
| } else { |
| throw new Exception(msg); |
| } |
| } else { |
| InputNode root = NodeBuilder.read(new FileInputStream(xml)); |
| InputNode listNode = root.getNext(); |
| if (listNodeName.equals(listNode.getName())) { |
| InputNode item = listNode.getNext(); |
| while (item != null) { |
| T o = ser.read(clazz, item, false); |
| list.add(o); |
| item = listNode.getNext(); |
| } |
| } |
| } |
| return list; |
| } |
| |
| private Node getNode(Node doc, String name) { |
| NodeList nl = doc.getChildNodes(); |
| for (int i = 0; i < nl.getLength(); ++i) { |
| Node node = nl.item(i); |
| if (node.getNodeType() == Node.ELEMENT_NODE && name.equals(node.getNodeName())) { |
| return node; |
| } |
| } |
| return null; |
| } |
| |
| public List<User> readUserList(InputStream xml, String listNodeName) throws Exception { |
| return readUserList(new InputSource(xml), listNodeName); |
| } |
| |
| public List<User> readUserList(File baseDir, String fileName, String listNodeName) throws Exception { |
| File xml = new File(baseDir, fileName); |
| if (!xml.exists()) { |
| throw new Exception(fileName + " missing"); |
| } |
| |
| return readUserList(new InputSource(xml.toURI().toASCIIString()), listNodeName); |
| } |
| |
| //FIXME (need to be removed in later versions) HACK to fix 2 deleted nodes in users.xml and inline Adresses and sipData |
| private List<User> readUserList(InputSource xml, String listNodeName) throws Exception { |
| Registry registry = new Registry(); |
| Strategy strategy = new RegistryStrategy(registry); |
| Serializer ser = new Persister(strategy); |
| |
| registry.bind(Organisation.class, new OrganisationConverter(orgDao, organisationsMap)); |
| registry.bind(OmTimeZone.class, new OmTimeZoneConverter(omTimeZoneDaoImpl)); |
| registry.bind(State.class, new StateConverter(statemanagement)); |
| registry.bind(Date.class, DateConverter.class); |
| |
| DocumentBuilder dBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder(); |
| Document doc = dBuilder.parse(xml); |
| NodeList nl = getNode(getNode(doc, "root"), listNodeName).getChildNodes(); |
| for (int i = 0; i < nl.getLength(); ++i) { |
| Node user = nl.item(i); |
| NodeList nl1 = user.getChildNodes(); |
| boolean deletedFound = false; |
| for (int j = 0; j < nl1.getLength(); ++j) { |
| Node node = nl1.item(j); |
| if (node.getNodeType() == Node.ELEMENT_NODE && "deleted".equals(node.getNodeName())) { |
| if (deletedFound) { |
| user.removeChild(node); |
| break; |
| } |
| deletedFound = true; |
| } |
| } |
| } |
| |
| StringWriter sw = new StringWriter(); |
| Transformer xformer = TransformerFactory.newInstance().newTransformer(); |
| xformer.transform(new DOMSource(doc), new StreamResult(sw)); |
| |
| List<User> list = new ArrayList<User>(); |
| InputNode root = NodeBuilder.read(new StringReader(sw.toString())); |
| InputNode root1 = NodeBuilder.read(new StringReader(sw.toString())); //HACK to handle Address inside user |
| InputNode listNode = root.getNext(); |
| InputNode listNode1 = root1.getNext(); //HACK to handle Address inside user |
| if (listNodeName.equals(listNode.getName())) { |
| InputNode item = listNode.getNext(); |
| InputNode item1 = listNode1.getNext(); //HACK to handle Address inside user |
| while (item != null) { |
| User u = ser.read(User.class, item, false); |
| |
| //HACK to handle Address inside user |
| if (u.getAdresses() == null) { |
| Address a = ser.read(Address.class, item1, false); |
| u.setAdresses(a); |
| } |
| list.add(u); |
| item = listNode.getNext(); |
| do { |
| item1 = listNode1.getNext(); //HACK to handle Address inside user |
| } while (item != null && !"user".equals(item1.getName())); |
| } |
| } |
| return list; |
| } |
| |
| private Long getProfileId(File f) { |
| String n = f.getName(); |
| if (n.indexOf(profilesPrefix) > -1) { |
| return importLongType(n.substring(profilesPrefix.length())); |
| } |
| return null; |
| } |
| |
| private void importFolders(File importBaseDir) throws IOException { |
| // Now check the room files and import them |
| File roomFilesFolder = new File(importBaseDir, "roomFiles"); |
| |
| File uploadDir = getUploadDir(); |
| |
| log.debug("roomFilesFolder PATH " + roomFilesFolder.getCanonicalPath()); |
| |
| if (roomFilesFolder.exists()) { |
| for (File file : roomFilesFolder.listFiles()) { |
| if (file.isDirectory()) { |
| String fName = file.getName(); |
| if ("profiles".equals(fName)) { |
| // profile should correspond to the new user id |
| for (File profile : file.listFiles()) { |
| Long oldId = getProfileId(profile); |
| Long id = oldId != null ? getNewId(oldId, Maps.USERS) : null; |
| if (id != null) { |
| copyRec(profile, getUploadProfilesUserDir(id)); |
| } |
| } |
| continue; |
| } else { |
| // check if folder is room folder, store it under new id if necessary |
| Long oldId = importLongType(fName); |
| Long id = oldId != null ? getNewId(oldId, Maps.ROOMS) : null; |
| if (id != null) { |
| copyRec(file, getUploadRoomDir(id.toString())); |
| continue; |
| } |
| } |
| copyRec(file, new File(uploadDir, fName)); |
| } |
| } |
| } |
| |
| // Now check the recordings and import them |
| |
| File sourceDirRec = new File(importBaseDir, "recordingFiles"); |
| |
| log.debug("sourceDirRec PATH " + sourceDirRec.getCanonicalPath()); |
| if (sourceDirRec.exists()) { |
| copyRec(sourceDirRec, getStreamsHibernateDir()); |
| } |
| } |
| |
| private Long importLongType(String value) { |
| Long val = null; |
| try { |
| val = Long.valueOf(value); |
| } catch (Exception e) { |
| // no-op |
| } |
| return val; |
| } |
| |
| private Long getNewId(Long oldId, Maps map) { |
| Long newId = oldId; |
| switch (map) { |
| case USERS: |
| if (usersMap.containsKey(oldId)) { |
| newId = usersMap.get(oldId); |
| } |
| break; |
| case ORGANISATIONS: |
| if (organisationsMap.containsKey(oldId)) { |
| newId = organisationsMap.get(oldId); |
| } |
| break; |
| case APPOINTMENTS: |
| if (appointmentsMap.containsKey(oldId)) { |
| newId = appointmentsMap.get(oldId); |
| } |
| break; |
| case ROOMS: |
| if (roomsMap.containsKey(oldId)) { |
| newId = roomsMap.get(oldId); |
| } |
| break; |
| case MESSAGEFOLDERS: |
| if (messageFoldersMap.containsKey(oldId)) { |
| newId = messageFoldersMap.get(oldId); |
| } |
| break; |
| case USERCONTACTS: |
| if (userContactsMap.containsKey(oldId)) { |
| newId = userContactsMap.get(oldId); |
| } |
| break; |
| default: |
| break; |
| } |
| return newId; |
| } |
| } |