src/org/openmeetings/servlet/outputhandler/BackupImportController.java

/*
 * 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;
	}

}