/*
* 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.openmeetings.servlet.outputhandler;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.regex.Pattern;
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 org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.openmeetings.app.OpenmeetingsVariables;
import org.openmeetings.app.data.basic.Configurationmanagement;
import org.openmeetings.app.data.basic.dao.LdapConfigDaoImpl;
import org.openmeetings.app.data.basic.dao.OmTimeZoneDaoImpl;
import org.openmeetings.app.data.calendar.daos.AppointmentCategoryDaoImpl;
import org.openmeetings.app.data.calendar.daos.AppointmentDaoImpl;
import org.openmeetings.app.data.calendar.daos.AppointmentReminderTypDaoImpl;
import org.openmeetings.app.data.calendar.daos.MeetingMemberDaoImpl;
import org.openmeetings.app.data.conference.PollManagement;
import org.openmeetings.app.data.conference.Roommanagement;
import org.openmeetings.app.data.conference.dao.RoomModeratorsDaoImpl;
import org.openmeetings.app.data.file.dao.FileExplorerItemDaoImpl;
import org.openmeetings.app.data.flvrecord.FlvRecordingDaoImpl;
import org.openmeetings.app.data.flvrecord.FlvRecordingMetaDataDaoImpl;
import org.openmeetings.app.data.user.Organisationmanagement;
import org.openmeetings.app.data.user.Statemanagement;
import org.openmeetings.app.data.user.dao.PrivateMessageFolderDaoImpl;
import org.openmeetings.app.data.user.dao.PrivateMessagesDaoImpl;
import org.openmeetings.app.data.user.dao.UserContactsDaoImpl;
import org.openmeetings.app.data.user.dao.UsersDaoImpl;
import org.openmeetings.app.persistence.beans.adresses.States;
import org.openmeetings.app.persistence.beans.basic.Configuration;
import org.openmeetings.app.persistence.beans.basic.LdapConfig;
import org.openmeetings.app.persistence.beans.basic.OmTimeZone;
import org.openmeetings.app.persistence.beans.calendar.Appointment;
import org.openmeetings.app.persistence.beans.calendar.MeetingMember;
import org.openmeetings.app.persistence.beans.domain.Organisation;
import org.openmeetings.app.persistence.beans.domain.Organisation_Users;
import org.openmeetings.app.persistence.beans.files.FileExplorerItem;
import org.openmeetings.app.persistence.beans.flvrecord.FlvRecording;
import org.openmeetings.app.persistence.beans.flvrecord.FlvRecordingMetaData;
import org.openmeetings.app.persistence.beans.poll.RoomPoll;
import org.openmeetings.app.persistence.beans.poll.RoomPollAnswers;
import org.openmeetings.app.persistence.beans.rooms.RoomModerators;
import org.openmeetings.app.persistence.beans.rooms.Rooms;
import org.openmeetings.app.persistence.beans.rooms.Rooms_Organisation;
import org.openmeetings.app.persistence.beans.sip.asterisk.AsteriskSipUsers;
import org.openmeetings.app.persistence.beans.sip.asterisk.Extensions;
import org.openmeetings.app.persistence.beans.sip.asterisk.MeetMe;
import org.openmeetings.app.persistence.beans.user.PrivateMessageFolder;
import org.openmeetings.app.persistence.beans.user.PrivateMessages;
import org.openmeetings.app.persistence.beans.user.UserContacts;
import org.openmeetings.app.persistence.beans.user.UserSipData;
import org.openmeetings.app.persistence.beans.user.Users;
import org.openmeetings.app.remote.red5.ScopeApplicationAdapter;
import org.openmeetings.app.sip.api.impl.asterisk.dao.AsteriskDAOImpl;
import org.openmeetings.utils.math.CalendarPatterns;
import org.red5.logging.Red5LoggerFactory;
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;
@Controller
public class BackupImportController extends AbstractUploadController {
private static final Logger log = Red5LoggerFactory.getLogger(
BackupImportController.class, OpenmeetingsVariables.webAppRootKey);
@Autowired
private AppointmentDaoImpl appointmentDao;
@Autowired
private Statemanagement statemanagement;
@Autowired
private OmTimeZoneDaoImpl omTimeZoneDaoImpl;
@Autowired
private Organisationmanagement organisationmanagement;
@Autowired
private Roommanagement roommanagement;
@Autowired
private AppointmentCategoryDaoImpl appointmentCategoryDaoImpl;
@Autowired
private AppointmentReminderTypDaoImpl appointmentReminderTypDaoImpl;
@Autowired
private UsersDaoImpl usersDao;
@Autowired
private FlvRecordingDaoImpl flvRecordingDao;
@Autowired
private FlvRecordingMetaDataDaoImpl flvRecordingMetaDataDao;
@Autowired
private PrivateMessageFolderDaoImpl privateMessageFolderDao;
@Autowired
private PrivateMessagesDaoImpl privateMessagesDao;
@Autowired
private MeetingMemberDaoImpl meetingMemberDao;
@Autowired
private LdapConfigDaoImpl ldapConfigDao;
@Autowired
private RoomModeratorsDaoImpl roomModeratorsDao;
@Autowired
private FileExplorerItemDaoImpl fileExplorerItemDao;
@Autowired
private UserContactsDaoImpl userContactsDao;
@Autowired
private ScopeApplicationAdapter scopeApplicationAdapter;
@Autowired
private PollManagement pollManagement;
@Autowired
private Configurationmanagement cfgManagement;
@Autowired
private AsteriskDAOImpl asteriskDAOImpl;
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 final HashMap<Long, Long> fileExplorerItemsMap = new HashMap<Long, Long>();
private enum Maps {
USERS, ORGANISATIONS, APPOINTMENTS, ROOMS, MESSAGEFOLDERS, USERCONTACTS, FILEEXPLORERITEMS
};
public void performImport(InputStream is, String current_dir) throws Exception {
File working_dir = new File(current_dir, OpenmeetingsVariables.UPLOAD_DIR
+ File.separatorChar + "import");
if (!working_dir.exists()) {
working_dir.mkdir();
}
File f = new File(working_dir, "import_" + CalendarPatterns.getTimeForStreamId(new Date()));
int recursiveNumber = 0;
do {
if (f.exists()) {
f = new File(f.getAbsolutePath() + (recursiveNumber++));
}
} while (f.exists());
f.mkdir();
log.debug("##### WRITE FILE TO: " + f);
ZipInputStream zipinputstream = new ZipInputStream(is);
byte[] buf = new byte[1024];
ZipEntry zipentry = zipinputstream.getNextEntry();
while (zipentry != null) {
// for each entry to be extracted
int n;
FileOutputStream fileoutputstream;
File fentryName = new File(f, zipentry.getName());
if (zipentry.isDirectory()) {
if (!fentryName.mkdir()) {
break;
}
zipentry = zipinputstream.getNextEntry();
continue;
}
File fparent = new File(fentryName.getParent());
if (!fparent.exists()) {
File fparentparent = new File(fparent.getParent());
if (!fparentparent.exists()) {
File fparentparentparent = new File(
fparentparent.getParent());
if (!fparentparentparent.exists()) {
fparentparentparent.mkdir();
fparentparent.mkdir();
fparent.mkdir();
} else {
fparentparent.mkdir();
fparent.mkdir();
}
} else {
fparent.mkdir();
}
}
fileoutputstream = new FileOutputStream(fentryName);
while ((n = zipinputstream.read(buf, 0, 1024)) > -1) {
fileoutputstream.write(buf, 0, n);
}
fileoutputstream.close();
zipinputstream.closeEntry();
zipentry = zipinputstream.getNextEntry();
}// while
zipinputstream.close();
/*
* ##################### Import Organizations
*/
File orgFile = new File(f, "organizations.xml");
if (!orgFile.exists()) {
throw new Exception("organizations.xml missing");
}
this.importOrganizsations(orgFile);
log.info("Organizations import complete, starting user import");
/*
* ##################### Import Users
*/
File userFile = new File(f, "users.xml");
if (!userFile.exists()) {
throw new Exception("users.xml missing");
}
this.importUsers(userFile);
log.info("Users import complete, starting room import");
/*
* ##################### Import Rooms
*/
File roomFile = new File(f, "rooms.xml");
if (!roomFile.exists()) {
throw new Exception("rooms.xml missing");
}
this.importRooms(roomFile);
log.info("Room import complete, starting room organizations import");
/*
* ##################### Import Room Organisations
*/
File orgRoomListFile = new File(f, "rooms_organisation.xml");
if (!orgRoomListFile.exists()) {
throw new Exception("rooms_organisation.xml missing");
}
this.importOrgRooms(orgRoomListFile);
log.info("Room organizations import complete, starting appointement import");
/*
* ##################### Import Appointements
*/
File appointementListFile = new File(f, "appointements.xml");
if (!appointementListFile.exists()) {
throw new Exception("appointements.xml missing");
}
this.importAppointements(appointementListFile);
log.info("Appointement import complete, starting meeting members import");
/*
* ##################### Import MeetingMembers
*
* Reminder Invitations will be NOT send!
*/
File meetingmembersListFile = new File(f, "meetingmembers.xml");
if (!meetingmembersListFile.exists()) {
throw new Exception("meetingmembersListFile missing");
}
this.importMeetingmembers(meetingmembersListFile);
log.info("Meeting members import complete, starting ldap config import");
/*
* ##################### Import LDAP Configs
*/
File ldapConfigListFile = new File(f, "ldapconfigs.xml");
if (!ldapConfigListFile.exists()) {
log.debug("meetingmembersListFile missing");
// throw new Exception
// ("meetingmembersListFile missing");
} else {
this.importLdapConfig(ldapConfigListFile);
}
log.info("Ldap config import complete, starting recordings import");
/*
* ##################### Import Recordings
*/
File flvRecordingsListFile = new File(f, "flvRecordings.xml");
if (!flvRecordingsListFile.exists()) {
log.debug("flvRecordingsListFile missing");
// throw new Exception
// ("meetingmembersListFile missing");
} else {
this.importFlvRecordings(flvRecordingsListFile);
}
log.info("FLVrecording import complete, starting private message folder import");
/*
* ##################### Import Private Message Folders
*/
File privateMessageFoldersFile = new File(f, "privateMessageFolder.xml");
if (!privateMessageFoldersFile.exists()) {
log.debug("privateMessageFoldersFile missing");
// throw new Exception
// ("meetingmembersListFile missing");
} else {
this.importPrivateMessageFolders(privateMessageFoldersFile);
}
log.info("Private message folder import complete, starting private message import");
/*
* ##################### Import Private Messages
*/
File privateMessagesFile = new File(f, "privateMessages.xml");
if (!privateMessagesFile.exists()) {
log.debug("privateMessagesFile missing");
// throw new Exception
// ("meetingmembersListFile missing");
} else {
this.importPrivateMessages(privateMessagesFile);
}
log.info("Private message import complete, starting usercontact import");
/*
* ##################### Import User Contacts
*/
File userContactsFile = new File(f, "userContacts.xml");
if (!userContactsFile.exists()) {
log.debug("userContactsFile missing");
// throw new Exception
// ("meetingmembersListFile missing");
} else {
this.importUserContacts(userContactsFile);
}
log.info("Usercontact import complete, starting file explorer item import");
/*
* ##################### Import File-Explorer Items
*/
File fileExplorerListFile = new File(f, "fileExplorerItems.xml");
if (!fileExplorerListFile.exists()) {
log.debug("fileExplorerListFile missing");
// throw new Exception
// ("meetingmembersListFile missing");
} else {
this.importFileExplorerItems(fileExplorerListFile);
}
log.info("File explorer item import complete, starting file poll import");
/*
* ##################### Import Room Polls
*/
File roomPollListFile = new File(f, "roompolls.xml");
if (!roomPollListFile.exists()) {
log.debug("roomPollListFile missing");
} else {
this.importRoomPolls(roomPollListFile);
}
log.info("Poll import complete, starting configs import");
/*
* ##################### Import Configs
*/
File configsFile = new File(f, "configs.xml");
if (!configsFile.exists()) {
log.debug("configsFile missing");
} else {
importConfigs(configsFile);
}
log.info("Configs import complete, starting asteriskSipUsersFile import");
/*
* ##################### Import AsteriskSipUsers
*/
File asteriskSipUsersFile = new File(f, "asterisksipusers.xml");
if (!asteriskSipUsersFile.exists()) {
log.debug("asteriskSipUsersFile missing");
} else {
importAsteriskSipUsers(asteriskSipUsersFile);
}
log.info("AsteriskSipUsers import complete, starting extensions import");
/*
* ##################### Import Extensions
*/
File extensionsFile = new File(f, "extensions.xml");
if (!extensionsFile.exists()) {
log.debug("extensionsFile missing");
} else {
importExtensions(extensionsFile);
}
log.info("Extensions import complete, starting members import");
/*
* ##################### Import Extensions
*/
File membersFile = new File(f, "members.xml");
if (!membersFile.exists()) {
log.debug("membersFile missing");
} else {
importMembers(membersFile);
}
log.info("Members import complete, starting copy of files and folders");
/*
* ##################### Import real files and folders
*/
importFolders(current_dir, f);
log.info("File explorer item import complete, clearing temp files");
deleteDirectory(f);
}
@RequestMapping(value = "/backup.upload", method = RequestMethod.POST)
public void service(HttpServletRequest request,
HttpServletResponse httpServletResponse)
throws ServletException, IOException {
UploadInfo info = validate(request, true);
try {
String current_dir = context.getRealPath("/");
MultipartFile multipartFile = info.file;
InputStream is = multipartFile.getInputStream();
performImport(is, current_dir);
LinkedHashMap<String, Object> hs = new LinkedHashMap<String, Object>();
hs.put("user", usersDao.getUser(info.userId));
hs.put("message", "library");
hs.put("action", "import");
hs.put("error", "");
hs.put("fileName", info.filename);
scopeApplicationAdapter.sendMessageWithClientByPublicSID(
hs, info.publicSID);
} catch (Exception e) {
log.error("[ImportExport]", e);
e.printStackTrace();
throw new ServletException(e);
}
return;
}
private void importRoomPolls(File roomPollListFile) {
try {
List<RoomPoll> roomPolls = this.getRoomPolls(roomPollListFile);
for (RoomPoll roomPoll : roomPolls) {
pollManagement.savePollBackup(roomPoll);
}
} catch (Exception err) {
log.error("[getRoomPolls]", err);
}
}
private void importMembers(File membersFile) throws Exception {
SAXReader reader = new SAXReader();
Document document = reader.read(membersFile);
Element root = document.getRootElement();
Element extensions = root.element("members");
for (@SuppressWarnings("unchecked")
Iterator<Element> iter = extensions.elementIterator("member"); iter.hasNext();) {
Element extensionElem = iter.next();
String confno = extensionElem.elementText("confno");
try {
MeetMe meetMe = new MeetMe();
meetMe.setConfno(unformatString(extensionElem
.element("confno").getText()));
meetMe.setPin(unformatString(extensionElem
.element("pin").getText()));
meetMe.setAdminpin(unformatString(extensionElem
.element("adminpin").getText()));
meetMe.setMembers(importIntegerType(unformatString(extensionElem
.element("members").getText())));
asteriskDAOImpl.saveMeetMe(meetMe);
} catch (Exception e) {
log.debug("failed to add/update members confno: " + confno, e);
}
}
}
private void importExtensions(File extensionsFile) throws Exception {
SAXReader reader = new SAXReader();
Document document = reader.read(extensionsFile);
Element root = document.getRootElement();
Element extensions = root.element("extensions");
for (@SuppressWarnings("unchecked")
Iterator<Element> iter = extensions.elementIterator("extension"); iter.hasNext();) {
Element extensionElem = iter.next();
String id = extensionElem.elementText("id");
try {
Extensions extension = new Extensions();
//the primary key must be null for new objects if its an auto-increment
extension.setExten(unformatString(extensionElem
.element("exten").getText()));
extension.setPriority(importIntegerType(unformatString(extensionElem
.element("priority").getText())));
extension.setApp(unformatString(extensionElem
.element("app").getText()));
extension.setAppdata(unformatString(extensionElem
.element("appdata").getText()));
asteriskDAOImpl.saveExtensions(extension);
} catch (Exception e) {
log.debug("failed to add/update extensions id: " + id, e);
}
}
}
private void importAsteriskSipUsers(File asteriskSipUsersFile) throws Exception {
SAXReader reader = new SAXReader();
Document document = reader.read(asteriskSipUsersFile);
Element root = document.getRootElement();
Element asterisksipusers = root.element("asterisksipusers");
for (@SuppressWarnings("unchecked")
Iterator<Element> iter = asterisksipusers.elementIterator("asterisksipuser"); iter.hasNext();) {
Element asterisksipuserElem = iter.next();
String id = asterisksipuserElem.elementText("id");
try {
AsteriskSipUsers asterisksipuser = new AsteriskSipUsers();
//the primary key must be null for new objects if its an auto-increment
asterisksipuser.setAccountcode(unformatString(asterisksipuserElem
.element("accountcode").getText()));
asterisksipuser.setDisallow(unformatString(asterisksipuserElem
.element("disallow").getText()));
asterisksipuser.setAllow(unformatString(asterisksipuserElem
.element("allow").getText()));
asterisksipuser.setAllowoverlap(unformatString(asterisksipuserElem
.element("allowoverlap").getText()));
asterisksipuser.setAllowsubscribe(unformatString(asterisksipuserElem
.element("allowsubscribe").getText()));
asterisksipuser.setAllowtransfer(unformatString(asterisksipuserElem
.element("allowtransfer").getText()));
asterisksipuser.setAmaflags(unformatString(asterisksipuserElem
.element("amaflags").getText()));
asterisksipuser.setAutoframing(unformatString(asterisksipuserElem
.element("autoframing").getText()));
asterisksipuser.setAuth(unformatString(asterisksipuserElem
.element("auth").getText()));
asterisksipuser.setBuggymwi(unformatString(asterisksipuserElem
.element("buggymwi").getText()));
asterisksipuser.setCallgroup(unformatString(asterisksipuserElem
.element("callgroup").getText()));
asterisksipuser.setCallerid(unformatString(asterisksipuserElem
.element("callerid").getText()));
asterisksipuser.setCid_number(unformatString(asterisksipuserElem
.element("cid_number").getText()));
asterisksipuser.setFullname(unformatString(asterisksipuserElem
.element("fullname").getText()));
asterisksipuser.setCallingpres(unformatString(asterisksipuserElem
.element("callingpres").getText()));
asterisksipuser.setCanreinvite(unformatString(asterisksipuserElem
.element("canreinvite").getText()));
asterisksipuser.setContext(unformatString(asterisksipuserElem
.element("context").getText()));
asterisksipuser.setDefaultip(unformatString(asterisksipuserElem
.element("defaultip").getText()));
asterisksipuser.setDtmfmode(unformatString(asterisksipuserElem
.element("dtmfmode").getText()));
asterisksipuser.setFromuser(unformatString(asterisksipuserElem
.element("fromuser").getText()));
asterisksipuser.setFromdomain(unformatString(asterisksipuserElem
.element("fromdomain").getText()));
asterisksipuser.setFullcontact(unformatString(asterisksipuserElem
.element("fullcontact").getText()));
asterisksipuser.setG726nonstandard(unformatString(asterisksipuserElem
.element("g726nonstandard").getText()));
asterisksipuser.setHost(unformatString(asterisksipuserElem
.element("host").getText()));
asterisksipuser.setInsecure(unformatString(asterisksipuserElem
.element("insecure").getText()));
asterisksipuser.setIpaddr(unformatString(asterisksipuserElem
.element("ipaddr").getText()));
asterisksipuser.setLanguage(unformatString(asterisksipuserElem
.element("language").getText()));
asterisksipuser.setLastms(unformatString(asterisksipuserElem
.element("lastms").getText()));
asterisksipuser.setMailbox(unformatString(asterisksipuserElem
.element("mailbox").getText()));
asterisksipuser.setMaxcallbitrate(importIntegerType(unformatString(asterisksipuserElem
.element("maxcallbitrate").getText())));
asterisksipuser.setMohsuggest(unformatString(asterisksipuserElem
.element("mohsuggest").getText()));
asterisksipuser.setMd5secret(unformatString(asterisksipuserElem
.element("md5secret").getText()));
asterisksipuser.setMusiconhold(unformatString(asterisksipuserElem
.element("musiconhold").getText()));
asterisksipuser.setName(unformatString(asterisksipuserElem
.element("name").getText()));
asterisksipuser.setNat(unformatString(asterisksipuserElem
.element("nat").getText()));
asterisksipuser.setOutboundproxy(unformatString(asterisksipuserElem
.element("outboundproxy").getText()));
asterisksipuser.setDeny(unformatString(asterisksipuserElem
.element("deny").getText()));
asterisksipuser.setPermit(unformatString(asterisksipuserElem
.element("permit").getText()));
asterisksipuser.setPickupgroup(unformatString(asterisksipuserElem
.element("pickupgroup").getText()));
asterisksipuser.setPort(unformatString(asterisksipuserElem
.element("port").getText()));
asterisksipuser.setProgressinband(unformatString(asterisksipuserElem
.element("progressinband").getText()));
asterisksipuser.setPromiscredir(unformatString(asterisksipuserElem
.element("promiscredir").getText()));
asterisksipuser.setQualify(unformatString(asterisksipuserElem
.element("qualify").getText()));
asterisksipuser.setRegexten(unformatString(asterisksipuserElem
.element("regexten").getText()));
asterisksipuser.setRegseconds(importIntegerType(unformatString(asterisksipuserElem
.element("regseconds").getText())));
asterisksipuser.setRfc2833compensate(unformatString(asterisksipuserElem
.element("rfc2833compensate").getText()));
asterisksipuser.setRtptimeout(unformatString(asterisksipuserElem
.element("rtptimeout").getText()));
asterisksipuser.setRtpholdtimeout(unformatString(asterisksipuserElem
.element("rtpholdtimeout").getText()));
asterisksipuser.setSecret(unformatString(asterisksipuserElem
.element("secret").getText()));
asterisksipuser.setSendrpid(unformatString(asterisksipuserElem
.element("sendrpid").getText()));
asterisksipuser.setSetvar(unformatString(asterisksipuserElem
.element("setvar").getText()));
asterisksipuser.setSubscribecontext(unformatString(asterisksipuserElem
.element("subscribecontext").getText()));
asterisksipuser.setSubscribemwi(unformatString(asterisksipuserElem
.element("subscribemwi").getText()));
asterisksipuser.setT38pt_udptl(unformatString(asterisksipuserElem
.element("t38pt_udptl").getText()));
asterisksipuser.setTrustrpid(unformatString(asterisksipuserElem
.element("trustrpid").getText()));
asterisksipuser.setType(unformatString(asterisksipuserElem
.element("type").getText()));
asterisksipuser.setUseclientcode(unformatString(asterisksipuserElem
.element("useclientcode").getText()));
asterisksipuser.setUsername(unformatString(asterisksipuserElem
.element("username").getText()));
asterisksipuser.setUsereqphone(unformatString(asterisksipuserElem
.element("usereqphone").getText()));
asterisksipuser.setVideosupport(unformatString(asterisksipuserElem
.element("videosupport").getText()));
asterisksipuser.setVmexten(unformatString(asterisksipuserElem
.element("vmexten").getText()));
asteriskDAOImpl.saveAsteriskSipUsers(asterisksipuser);
} catch (Exception e) {
log.debug("failed to add/update asterisksipuser id: "+id, e);
}
}
}
private void importConfigs(File configsFile) throws Exception {
SAXReader reader = new SAXReader();
Document document = reader.read(configsFile);
Element root = document.getRootElement();
Element configs = root.element("configs");
for (@SuppressWarnings("unchecked")
Iterator<Element> iter = configs.elementIterator("config"); iter.hasNext();) {
Element cfgElem = iter.next();
String key = cfgElem.elementText("key");
try {
Configuration cfg = cfgManagement.getConfKey(3L, key);
if (cfg == null) {
cfg = new Configuration();
cfg.setConf_key(key);
}
cfg.setConf_value(cfgElem.elementText("value"));
cfg.setUpdatetime(new Date());
cfg.setDeleted(cfgElem.elementText("deleted"));
cfg.setComment(cfgElem.elementText("comment"));
cfgManagement.updateConfig(cfg);
} catch (Exception e) {
log.debug("failed to add/update configuration: " + key, e);
}
}
}
@SuppressWarnings("unchecked")
private List<RoomPoll> getRoomPolls(File roomPollListFile) throws Exception {
List<RoomPoll> roomPollList = new LinkedList<RoomPoll>();
SAXReader reader = new SAXReader();
Document document = reader.read(roomPollListFile);
Element root = document.getRootElement();
for (Iterator<Element> i = root.elementIterator(); i.hasNext();) {
Element itemObject = i.next();
if (itemObject.getName().equals("roompolls")) {
for (Iterator<Element> innerIter = itemObject
.elementIterator("roompoll"); innerIter.hasNext();) {
Element roompollObject = innerIter.next();
String pollname = unformatString(roompollObject.element(
"pollname").getText());
String pollquestion = unformatString(roompollObject
.element("pollquestion").getText());
Boolean archived = importBooleanType(unformatString(roompollObject
.element("archived").getText()));
Date created = CalendarPatterns
.parseImportDate(unformatString(roompollObject
.element("created").getText()));
Long createdbyuserid = importLongType(unformatString(roompollObject
.element("createdbyuserid").getText()));
Long polltypeid = importLongType(unformatString(roompollObject
.element("polltypeid").getText()));
Long roomid = importLongType(unformatString(roompollObject
.element("roomid").getText()));
RoomPoll roomPoll = new RoomPoll();
roomPoll.setPollName(pollname);
roomPoll.setPollQuestion(pollquestion);
if (archived != null) {
roomPoll.setArchived(archived.booleanValue());
} else {
roomPoll.setArchived(true);
}
roomPoll.setCreated(created);
roomPoll.setCreatedBy(usersDao.getUser(getNewId(createdbyuserid, Maps.USERS)));
roomPoll.setPollType(pollManagement.getPollType(polltypeid));
roomPoll.setRoom(roommanagement.getRoomById(getNewId(roomid, Maps.ROOMS)));
roomPoll.setRoomPollAnswerList(new LinkedList<RoomPollAnswers>());
Element roompollanswers = roompollObject
.element("roompollanswers");
for (Iterator<Element> innerIterAnswers = roompollanswers
.elementIterator("roompollanswer"); innerIterAnswers
.hasNext();) {
Element innerIterAnswerObj = innerIterAnswers.next();
Integer pointlist = importIntegerType(unformatString(innerIterAnswerObj
.element("pointlist").getText()));
Boolean answer = importBooleanType(unformatString(innerIterAnswerObj
.element("answer").getText()));
Date votedate = CalendarPatterns
.parseImportDate(unformatString(innerIterAnswerObj
.element("votedate").getText()));
Long voteduserid = importLongType(unformatString(innerIterAnswerObj
.element("voteduserid").getText()));
RoomPollAnswers roomPollAnswers = new RoomPollAnswers();
roomPollAnswers.setPointList(pointlist);
roomPollAnswers.setAnswer(answer);
roomPollAnswers.setVoteDate(votedate);
roomPollAnswers.setVotedUser(usersDao.getUser(getNewId(voteduserid, Maps.USERS)));
roomPoll.getRoomPollAnswerList().add(roomPollAnswers);
}
roomPollList.add(roomPoll);
}
}
}
return roomPollList;
}
public void copyDirectory(File sourceLocation, File targetLocation)
throws IOException {
// log.debug("^^^^ "+sourceLocation.getName()+" || "+targetLocation.getName());
if (sourceLocation.isDirectory()) {
if (!targetLocation.exists()) {
targetLocation.mkdir();
}
String[] children = sourceLocation.list();
for (int i = 0; i < children.length; i++) {
copyDirectory(new File(sourceLocation, children[i]), new File(
targetLocation, children[i]));
}
} else {
InputStream in = new FileInputStream(sourceLocation);
OutputStream out = new FileOutputStream(targetLocation);
// Copy the bits from instream to outstream
byte[] buf = new byte[1024];
int len;
while ((len = in.read(buf)) > 0) {
out.write(buf, 0, len);
}
in.close();
out.close();
}
}
public void copyFile(File sourceLocation, File targetLocation)
throws IOException {
InputStream in = new FileInputStream(sourceLocation);
OutputStream out = new FileOutputStream(targetLocation);
// Copy the bits from instream to outstream
byte[] buf = new byte[1024];
int len;
while ((len = in.read(buf)) > 0) {
out.write(buf, 0, len);
}
in.close();
out.close();
}
public boolean deleteDirectory(File path) throws IOException {
if (path.exists()) {
File[] files = path.listFiles();
for (int i = 0; i < files.length; i++) {
if (files[i].isDirectory()) {
deleteDirectory(files[i]);
} else {
files[i].delete();
}
}
}
return (path.delete());
}
private void importUsers(File userFile) throws Exception {
this.getUsersByXML(userFile);
}
@SuppressWarnings("unchecked")
private void getUsersByXML(File userFile) {
try {
SAXReader reader = new SAXReader();
Document document = reader.read(userFile);
Element root = document.getRootElement();
for (Iterator<Element> i = root.elementIterator(); i.hasNext();) {
Element itemObject = i.next();
if (itemObject.getName().equals("users")) {
for (Iterator<Element> innerIter = itemObject
.elementIterator("user"); innerIter.hasNext();) {
Element itemUsers = innerIter.next();
Users us = new Users();
Long userId = Long.valueOf(unformatString(itemUsers
.element("user_id").getText()));
us.setAge(CalendarPatterns
.parseImportDate(unformatString(itemUsers
.element("age").getText())));
us.setAvailible(importIntegerType(unformatString(itemUsers
.element("availible").getText())));
us.setDeleted(unformatString(itemUsers.element(
"deleted").getText()));
us.setFirstname(unformatString(itemUsers.element(
"firstname").getText()));
us.setLastname(unformatString(itemUsers.element(
"lastname").getText()));
us.setLogin(unformatString(itemUsers.element("login")
.getText()));
us.setPassword(unformatString(itemUsers.element("pass")
.getText()));
us.setDeleted(itemUsers.element("deleted").getText());
if (itemUsers.element("activatehash") != null) {
us.setActivatehash(unformatString(itemUsers
.element("activatehash").getText()));
} else {
us.setActivatehash("");
}
if (itemUsers.element("externalUserType") != null) {
us.setExternalUserType(unformatString(itemUsers
.element("externalUserType").getText()));
} else {
us.setExternalUserType("");
}
if (itemUsers.element("externalUserId") != null) {
us.setExternalUserId(unformatString(itemUsers
.element("externalUserId").getText()));
} else {
us.setExternalUserId(null);
}
if (itemUsers.element("resethash") != null) {
us.setResethash(unformatString(itemUsers.element(
"resethash").getText()));
} else {
us.setResethash(null);
}
if (itemUsers.element("userOffers") != null) {
us.setUserOffers(unformatString(itemUsers.element(
"userOffers").getText()));
} else {
us.setUserOffers("");
}
if (itemUsers.element("userSearchs") != null) {
us.setUserSearchs(unformatString(itemUsers.element(
"userSearchs").getText()));
} else {
us.setUserSearchs("");
}
if (itemUsers.element("forceTimeZoneCheck") != null) {
us.setForceTimeZoneCheck(importBooleanType(unformatString(itemUsers
.element("forceTimeZoneCheck").getText())));
} else {
us.setForceTimeZoneCheck(null);
}
if (itemUsers.element("lasttrans") != null) {
us.setLasttrans(importLongType(unformatString(itemUsers
.element("lasttrans").getText())));
} else {
us.setLasttrans(null);
}
if (itemUsers.element("showContactData") != null) {
us.setShowContactData(importBooleanType(unformatString(itemUsers
.element("showContactData").getText())));
} else {
us.setShowContactData(null);
}
if (itemUsers.element("showContactDataToContacts") != null) {
us.setShowContactDataToContacts(importBooleanType(unformatString(itemUsers
.element("showContactDataToContacts")
.getText())));
} else {
us.setShowContactDataToContacts(null);
}
us.setPictureuri(unformatString(itemUsers.element(
"pictureuri").getText()));
if (unformatString(
itemUsers.element("language_id").getText())
.length() > 0)
us.setLanguage_id(Long
.valueOf(unformatString(itemUsers.element(
"language_id").getText())));
us.setStatus(importIntegerType(unformatString(itemUsers
.element("status").getText())));
us.setRegdate(CalendarPatterns
.parseImportDate(unformatString(itemUsers
.element("regdate").getText())));
us.setTitle_id(importIntegerType(unformatString(itemUsers
.element("title_id").getText())));
us.setLevel_id(importLongType(unformatString(itemUsers
.element("level_id").getText())));
// UserSIP Data
if (itemUsers.element("sip_username") != null
&& itemUsers.element("sip_userpass") != null
&& itemUsers.element("sip_authid") != null) {
UserSipData userSipData = new UserSipData();
userSipData.setUsername(unformatString(itemUsers
.element("sip_username").getText()));
userSipData.setUsername(unformatString(itemUsers
.element("sip_userpass").getText()));
userSipData.setUsername(unformatString(itemUsers
.element("sip_authid").getText()));
us.setUserSipData(userSipData);
}
String additionalname = unformatString(itemUsers
.element("additionalname").getText());
String comment = unformatString(itemUsers.element(
"comment").getText());
// A User can not have a deleted Adress, you cannot
// delete the
// Adress of an User
// String deleted = u.getAdresses().getDeleted()
// Phone Number not done yet
String fax = unformatString(itemUsers.element("fax")
.getText());
Long state_id = importLongType(unformatString(itemUsers
.element("state_id").getText()));
String street = unformatString(itemUsers.element(
"street").getText());
String town = unformatString(itemUsers.element("town")
.getText());
String zip = unformatString(itemUsers.element("zip")
.getText());
if (itemUsers.element("omTimeZone") != null) {
OmTimeZone omTimeZone = omTimeZoneDaoImpl
.getOmTimeZone(unformatString(itemUsers
.element("omTimeZone").getText()));
us.setOmTimeZone(omTimeZone);
us.setForceTimeZoneCheck(false);
} else {
String jNameTimeZone = cfgManagement.getConfValue("default.timezone", String.class, "Europe/Berlin");
OmTimeZone omTimeZone = omTimeZoneDaoImpl
.getOmTimeZone(jNameTimeZone);
us.setOmTimeZone(omTimeZone);
us.setForceTimeZoneCheck(true);
}
String phone = "";
if (itemUsers.element("phone") != null) {
phone = unformatString(itemUsers.element("phone")
.getText());
}
String email = "";
if (itemUsers.element("mail") != null) {
email = unformatString(itemUsers.element("mail")
.getText());
}
States st = statemanagement.getStateById(state_id);
if (st == null) {
st = statemanagement.getStateById(1L);
}
us.setAdresses(street, zip, town,
st, additionalname, comment, fax,
phone, email);
HashSet<Organisation_Users> orgUsers = new HashSet<Organisation_Users>();
for (Iterator<Element> organisationsIterator = itemUsers
.elementIterator("organisations"); organisationsIterator
.hasNext();) {
Element organisations = organisationsIterator
.next();
for (Iterator<Element> organisationIterator = organisations
.elementIterator("user_organisation"); organisationIterator
.hasNext();) {
Element organisationObject = organisationIterator
.next();
Long organisation_id = getNewId(
importLongType(unformatString(organisationObject
.element("organisation_id")
.getText())),
Maps.ORGANISATIONS);
Boolean isModerator = importBooleanType(unformatString(organisationObject
.element("isModerator").getText()));
String deleted = unformatString(organisationObject
.element("deleted").getText());
Organisation_Users orgUser = new Organisation_Users();
orgUser.setOrganisation(organisationmanagement
.getOrganisationByIdBackup(organisation_id));
orgUser.setIsModerator(isModerator);
orgUser.setStarttime(new Date());
orgUser.setDeleted(deleted);
orgUsers.add(orgUser);
}
}
log.debug("Import User ID " + userId);
us.setStarttime(new Date());
Long actualNewUserId = userManagement.addUserBackup(us);
usersMap.put(userId, actualNewUserId);
for (Iterator<Organisation_Users> orgUserIterator = orgUsers
.iterator(); orgUserIterator.hasNext();) {
Organisation_Users organisationUsers = orgUserIterator
.next();
organisationmanagement
.addOrganisationUserObj(actualNewUserId, organisationUsers);
}
}
}
}
} catch (Exception err) {
log.error("[getUsersByXML]", err);
}
}
private void importFlvRecordings(File flvRecordingsListFile)
throws Exception {
List<FlvRecording> flvRecordings = this
.getFlvRecordings(flvRecordingsListFile);
for (FlvRecording flvRecording : flvRecordings) {
Long flvRecordingId = flvRecordingDao
.addFlvRecordingObj(flvRecording);
for (FlvRecordingMetaData flvRecordingMetaData : flvRecording
.getFlvRecordingMetaData()) {
FlvRecording flvRecordingSaved = flvRecordingDao
.getFlvRecordingById(flvRecordingId);
flvRecordingMetaData.setFlvRecording(flvRecordingSaved);
flvRecordingMetaDataDao
.addFlvRecordingMetaDataObj(flvRecordingMetaData);
}
}
}
@SuppressWarnings("unchecked")
private List<FlvRecording> getFlvRecordings(File flvRecordingsListFile) {
try {
List<FlvRecording> flvList = new LinkedList<FlvRecording>();
SAXReader reader = new SAXReader();
Document document = reader.read(flvRecordingsListFile);
Element root = document.getRootElement();
for (Iterator<Element> i = root.elementIterator(); i.hasNext();) {
Element itemObject = i.next();
if (itemObject.getName().equals("flvrecordings")) {
for (Iterator<Element> innerIter = itemObject
.elementIterator("flvrecording"); innerIter
.hasNext();) {
Element flvObject = innerIter.next();
String alternateDownload = unformatString(flvObject
.element("alternateDownload").getText());
String comment = unformatString(flvObject.element(
"comment").getText());
String deleted = unformatString(flvObject.element(
"deleted").getText());
String fileHash = unformatString(flvObject.element(
"fileHash").getText());
String fileName = unformatString(flvObject.element(
"fileName").getText());
String previewImage = unformatString(flvObject.element(
"previewImage").getText());
String recorderStreamId = unformatString(flvObject
.element("recorderStreamId").getText());
Long fileSize = importLongType(unformatString(flvObject
.element("fileSize").getText()));
Integer flvHeight = importIntegerType(unformatString(flvObject
.element("flvHeight").getText()));
Integer flvWidth = importIntegerType(unformatString(flvObject
.element("flvWidth").getText()));
Integer height = importIntegerType(unformatString(flvObject
.element("height").getText()));
Integer width = importIntegerType(unformatString(flvObject
.element("width").getText()));
Long insertedBy = getNewId(
importLongType(unformatString(flvObject
.element("insertedBy").getText())),
Maps.USERS);
Long organization_id = getNewId(
importLongType(unformatString(flvObject
.element("organization_id").getText())),
Maps.ORGANISATIONS);
Long ownerId = getNewId(
importLongType(unformatString(flvObject
.element("ownerId").getText())),
Maps.USERS);
Long parentFileExplorerItemId = getNewId(
importLongType(unformatString(flvObject
.element("parentFileExplorerItemId")
.getText())), Maps.FILEEXPLORERITEMS);
Integer progressPostProcessing = importIntegerType(unformatString(flvObject
.element("progressPostProcessing").getText()));
Long room_id = getNewId(
importLongType(unformatString(flvObject
.element("room_id").getText())),
Maps.ROOMS);
Date inserted = CalendarPatterns
.parseImportDate(unformatString(flvObject
.element("inserted").getText()));
Boolean isFolder = importBooleanType(unformatString(flvObject
.element("isFolder").getText()));
Boolean isImage = importBooleanType(unformatString(flvObject
.element("isImage").getText()));
Boolean isInterview = importBooleanType(unformatString(flvObject
.element("isInterview").getText()));
Boolean isPresentation = importBooleanType(unformatString(flvObject
.element("isPresentation").getText()));
Boolean isRecording = importBooleanType(unformatString(flvObject
.element("isRecording").getText()));
Date recordEnd = CalendarPatterns
.parseImportDate(unformatString(flvObject
.element("recordEnd").getText()));
Date recordStart = CalendarPatterns
.parseImportDate(unformatString(flvObject
.element("recordStart").getText()));
FlvRecording flvRecording = new FlvRecording();
flvRecording.setAlternateDownload(alternateDownload);
flvRecording.setComment(comment);
flvRecording.setFileHash(fileHash);
flvRecording.setFileName(fileName);
flvRecording.setPreviewImage(previewImage);
flvRecording.setRecorderStreamId(recorderStreamId);
flvRecording.setFileSize(fileSize);
flvRecording.setFlvHeight(flvHeight);
flvRecording.setFlvWidth(flvWidth);
flvRecording.setHeight(height);
flvRecording.setWidth(width);
flvRecording.setInsertedBy(insertedBy);
flvRecording.setOrganization_id(organization_id);
flvRecording.setOwnerId(ownerId);
flvRecording
.setParentFileExplorerItemId(parentFileExplorerItemId);
flvRecording
.setProgressPostProcessing(progressPostProcessing);
flvRecording.setRoom_id(room_id);
flvRecording.setInserted(inserted);
flvRecording.setIsFolder(isFolder);
flvRecording.setIsImage(isImage);
flvRecording.setIsInterview(isInterview);
flvRecording.setIsPresentation(isPresentation);
flvRecording.setIsRecording(isRecording);
flvRecording.setRecordEnd(recordEnd);
flvRecording.setRecordStart(recordStart);
flvRecording.setDeleted(deleted);
flvRecording
.setFlvRecordingMetaData(new LinkedList<FlvRecordingMetaData>());
Element flvrecordingmetadatas = flvObject
.element("flvrecordingmetadatas");
for (Iterator<Element> innerIterMetas = flvrecordingmetadatas
.elementIterator("flvrecordingmetadata"); innerIterMetas
.hasNext();) {
Element flvrecordingmetadataObj = innerIterMetas
.next();
String freeTextUserName = unformatString(flvrecordingmetadataObj
.element("freeTextUserName").getText());
String fullWavAudioData = unformatString(flvrecordingmetadataObj
.element("fullWavAudioData").getText());
String streamName = unformatString(flvrecordingmetadataObj
.element("streamName").getText());
String wavAudioData = unformatString(flvrecordingmetadataObj
.element("wavAudioData").getText());
Integer initialGapSeconds = importIntegerType(unformatString(flvrecordingmetadataObj
.element("initialGapSeconds").getText()));
Long insertedBy1 = importLongType(unformatString(flvrecordingmetadataObj
.element("insertedBy").getText()));
Integer interiewPodId = importIntegerType(unformatString(flvrecordingmetadataObj
.element("interiewPodId").getText()));
Boolean audioIsValid = importBooleanType(unformatString(flvrecordingmetadataObj
.element("audioIsValid").getText()));
Date inserted1 = CalendarPatterns
.parseImportDate(unformatString(flvrecordingmetadataObj
.element("inserted").getText()));
Boolean isAudioOnly = importBooleanType(unformatString(flvrecordingmetadataObj
.element("isAudioOnly").getText()));
Boolean isScreenData = importBooleanType(unformatString(flvrecordingmetadataObj
.element("isScreenData").getText()));
Boolean isVideoOnly = importBooleanType(unformatString(flvrecordingmetadataObj
.element("isVideoOnly").getText()));
Date recordEnd1 = CalendarPatterns
.parseImportDate(unformatString(flvrecordingmetadataObj
.element("recordEnd").getText()));
Date recordStart1 = CalendarPatterns
.parseImportDate(unformatString(flvrecordingmetadataObj
.element("recordStart").getText()));
Date updated = CalendarPatterns
.parseImportDate(unformatString(flvrecordingmetadataObj
.element("updated").getText()));
FlvRecordingMetaData flvrecordingmetadata = new FlvRecordingMetaData();
flvrecordingmetadata
.setFreeTextUserName(freeTextUserName);
flvrecordingmetadata
.setFullWavAudioData(fullWavAudioData);
flvrecordingmetadata.setStreamName(streamName);
flvrecordingmetadata.setWavAudioData(wavAudioData);
flvrecordingmetadata
.setInitialGapSeconds(initialGapSeconds);
flvrecordingmetadata.setInsertedBy(insertedBy1);
flvrecordingmetadata
.setInteriewPodId(interiewPodId);
flvrecordingmetadata.setAudioIsValid(audioIsValid);
flvrecordingmetadata.setInserted(inserted1);
flvrecordingmetadata.setIsAudioOnly(isAudioOnly);
flvrecordingmetadata.setIsScreenData(isScreenData);
flvrecordingmetadata.setIsVideoOnly(isVideoOnly);
flvrecordingmetadata.setRecordEnd(recordEnd1);
flvrecordingmetadata.setRecordStart(recordStart1);
flvrecordingmetadata.setUpdated(updated);
flvrecordingmetadata.setDeleted("false");
flvRecording.getFlvRecordingMetaData().add(
flvrecordingmetadata);
}
flvList.add(flvRecording);
}
}
}
return flvList;
} catch (Exception err) {
log.error("[getFlvRecordings]", err);
}
return null;
}
private void importPrivateMessageFolders(File privateMessageFoldersFile)
throws Exception {
List<PrivateMessageFolder> privateMessageFolders = this
.getPrivateMessageFoldersByXML(privateMessageFoldersFile);
for (PrivateMessageFolder privateMessageFolder : privateMessageFolders) {
Long folderId = privateMessageFolder.getPrivateMessageFolderId();
PrivateMessageFolder storedFolder = privateMessageFolderDao
.getPrivateMessageFolderById(folderId);
if (storedFolder == null) {
privateMessageFolder.setPrivateMessageFolderId(0);
Long newFolderId = privateMessageFolderDao
.addPrivateMessageFolderObj(privateMessageFolder);
messageFoldersMap.put(folderId, newFolderId);
}
}
}
@SuppressWarnings("unchecked")
private List<PrivateMessageFolder> getPrivateMessageFoldersByXML(
File privateMessageFoldersFile) {
try {
List<PrivateMessageFolder> pmfList = new LinkedList<PrivateMessageFolder>();
SAXReader reader = new SAXReader();
Document document = reader.read(privateMessageFoldersFile);
Element root = document.getRootElement();
for (Iterator<Element> i = root.elementIterator(); i.hasNext();) {
Element itemObject = i.next();
if (itemObject.getName().equals("privatemessagefolders")) {
for (Iterator<Element> innerIter = itemObject
.elementIterator("privatemessagefolder"); innerIter
.hasNext();) {
Element pmfObject = innerIter.next();
String folderName = unformatString(pmfObject.element(
"folderName").getText());
Long userId = getNewId(
importLongType(unformatString(pmfObject
.element("userId").getText())),
Maps.USERS);
Long privateMessageFolderId = importLongType(unformatString(pmfObject
.element("privateMessageFolderId").getText()));
PrivateMessageFolder privateMessageFolder = new PrivateMessageFolder();
privateMessageFolder.setFolderName(folderName);
privateMessageFolder.setUserId(userId);
privateMessageFolder
.setPrivateMessageFolderId(privateMessageFolderId);
pmfList.add(privateMessageFolder);
}
}
}
return pmfList;
} catch (Exception err) {
log.error("[getPrivateMessageFoldersByXML]", err);
}
return null;
}
private void importPrivateMessages(File privateMessagesFile)
throws Exception {
List<PrivateMessages> pmList = this
.getPrivateMessagesByXML(privateMessagesFile);
for (PrivateMessages pm : pmList) {
privateMessagesDao.addPrivateMessageObj(pm);
}
}
@SuppressWarnings("unchecked")
private List<PrivateMessages> getPrivateMessagesByXML(
File privateMessagesFile) {
try {
List<PrivateMessages> pmList = new LinkedList<PrivateMessages>();
SAXReader reader = new SAXReader();
Document document = reader.read(privateMessagesFile);
Element root = document.getRootElement();
for (Iterator<Element> i = root.elementIterator(); i.hasNext();) {
Element itemObject = i.next();
if (itemObject.getName().equals("privatemessages")) {
for (Iterator<Element> innerIter = itemObject
.elementIterator("privatemessage"); innerIter
.hasNext();) {
Element pmObject = innerIter.next();
String message = unformatString(pmObject.element(
"message").getText());
String subject = unformatString(pmObject.element(
"subject").getText());
Long privateMessageFolderId = getNewId(
importLongType(unformatString(pmObject.element(
"privateMessageFolderId").getText())),
Maps.MESSAGEFOLDERS);
Long userContactId = getNewId(
importLongType(unformatString(pmObject.element(
"userContactId").getText())),
Maps.USERCONTACTS);
Long parentMessage = importLongType(unformatString(pmObject
.element("parentMessage").getText()));
Boolean bookedRoom = importBooleanType(unformatString(pmObject
.element("bookedRoom").getText()));
Users from = userManagement.getUserById(getNewId(
importLongType(unformatString(pmObject.element(
"from").getText())), Maps.USERS));
Users to = userManagement.getUserById(getNewId(
importLongType(unformatString(pmObject.element(
"to").getText())), Maps.USERS));
Date inserted = CalendarPatterns
.parseImportDate(unformatString(pmObject
.element("inserted").getText()));
Boolean isContactRequest = importBooleanType(unformatString(pmObject
.element("isContactRequest").getText()));
Boolean isRead = importBooleanType(unformatString(pmObject
.element("isRead").getText()));
Boolean isTrash = importBooleanType(unformatString(pmObject
.element("isTrash").getText()));
Users owner = userManagement.getUserById(getNewId(
importLongType(unformatString(pmObject.element(
"owner").getText())), Maps.USERS));
Rooms room = roommanagement.getRoomById(getNewId(
importLongType(unformatString(pmObject.element(
"room").getText())), Maps.ROOMS));
PrivateMessages pm = new PrivateMessages();
pm.setMessage(message);
pm.setSubject(subject);
pm.setPrivateMessageFolderId(privateMessageFolderId);
pm.setUserContactId(userContactId);
pm.setParentMessage(parentMessage);
pm.setBookedRoom(bookedRoom);
pm.setFrom(from);
pm.setTo(to);
pm.setInserted(inserted);
pm.setIsContactRequest(isContactRequest);
pm.setIsRead(isRead);
pm.setIsTrash(isTrash);
pm.setOwner(owner);
pm.setRoom(room);
pmList.add(pm);
}
}
}
return pmList;
} catch (Exception err) {
log.error("[getPrivateMessagesByXML]", err);
}
return null;
}
private void importUserContacts(File userContactsFile) throws Exception {
List<UserContacts> ucList = this.getUserContactsByXML(userContactsFile);
for (UserContacts uc : ucList) {
Long userContactId = uc.getUserContactId();
UserContacts storedUC = userContactsDao
.getUserContacts(userContactId);
if (storedUC == null) {
uc.setUserContactId(0);
Long newId = userContactsDao.addUserContactObj(uc);
this.userContactsMap.put(userContactId, newId);
}
}
}
@SuppressWarnings("unchecked")
private List<UserContacts> getUserContactsByXML(File userContactsFile) {
try {
List<UserContacts> ucList = new LinkedList<UserContacts>();
SAXReader reader = new SAXReader();
Document document = reader.read(userContactsFile);
Element root = document.getRootElement();
for (Iterator<Element> i = root.elementIterator(); i.hasNext();) {
Element itemObject = i.next();
if (itemObject.getName().equals("usercontacts")) {
for (Iterator<Element> innerIter = itemObject
.elementIterator("usercontact"); innerIter
.hasNext();) {
Element usercontact = innerIter.next();
String hash = unformatString(usercontact
.element("hash").getText());
Users contact = userManagement.getUserById(getNewId(
importLongType(unformatString(usercontact
.element("contact").getText())),
Maps.USERS));
Users owner = userManagement.getUserById(getNewId(
importLongType(unformatString(usercontact
.element("owner").getText())),
Maps.USERS));
Boolean pending = importBooleanType(unformatString(usercontact
.element("pending").getText()));
Boolean shareCalendar = importBooleanType(unformatString(usercontact
.element("shareCalendar").getText()));
Long userContactId = importLongType(unformatString(usercontact
.element("userContactId").getText()));
UserContacts userContacts = new UserContacts();
userContacts.setHash(hash);
userContacts.setContact(contact);
userContacts.setOwner(owner);
userContacts.setPending(pending);
userContacts.setShareCalendar(shareCalendar);
userContacts.setUserContactId(userContactId);
ucList.add(userContacts);
}
}
}
return ucList;
} catch (Exception err) {
log.error("[getUserContactsByXML]", err);
}
return null;
}
private void importOrganizsations(File orgFile) {
try {
SAXReader reader = new SAXReader();
Document document = reader.read(orgFile);
Element root = document.getRootElement();
for (@SuppressWarnings("unchecked")
Iterator<Element> i = root.elementIterator(); i.hasNext();) {
Element itemObject = i.next();
if (itemObject.getName().equals("organisations")) {
for (@SuppressWarnings("unchecked")
Iterator<Element> innerIter = itemObject
.elementIterator("organisation"); innerIter
.hasNext();) {
Element orgObject = innerIter.next();
Long organisation_id = importLongType(unformatString(orgObject
.element("organisation_id").getText()));
String name = unformatString(orgObject.element("name")
.getText());
String deleted = unformatString(orgObject.element(
"deleted").getText());
Organisation organisation = new Organisation();
organisation.setName(name);
organisation.setDeleted(deleted);
Long newOrgID = organisationmanagement
.addOrganisationObj(organisation);
organisationsMap.put(organisation_id, newOrgID);
}
}
}
} catch (Exception err) {
log.error("[getOrganisationsByXML]", err);
}
}
private String unformatString(String str) {
str = str.replaceAll(Pattern.quote("<![CDATA["), "");
str = str.replaceAll(Pattern.quote("]]>"), "");
return str;
}
private void importMeetingmembers(File meetingmembersListFile)
throws Exception {
List<MeetingMember> meetingmembersList = this
.getMeetingmembersListByXML(meetingmembersListFile);
for (MeetingMember ma : meetingmembersList) {
// We need to reset this as openJPA reject to store them otherwise
ma.setMeetingMemberId(null);
meetingMemberDao.addMeetingMemberByObject(ma);
}
}
@SuppressWarnings("unchecked")
private List<MeetingMember> getMeetingmembersListByXML(
File meetingmembersListFile) {
try {
List<MeetingMember> meetingmembersList = new LinkedList<MeetingMember>();
SAXReader reader = new SAXReader();
Document document = reader.read(meetingmembersListFile);
Element root = document.getRootElement();
for (Iterator<Element> i = root.elementIterator(); i.hasNext();) {
Element itemObject = i.next();
if (itemObject.getName().equals("meetingmembers")) {
for (Iterator<Element> innerIter = itemObject
.elementIterator("meetingmember"); innerIter
.hasNext();) {
Element appointmentsObject = innerIter.next();
Long meetingMemberId = importLongType(unformatString(appointmentsObject
.element("meetingMemberId").getText()));
Long userid = getNewId(
importLongType(unformatString(appointmentsObject
.element("userid").getText())),
Maps.USERS);
Long appointment = getNewId(
importLongType(unformatString(appointmentsObject
.element("appointment").getText())),
Maps.APPOINTMENTS);
String firstname = unformatString(appointmentsObject
.element("firstname").getText());
String lastname = unformatString(appointmentsObject
.element("lastname").getText());
String memberStatus = unformatString(appointmentsObject
.element("memberStatus").getText());
String appointmentStatus = unformatString(appointmentsObject
.element("appointmentStatus").getText());
String email = unformatString(appointmentsObject
.element("email").getText());
Boolean deleted = importBooleanType(unformatString(appointmentsObject
.element("deleted").getText()));
Boolean invitor = importBooleanType(unformatString(appointmentsObject
.element("invitor").getText()));
MeetingMember meetingMember = new MeetingMember();
meetingMember.setMeetingMemberId(meetingMemberId);
meetingMember.setUserid(usersDao.getUser(userid));
meetingMember.setAppointment(appointmentDao
.getAppointmentByIdBackup(appointment));
meetingMember.setFirstname(firstname);
meetingMember.setLastname(lastname);
meetingMember.setMemberStatus(memberStatus);
meetingMember.setAppointmentStatus(appointmentStatus);
meetingMember.setEmail(email);
meetingMember.setDeleted(deleted);
meetingMember.setInvitor(invitor);
meetingmembersList.add(meetingMember);
}
}
}
return meetingmembersList;
} catch (Exception err) {
log.error("[meetingmembersList]", err);
}
return null;
}
private void importLdapConfig(File ldapConfigListFile) throws Exception {
List<LdapConfig> ldapConfigList = this
.getLdapConfigListByXML(ldapConfigListFile);
for (LdapConfig ldapConfig : ldapConfigList) {
ldapConfigDao.addLdapConfigByObject(ldapConfig);
}
}
@SuppressWarnings("unchecked")
private List<LdapConfig> getLdapConfigListByXML(File ldapConfigListFile) {
try {
List<LdapConfig> ldapConfigsList = new LinkedList<LdapConfig>();
SAXReader reader = new SAXReader();
Document document = reader.read(ldapConfigListFile);
Element root = document.getRootElement();
for (Iterator<Element> i = root.elementIterator(); i.hasNext();) {
Element itemObject = i.next();
if (itemObject.getName().equals("ldapconfigs")) {
for (Iterator<Element> innerIter = itemObject
.elementIterator("ldapconfig"); innerIter.hasNext();) {
Element ldapconfigObject = innerIter.next();
String name = unformatString(ldapconfigObject.element(
"name").getText());
String configFileName = unformatString(ldapconfigObject
.element("configFileName").getText());
Boolean addDomainToUserName = importBooleanType(unformatString(ldapconfigObject
.element("addDomainToUserName").getText()));
String domain = unformatString(ldapconfigObject
.element("domain").getText());
Boolean isActive = importBooleanType(unformatString(ldapconfigObject
.element("isActive").getText()));
LdapConfig ldapConfig = new LdapConfig();
ldapConfig.setName(name);
ldapConfig.setConfigFileName(configFileName);
ldapConfig.setAddDomainToUserName(addDomainToUserName);
ldapConfig.setDomain(domain);
ldapConfig.setIsActive(isActive);
ldapConfigsList.add(ldapConfig);
}
}
}
return ldapConfigsList;
} catch (Exception err) {
log.error("[getLdapConfigListByXML]", err);
}
return null;
}
private void importAppointements(File appointementListFile)
throws Exception {
List<Appointment> appointmentList = this
.getAppointmentListByXML(appointementListFile);
for (Appointment appointment : appointmentList) {
Long appId = appointment.getAppointmentId();
// We need to reset this as openJPA reject to store them otherwise
appointment.setAppointmentId(null);
Long newAppId = appointmentDao.addAppointmentObj(appointment);
appointmentsMap.put(appId, newAppId);
}
}
@SuppressWarnings("unchecked")
private List<Appointment> getAppointmentListByXML(File appointementListFile) {
try {
List<Appointment> appointmentList = new LinkedList<Appointment>();
SAXReader reader = new SAXReader();
Document document = reader.read(appointementListFile);
Element root = document.getRootElement();
for (Iterator<Element> i = root.elementIterator(); i.hasNext();) {
Element itemObject = i.next();
if (itemObject.getName().equals("appointments")) {
for (Iterator<Element> innerIter = itemObject
.elementIterator("appointment"); innerIter
.hasNext();) {
Element appointmentsObject = innerIter.next();
Long appointmentId = importLongType(unformatString(appointmentsObject
.element("appointmentId").getText()));
String appointmentName = unformatString(appointmentsObject
.element("appointmentName").getText());
String appointmentLocation = unformatString(appointmentsObject
.element("appointmentLocation").getText());
String appointmentDescription = unformatString(appointmentsObject
.element("appointmentDescription").getText());
Long categoryId = importLongType(unformatString(appointmentsObject
.element("categoryId").getText()));
Date appointmentStarttime = CalendarPatterns
.parseImportDate(unformatString(appointmentsObject
.element("appointmentStarttime")
.getText()));
Date appointmentEndtime = CalendarPatterns
.parseImportDate(unformatString(appointmentsObject
.element("appointmentEndtime")
.getText()));
String deleted = unformatString(appointmentsObject
.element("deleted").getText());
Long typId = importLongType(unformatString(appointmentsObject
.element("typId").getText()));
Boolean isDaily = importBooleanType(unformatString(appointmentsObject
.element("isDaily").getText()));
Boolean isWeekly = importBooleanType(unformatString(appointmentsObject
.element("isWeekly").getText()));
Boolean isMonthly = importBooleanType(unformatString(appointmentsObject
.element("isMonthly").getText()));
Boolean isYearly = importBooleanType(unformatString(appointmentsObject
.element("isYearly").getText()));
Long room_id = getNewId(
importLongType(unformatString(appointmentsObject
.element("room_id").getText())),
Maps.ROOMS);
String icalId = unformatString(appointmentsObject
.element("icalId").getText());
Long language_id = importLongType(unformatString(appointmentsObject
.element("language_id").getText()));
Boolean isPasswordProtected = importBooleanType(unformatString(appointmentsObject
.element("isPasswordProtected").getText()));
String password = unformatString(appointmentsObject
.element("password").getText());
Long users_id = getNewId(
importLongType(unformatString(appointmentsObject
.element("users_id").getText())),
Maps.USERS);
Appointment app = new Appointment();
app.setAppointmentId(appointmentId);
app.setAppointmentLocation(appointmentLocation);
app.setAppointmentName(appointmentName);
app.setAppointmentDescription(appointmentDescription);
app.setAppointmentCategory(appointmentCategoryDaoImpl
.getAppointmentCategoryById(categoryId));
app.setAppointmentStarttime(appointmentStarttime);
app.setAppointmentEndtime(appointmentEndtime);
app.setDeleted(deleted);
app.setRemind(appointmentReminderTypDaoImpl
.getAppointmentReminderTypById(typId));
app.setIsDaily(isDaily);
app.setIsWeekly(isWeekly);
app.setIsMonthly(isMonthly);
app.setIsYearly(isYearly);
app.setRoom(roommanagement.getRoomById(room_id));
app.setIcalId(icalId);
app.setLanguage_id(language_id);
app.setIsPasswordProtected(isPasswordProtected);
app.setPassword(password);
app.setUserId(userManagement.getUserById(users_id));
appointmentList.add(app);
}
}
}
return appointmentList;
} catch (Exception err) {
log.error("[getRoomListByXML]", err);
}
return null;
}
private void importOrgRooms(File orgRoomListFile) throws Exception {
List<Rooms_Organisation> roomOrgList = this
.getOrgRoomListByXML(orgRoomListFile);
for (Rooms_Organisation rooms_Organisation : roomOrgList) {
// We need to reset this as openJPA reject to store them otherwise
rooms_Organisation.setRooms_organisation_id(null);
roommanagement.addRoomOrganisation(rooms_Organisation);
}
}
@SuppressWarnings("unchecked")
private List<Rooms_Organisation> getOrgRoomListByXML(File orgRoomListFile) {
try {
List<Rooms_Organisation> orgRoomList = new LinkedList<Rooms_Organisation>();
SAXReader reader = new SAXReader();
Document document = reader.read(orgRoomListFile);
Element root = document.getRootElement();
for (Iterator<Element> i = root.elementIterator(); i.hasNext();) {
Element itemObject = i.next();
if (itemObject.getName().equals("room_organisations")) {
for (Iterator<Element> innerIter = itemObject
.elementIterator("room_organisation"); innerIter
.hasNext();) {
Element orgRoomObject = innerIter.next();
Long rooms_organisation_id = importLongType(unformatString(orgRoomObject
.element("rooms_organisation_id").getText()));
Long organisation_id = getNewId(
importLongType(unformatString(orgRoomObject
.element("organisation_id").getText())),
Maps.ORGANISATIONS);
Long rooms_id = getNewId(
importLongType(unformatString(orgRoomObject
.element("rooms_id").getText())),
Maps.ROOMS);
String deleted = unformatString(orgRoomObject.element(
"deleted").getText());
Rooms_Organisation rooms_Organisation = new Rooms_Organisation();
rooms_Organisation
.setRooms_organisation_id(rooms_organisation_id);
rooms_Organisation
.setOrganisation(organisationmanagement
.getOrganisationById(organisation_id));
rooms_Organisation.setRoom(roommanagement
.getRoomById(rooms_id));
rooms_Organisation.setDeleted(deleted);
orgRoomList.add(rooms_Organisation);
}
}
}
return orgRoomList;
} catch (Exception err) {
log.error("[getRoomListByXML]", err);
}
return null;
}
@SuppressWarnings("unchecked")
private void importRooms(File roomFile) throws Exception {
try {
SAXReader reader = new SAXReader();
Document document = reader.read(roomFile);
Element root = document.getRootElement();
Element rooms = root.element("rooms");
for (Iterator<Element> innerIter = rooms
.elementIterator("room"); innerIter.hasNext();) {
Element roomObject = innerIter.next();
Long rooms_id = importLongType(unformatString(roomObject
.element("rooms_id").getText()));
String name = unformatString(roomObject.element("name")
.getText());
String deleted = unformatString(roomObject.element(
"deleted").getText());
String comment = unformatString(roomObject.element(
"comment").getText());
Long numberOfPartizipants = importLongType(unformatString((roomObject
.element("numberOfPartizipants").getText())));
Boolean appointment = importBooleanType(unformatString(roomObject
.element("appointment").getText()));
Long externalRoomId = importLongType(unformatString(roomObject
.element("externalRoomId").getText()));
String externalRoomType = unformatString(roomObject
.element("externalRoomType").getText());
Long roomtypes_id = importLongType(unformatString(roomObject
.element("roomtypeId").getText()));
Boolean isDemoRoom = false;
if (roomObject
.element("isDemoRoom") != null) {
isDemoRoom = importBooleanType(unformatString(roomObject
.element("isDemoRoom").getText()));
}
Integer demoTime = null;
if (roomObject
.element("demoTime") != null) {
demoTime = importIntegerType(unformatString(roomObject
.element("demoTime").getText()));
}
Boolean isModeratedRoom = false;
if (roomObject.element("isModeratedRoom") != null) {
isModeratedRoom = importBooleanType(unformatString(roomObject
.element("isModeratedRoom").getText()));
}
Boolean allowUserQuestions = true;
if (roomObject.element("allowUserQuestions") != null) {
allowUserQuestions = importBooleanType(unformatString(roomObject
.element("allowUserQuestions").getText()));
}
Boolean isAudioOnly = false;
if (roomObject.element("isAudioOnly") != null) {
isAudioOnly = importBooleanType(unformatString(roomObject
.element("isAudioOnly").getText()));
}
String sipNumber = "";
if (roomObject.element("sipNumber") != null) {
sipNumber = unformatString(roomObject.element(
"sipNumber").getText());
}
String conferencePin = "";
if (roomObject.element("conferencePin") != null) {
conferencePin = unformatString(roomObject
.element("conferencePin").getText());
}
Boolean showMicrophoneStatus = false;
if (roomObject.element("showMicrophoneStatus") != null) {
showMicrophoneStatus = importBooleanType(unformatString(roomObject
.element("showMicrophoneStatus").getText()));
}
Long ownerId = null;
if (roomObject.element("ownerid") != null) {
ownerId = getNewId(
importLongType(unformatString(roomObject
.element("ownerid").getText())),
Maps.USERS);
}
Boolean ispublic = false;
if (roomObject.element("ispublic") != null) {
ispublic = importBooleanType(unformatString(roomObject
.element("ispublic").getText()));
}
Boolean waitForRecording = false;
if (roomObject.element("waitForRecording") != null) {
waitForRecording = importBooleanType(unformatString(roomObject
.element("waitForRecording").getText()));
}
Boolean hideTopBar = false;
if (roomObject.element("hideTopBar") != null) {
hideTopBar = importBooleanType(unformatString(roomObject
.element("hideTopBar").getText()));
}
Boolean isClosed = false;
if (roomObject.element("isClosed") != null) {
isClosed = importBooleanType(unformatString(roomObject
.element("isClosed").getText()));
}
Boolean allowRecording = false;
if (roomObject.element("allowRecording") != null) {
allowRecording = importBooleanType(unformatString(roomObject
.element("allowRecording").getText()));
}
String redirectURL = "";
if (roomObject.element("redirectURL") != null) {
redirectURL = unformatString(roomObject.element(
"redirectURL").getText());
}
Boolean hideActionsMenu = false;
if (roomObject.element("hideActionsMenu") != null) {
hideTopBar = importBooleanType(unformatString(roomObject
.element("hideActionsMenu").getText()));
}
Boolean hideActivitiesAndActions = false;
if (roomObject.element("hideActivitiesAndActions") != null) {
hideTopBar = importBooleanType(unformatString(roomObject
.element("hideActivitiesAndActions").getText()));
}
Boolean hideChat = false;
if (roomObject.element("hideChat") != null) {
hideTopBar = importBooleanType(unformatString(roomObject
.element("hideChat").getText()));
}
Boolean hideFilesExplorer = false;
if (roomObject.element("hideFilesExplorer") != null) {
hideTopBar = importBooleanType(unformatString(roomObject
.element("hideFilesExplorer").getText()));
}
Boolean hideScreenSharing = false;
if (roomObject.element("hideScreenSharing") != null) {
hideTopBar = importBooleanType(unformatString(roomObject
.element("hideScreenSharing").getText()));
}
Boolean hideWhiteboard = false;
if (roomObject.element("hideWhiteboard") != null) {
hideTopBar = importBooleanType(unformatString(roomObject
.element("hideWhiteboard").getText()));
}
Rooms room = new Rooms();
room.setRooms_id(rooms_id);
room.setOwnerId(ownerId);
room.setName(name);
room.setDeleted(deleted);
room.setComment(comment);
room.setNumberOfPartizipants(numberOfPartizipants);
room.setAppointment(appointment);
room.setExternalRoomId(externalRoomId);
room.setExternalRoomType(externalRoomType);
room.setRoomtype(roommanagement
.getRoomTypesById(roomtypes_id));
room.setIsDemoRoom(isDemoRoom);
room.setDemoTime(demoTime);
room.setIsModeratedRoom(isModeratedRoom);
room.setAllowUserQuestions(allowUserQuestions);
room.setIsAudioOnly(isAudioOnly);
room.setSipNumber(sipNumber);
room.setConferencePin(conferencePin);
room.setIspublic(ispublic);
room.setIsClosed(isClosed);
room.setRedirectURL(redirectURL);
room.setWaitForRecording(waitForRecording);
room.setHideTopBar(hideTopBar);
room.setAllowRecording(allowRecording);
room.setShowMicrophoneStatus(showMicrophoneStatus);
room.setHideActionsMenu(hideActionsMenu);
room.setHideActivitiesAndActions(hideActivitiesAndActions);
room.setHideChat(hideChat);
room.setHideFilesExplorer(hideFilesExplorer);
room.setHideScreenSharing(hideScreenSharing);
room.setHideWhiteboard(hideWhiteboard);
Long roomId = room.getRooms_id();
// We need to reset this as openJPA reject to store them
// otherwise
room.setRooms_id(null);
Long newRoomId = roommanagement.addRoom(room);
roomsMap.put(roomId, newRoomId);
for (Iterator<Element> iterMods = roomObject
.elementIterator("room_moderators"); iterMods
.hasNext();) {
Element room_moderators = iterMods.next();
for (Iterator<Element> iterMod = room_moderators
.elementIterator("room_moderator"); iterMod
.hasNext();) {
Element room_moderator = iterMod.next();
RoomModerators roomModerators = new RoomModerators();
Long user_id = getNewId(
importLongType(unformatString(room_moderator
.element("user_id").getText())),
Maps.USERS);
Boolean is_supermoderator = importBooleanType(unformatString(room_moderator
.element("is_supermoderator").getText()));
roomModerators.setDeleted("false");
roomModerators.setRoomId(getNewId(rooms_id,
Maps.ROOMS));
roomModerators.setUser(userManagement
.getUserById(user_id));
roomModerators
.setIsSuperModerator(is_supermoderator);
roomModeratorsDao
.addRoomModeratorByObj(roomModerators);
}
}
}
} catch (Exception err) {
log.error("[getRoomListByXML]", err);
}
}
private void importFileExplorerItems(File fileExplorerItemsListFile)
throws Exception {
List<FileExplorerItem> fileExplorerItems = this
.getFileExplorerItems(fileExplorerItemsListFile);
for (FileExplorerItem fileExplorerItem : fileExplorerItems) {
// We need to reset this as openJPA reject to store them otherwise
long itemId = fileExplorerItem.getFileExplorerItemId();
fileExplorerItem.setFileExplorerItemId(0);
long newItemId = fileExplorerItemDao
.addFileExplorerItem(fileExplorerItem);
fileExplorerItemsMap.put(itemId, newItemId);
}
}
@SuppressWarnings("unchecked")
private List<FileExplorerItem> getFileExplorerItems(
File fileExplorerItemsListFile) {
try {
List<FileExplorerItem> fileExplorerItemsList = new LinkedList<FileExplorerItem>();
SAXReader reader = new SAXReader();
Document document = reader.read(fileExplorerItemsListFile);
Element root = document.getRootElement();
for (Iterator<Element> i = root.elementIterator(); i.hasNext();) {
Element itemObject = i.next();
if (itemObject.getName().equals("fileExplorerItems")) {
for (Iterator<Element> innerIter = itemObject
.elementIterator("fileExplorerItem"); innerIter
.hasNext();) {
Element fileExplorerItemObj = innerIter.next();
Long fileExplorerItemId = importLongType(unformatString(fileExplorerItemObj
.element("fileExplorerItemId").getText()));
String fileName = unformatString(fileExplorerItemObj
.element("fileName").getText());
String fileHash = unformatString(fileExplorerItemObj
.element("fileHash").getText());
Long parentFileExplorerItemId = importLongType(unformatString(fileExplorerItemObj
.element("parentFileExplorerItemId").getText()));
Long room_id = getNewId(
importLongType(unformatString(fileExplorerItemObj
.element("room_id").getText())),
Maps.ROOMS);
Long ownerId = getNewId(
importLongType(unformatString(fileExplorerItemObj
.element("ownerId").getText())),
Maps.USERS);
Boolean isFolder = importBooleanType(unformatString(fileExplorerItemObj
.element("isFolder").getText()));
Boolean isImage = importBooleanType(unformatString(fileExplorerItemObj
.element("isImage").getText()));
Boolean isPresentation = importBooleanType(unformatString(fileExplorerItemObj
.element("isPresentation").getText()));
Boolean isVideo = importBooleanType(unformatString(fileExplorerItemObj
.element("isVideo").getText()));
Long insertedBy = getNewId(
importLongType(unformatString(fileExplorerItemObj
.element("insertedBy").getText())),
Maps.USERS);
Date inserted = CalendarPatterns
.parseImportDate(unformatString(fileExplorerItemObj
.element("inserted").getText()));
Date updated = CalendarPatterns
.parseImportDate(unformatString(fileExplorerItemObj
.element("updated").getText()));
String deleted = unformatString(fileExplorerItemObj
.element("deleted").getText());
Long fileSize = importLongType(unformatString(fileExplorerItemObj
.element("fileSize").getText()));
Integer flvWidth = importIntegerType(unformatString(fileExplorerItemObj
.element("flvWidth").getText()));
Integer flvHeight = importIntegerType(unformatString(fileExplorerItemObj
.element("flvHeight").getText()));
String previewImage = unformatString(fileExplorerItemObj
.element("previewImage").getText());
String wmlFilePath = unformatString(fileExplorerItemObj
.element("wmlFilePath").getText());
Boolean isStoredWmlFile = importBooleanType(unformatString(fileExplorerItemObj
.element("isStoredWmlFile").getText()));
Boolean isChart = importBooleanType(unformatString(fileExplorerItemObj
.element("isChart").getText()));
FileExplorerItem fileExplorerItem = new FileExplorerItem();
fileExplorerItem
.setFileExplorerItemId(fileExplorerItemId);
fileExplorerItem.setFileName(fileName);
fileExplorerItem.setFileHash(fileHash);
fileExplorerItem
.setParentFileExplorerItemId(parentFileExplorerItemId);
fileExplorerItem.setRoom_id(room_id);
fileExplorerItem.setOwnerId(ownerId);
fileExplorerItem.setIsFolder(isFolder);
fileExplorerItem.setIsImage(isImage);
fileExplorerItem.setIsPresentation(isPresentation);
fileExplorerItem.setIsVideo(isVideo);
fileExplorerItem.setInsertedBy(insertedBy);
fileExplorerItem.setInserted(inserted);
fileExplorerItem.setUpdated(updated);
fileExplorerItem.setDeleted(deleted);
fileExplorerItem.setFileSize(fileSize);
fileExplorerItem.setFlvWidth(flvWidth);
fileExplorerItem.setFlvHeight(flvHeight);
fileExplorerItem.setPreviewImage(previewImage);
fileExplorerItem.setWmlFilePath(wmlFilePath);
fileExplorerItem.setIsStoredWmlFile(isStoredWmlFile);
fileExplorerItem.setIsChart(isChart);
fileExplorerItemsList.add(fileExplorerItem);
}
}
}
return fileExplorerItemsList;
} catch (Exception err) {
log.error("[getFileExplorerItems]", err);
}
return null;
}
private void importFolders(String current_dir, File importBaseDir)
throws IOException {
// Now check the room files and import them
File roomFilesFolder = new File(importBaseDir, "roomFiles");
File library_dir = new File(current_dir, OpenmeetingsVariables.UPLOAD_DIR);
log.debug("roomFilesFolder PATH " + roomFilesFolder.getAbsolutePath());
if (roomFilesFolder.exists()) {
File[] files = roomFilesFolder.listFiles();
for (File file : files) {
if (file.isDirectory()) {
File parentPathFile = new File(library_dir, file.getName());
if (!parentPathFile.exists()) {
parentPathFile.mkdir();
}
File[] roomOrProfileFiles = file.listFiles();
for (File roomOrProfileFileOrFolder : roomOrProfileFiles) {
if (roomOrProfileFileOrFolder.isDirectory()) {
String fileOrFolderName = roomOrProfileFileOrFolder
.getName();
int beginIndex = fileOrFolderName
.indexOf(ScopeApplicationAdapter.profilesPrefix);
// Profile folder should be renamed if new user id
// is differ from current id.
if (beginIndex > -1) {
beginIndex = beginIndex
+ ScopeApplicationAdapter.profilesPrefix
.length();
Long profileId = importLongType(fileOrFolderName
.substring(beginIndex));
Long newProfileID = getNewId(profileId,
Maps.USERS);
if (profileId != newProfileID) {
fileOrFolderName = fileOrFolderName
.replaceFirst(
ScopeApplicationAdapter.profilesPrefix
+ profileId,
ScopeApplicationAdapter.profilesPrefix
+ newProfileID);
}
}
File roomDocumentFolder = new File(parentPathFile, fileOrFolderName);
if (!roomDocumentFolder.exists()) {
roomDocumentFolder.mkdir();
File[] roomDocumentFiles = roomOrProfileFileOrFolder
.listFiles();
for (File roomDocumentFile : roomDocumentFiles) {
if (roomDocumentFile.isDirectory()) {
log.error("Folder detected in Documents space! Folder "
+ roomDocumentFolder);
} else {
copyFile(roomDocumentFile,
new File(roomDocumentFolder, roomDocumentFile.getName()));
}
}
} else {
log.debug("Document already exists :: ",
roomDocumentFolder);
}
} else {
File roomFileOrProfileFile = new File(parentPathFile, roomOrProfileFileOrFolder.getName());
if (!roomFileOrProfileFile.exists()) {
this.copyFile(roomOrProfileFileOrFolder,
roomFileOrProfileFile);
} else {
log.debug("File does already exist :: ", roomFileOrProfileFile);
}
}
}
}
}
}
// Now check the recordings and import them
File sourceDirRec = new File(importBaseDir, "recordingFiles");
log.debug("sourceDirRec PATH " + sourceDirRec.getAbsolutePath());
if (sourceDirRec.exists()) {
File targetDirRec = new File(current_dir, OpenmeetingsVariables.STREAMS_DIR
+ File.separatorChar + "hibernate" + File.separatorChar);
copyDirectory(sourceDirRec, targetDirRec);
}
}
private Integer importIntegerType(String value) {
if (value.equals("null") || value.equals("")) {
return null;
}
return Integer.valueOf(value).intValue();
}
private Long importLongType(String value) {
if (value.equals("null") || value.equals("")) {
return null;
}
return Long.valueOf(value).longValue();
}
private Boolean importBooleanType(String value) {
if (value.equals("null") || value.equals("")) {
return null;
}
return Boolean.valueOf(value).booleanValue();
}
private Long getNewId(Long oldId, Maps map) {
Long newId = oldId;
switch (map) {
case USERS:
if (usersMap.get(oldId) != null)
newId = usersMap.get(oldId);
break;
case ORGANISATIONS:
if (organisationsMap.get(oldId) != null)
newId = organisationsMap.get(oldId);
break;
case APPOINTMENTS:
if (appointmentsMap.get(oldId) != null)
newId = appointmentsMap.get(oldId);
break;
case ROOMS:
if (roomsMap.get(oldId) != null)
newId = roomsMap.get(oldId);
break;
case MESSAGEFOLDERS:
if (messageFoldersMap.get(oldId) != null)
newId = messageFoldersMap.get(oldId);
break;
case USERCONTACTS:
if (userContactsMap.get(oldId) != null)
newId = userContactsMap.get(oldId);
break;
case FILEEXPLORERITEMS:
if (fileExplorerItemsMap.get(oldId) != null)
newId = fileExplorerItemsMap.get(oldId);
break;
default:
break;
}
return newId;
}
}