Communication.java

/**
 * Copyright (c) 2009 Juwi MacMillan Group GmbH
 *
 * Licensed 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 de.juwimm.cms.util;

import static de.juwimm.cms.common.Constants.rb;

import java.awt.Cursor;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
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.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Vector;

import javax.swing.JDialog;
import javax.swing.JOptionPane;
import javax.swing.tree.TreePath;

import org.andromda.spring.RemoteServiceLocator;
import org.apache.commons.io.IOUtils;
import org.apache.log4j.Logger;
import org.springframework.remoting.RemoteAccessException;
import org.springframework.remoting.RemoteInvocationFailureException;
import org.springframework.security.GrantedAuthority;
import org.springframework.security.SpringSecurityException;
import org.springframework.security.context.SecurityContextHolder;
import org.springframework.security.providers.UsernamePasswordAuthenticationToken;
import org.springframework.security.providers.rcp.RemoteAuthenticationManager;
import org.tizzit.util.ArraySorter;
import org.tizzit.util.Comparer;
import org.tizzit.util.XercesHelper;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

import com.Ostermiller.util.Browser;

import de.juwimm.cms.Messages;
import de.juwimm.cms.authorization.vo.GroupValue;
import de.juwimm.cms.authorization.vo.RoleValue;
import de.juwimm.cms.authorization.vo.UserLoginValue;
import de.juwimm.cms.authorization.vo.UserUnitsGroupsValue;
import de.juwimm.cms.authorization.vo.UserValue;
import de.juwimm.cms.common.Constants;
import de.juwimm.cms.common.UserRights;
import de.juwimm.cms.components.vo.AddressValue;
import de.juwimm.cms.components.vo.DepartmentValue;
import de.juwimm.cms.components.vo.PersonValue;
import de.juwimm.cms.components.vo.TalktimeValue;
import de.juwimm.cms.content.frame.DlgModal;
import de.juwimm.cms.exceptions.AlreadyCheckedOutException;
import de.juwimm.cms.exceptions.InvalidSizeException;
import de.juwimm.cms.exceptions.InvalidUsernameException;
import de.juwimm.cms.exceptions.LocalizedException;
import de.juwimm.cms.exceptions.NeededFieldsMissingException;
import de.juwimm.cms.exceptions.NoSitesException;
import de.juwimm.cms.exceptions.UnitnameIsAlreadyUsedException;
import de.juwimm.cms.exceptions.UserException;
import de.juwimm.cms.exceptions.ViewComponentLinkNameAlreadyExisting;
import de.juwimm.cms.exceptions.ViewComponentLinkNameIsEmptyException;
import de.juwimm.cms.exceptions.ViewComponentNotFound;
import de.juwimm.cms.gui.PanCheckInPages;
import de.juwimm.cms.gui.event.ExitEvent;
import de.juwimm.cms.gui.event.ExitListener;
import de.juwimm.cms.gui.table.ModifiedPagesTableModel;
import de.juwimm.cms.gui.tree.CmsTreeModel;
import de.juwimm.cms.gui.tree.PageNode;
import de.juwimm.cms.http.HttpClientWrapper;
import de.juwimm.cms.remote.ClientServiceSpring;
import de.juwimm.cms.safeguard.vo.ActiveRealmValue;
import de.juwimm.cms.safeguard.vo.RealmJaasValue;
import de.juwimm.cms.safeguard.vo.RealmJdbcValue;
import de.juwimm.cms.safeguard.vo.RealmLdapValue;
import de.juwimm.cms.safeguard.vo.RealmSimplePwUserValue;
import de.juwimm.cms.safeguard.vo.RealmSimplePwValue;
import de.juwimm.cms.search.vo.XmlSearchValue;
import de.juwimm.cms.vo.AccessRoleValue;
import de.juwimm.cms.vo.ContentValue;
import de.juwimm.cms.vo.ContentVersionValue;
import de.juwimm.cms.vo.DocumentSlimValue;
import de.juwimm.cms.vo.DocumentValue;
import de.juwimm.cms.vo.EditionValue;
import de.juwimm.cms.vo.HostValue;
import de.juwimm.cms.vo.PictureSlimValue;
import de.juwimm.cms.vo.PictureSlimstValue;
import de.juwimm.cms.vo.ShortLinkValue;
import de.juwimm.cms.vo.SiteGroupValue;
import de.juwimm.cms.vo.SiteValue;
import de.juwimm.cms.vo.TaskValue;
import de.juwimm.cms.vo.UnitValue;
import de.juwimm.cms.vo.ViewComponentValue;
import de.juwimm.cms.vo.ViewDocumentValue;
import de.juwimm.cms.vo.compound.ViewIdAndInfoTextValue;
import de.juwimm.cms.vo.compound.ViewIdAndUnitIdValue;

/**
 * Facade Class for communicating with the server.
 * 
 * @author <a href="mailto:s.kulawik@juwimm.com">Sascha-Matthias Kulawik</a>
 * @version $Id$
 */
public class Communication implements ExitListener, ActionListener {
	private static Logger log = Logger.getLogger(Communication.class);
	private UserLoginValue user = null;
	private GroupValue[] groups = null;
	private boolean loggedIn = false;
	private int activeSiteId = -1;
	private CmsTreeModel treeModel;
	private boolean isSessionInitialized = false;
	private ViewDocumentValue viewDocument = null;
	private int selectedUnitId;
	private DbHelper dbHelper = null;
	/* This ArrayList contains the ContentId (Integer) of all Contents who
	 * haven't been checked in. Needed for checking them in after unclean exit
	 */
	private static ArrayList<Integer> checkOutPages = new ArrayList<Integer>();
	private ClientServiceSpring clientService;

	public Communication() {

	}

	public Communication initialize() {
		if (!isSessionInitialized) {
			ActionHub.addExitListener(this);
			isSessionInitialized = true;
		}
		return this;
	}

	public ClientServiceSpring getClientService() {
		return clientService;
	}

	public void setClientService(ClientServiceSpring clientService) {
		this.clientService = clientService;
	}

	/**
	 * @param e
	 */
	public void actionPerformed(ActionEvent e) {
		ActionHub.fireActionPerformed(e);
	}

	public boolean isLoggedIn() {
		return loggedIn;
	}

	public void setLoggedIn(boolean loggedIn) {
		this.loggedIn = loggedIn;
	}

	public int getViewDocumentId() {
		return viewDocument.getViewDocumentId().intValue();
	}

	public ViewDocumentValue getViewDocument() {
		return viewDocument;
	}

	public void setViewDocument(ViewDocumentValue vdDao) {
		this.viewDocument = vdDao;
	}

	public boolean isUserInRole(String role) {
		if (user == null) {
			return false;
		}
		if (user.getUser().isMasterRoot()) {
			return true;
		}
		if (isUserInRolePhysically(role)) {
			return true;
		}
		if (isUserInRolePhysically(UserRights.SITE_ROOT)) {
			return true;
		}
		return false;
	}

	public boolean isUserInRolePhysically(String role) {
		if (groups == null) return false;
		for (int i = 0; i < groups.length; i++) {
			RoleValue[] roles = groups[i].getRoles();
			if (roles == null) continue;
			for (int j = 0; j < roles.length; j++) {
				if (roles[j].getRoleId().equalsIgnoreCase(role)) {
					return true;
				}
			}
		}
		return false;
	}

	public boolean isUserInRole(UserValue uv, String role) {
		if (uv == null) {
			return false;
		}
		if (uv.isMasterRoot()) {
			return true;
		}
		try {
			GroupValue[] gv = getClientService().getGroups4User(uv.getUserName());
			if (gv == null) return false;
			for (int i = 0; i < gv.length; i++) {
				for (int j = 0; j < gv[i].getRoles().length; j++) {
					if (gv[i].getRoles()[j].getRoleId().equalsIgnoreCase(role)) {
						return true;
					}
				}
			}
		} catch (Exception exe) {
			log.error(exe);
		}
		return false;
	}

	public GroupValue[] getGroups() {
		return groups;
	}

	public GroupValue[] getGroups4User(String userName) throws Exception {
		GroupValue[] gv = getClientService().getGroups4User(userName);
		if (gv == null) gv = new GroupValue[0];
		return gv;
	}

	public void removeUserFromGroup(GroupValue gv, String userName) throws Exception {
		gv.setRoles(new RoleValue[0]);
		getClientService().removeUserFromGroup(gv, userName);
	}

	public void addUserToGroup(GroupValue groupValue, String usrName) throws Exception {
		groupValue.setRoles(new RoleValue[0]);
		getClientService().addUserToGroup(groupValue, usrName);
	}

	public RoleValue[] getRolesMe() {
		ArrayList<String> al = new ArrayList<String>(groups.length);
		for (int i = 0; i < groups.length; i++) {
			for (int j = 0; j < groups[i].getRoles().length; j++) {
				al.add(groups[i].getRoles()[j].getRoleId());
			}
		}
		return al.toArray(new RoleValue[0]);
	}

	public RoleValue[] getAllRoles() {
		try {
			return getClientService().getAllRoles();
		} catch (Exception exe) {
			log.error(exe);
		}
		return new RoleValue[0];
	}

	public GroupValue[] getAllGroups() {
		GroupValue[] gv = new GroupValue[0];
		try {
			gv = getClientService().getAllGroups();
		} catch (Exception exe) {
			log.error(exe);
		}
		return gv;
	}

	public GroupValue[] getAllGroupsUsedInUnit(int unitId) {
		GroupValue[] gv = new GroupValue[0];
		try {
			gv = getClientService().getAllGroupsUsedInUnit(Integer.valueOf(unitId));
		} catch (Exception exe) {
			log.error(exe);
		}
		return gv;
	}

	public GroupValue createGroup(String groupName) throws Exception {
		return getClientService().createGroup(groupName);
	}

	public void removeGroup(int groupId) throws Exception {
		getClientService().removeGroup(Integer.valueOf(groupId));
	}

	public void updateGroup(GroupValue gv) throws Exception {
		getClientService().updateGroup(gv);
	}

	/**
	 * @deprecated This was a migration method for migrating to new Axis model
	 */
	@Deprecated
	private Vector arrayToVector(Object[] objarr) {
		if (objarr != null) {
			Vector<Object> vec = new Vector<Object>(objarr.length);
			for (int i = 0; i < objarr.length; i++) {
				vec.add(objarr[i]);
			}
			return vec;
		}
		return new Vector();
	}

	public void showBrowserWindow(int vcId, boolean showInFrame) {
		String strHost = Constants.CMS_PATH_DEMOPAGE;
		String page = "";

		if (showInFrame) {
			page = Constants.CMS_PATH_DEMOPAGE_FULLFRAMESET;
		} else {
			page = Constants.CMS_PATH_DEMOPAGE_CONTENT;
		}

		try {
			Browser.displayURL(strHost + getViewDocument().getLanguage() + "/" + getPathForViewComponentId(vcId) + "." + page);
		} catch (IOException exe) {
			log.error("Show browser error occures", exe);
		}
	}

	public String getPathForViewComponentId(int vcId) {
		try {
			return getClientService().getPathForViewComponentId(Integer.valueOf(vcId));
		} catch (Exception exe) {
			return "";
		}
	}

	public String getDCF(String dcfname) throws Exception {
		String dcf = getDbHelper().getDCF(dcfname);
		if (dcf == null || dcf.equalsIgnoreCase("")) {
			dcf = HttpClientWrapper.getInstance().getString(Constants.CMS_PATH_DCF + dcfname + ".xml?lang=" + Constants.CMS_LOCALE.getLanguage());
			getDbHelper().setDCF(dcfname, dcf);
		}
		return dcf;
	}

	public boolean exitPerformed(ExitEvent e) {
		log.info("Exit-event started");
		int result = JOptionPane.showConfirmDialog(UIConstants.getMainFrame(), rb.getString("dialog.exit.text"), rb.getString("dialog.exit"), JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE);
		if (result == JOptionPane.YES_OPTION) {
			if (!checkOutPages.isEmpty()) {
				ArrayList<ContentValue> pageList = new ArrayList<ContentValue>();
				Iterator it = checkOutPages.iterator();
				while (it.hasNext()) {
					try {
						ContentValue current = getClientService().getContent(((Integer) it.next()));
						pageList.add(current);
					} catch (Exception ex) {
						String msg = Messages.getString("exception.checkingInAllRemainingPages", Integer.toString(checkOutPages.size()));
						log.info(msg);
						JOptionPane.showMessageDialog(UIConstants.getMainFrame(), msg, rb.getString("dialog.title"), JOptionPane.INFORMATION_MESSAGE);
						UIConstants.getMainFrame().setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
						while (it.hasNext()) {
							Integer contentId = (Integer) it.next();
							try {
								msg = Messages.getString("exception.checkingInAllRemainingPagesStatusbar", contentId.toString());
								UIConstants.setActionStatus(msg);
								getClientService().checkIn4ContentId(contentId);
							} catch (Exception exe) {
								log.error("Exit event error", exe);
							}
						}
						checkOutPages = new ArrayList<Integer>();
						UIConstants.getMainFrame().setCursor(Cursor.getDefaultCursor());
						try {
							if (log.isDebugEnabled()) {
								log.debug("Calling logout on server");
							}
							getClientService().logout();
						} catch (Exception exe) {
						}
						log.info("Goodbye!");
						loggedIn = false;
						return true;
					}
				}
				PanCheckInPages pan = new PanCheckInPages(pageList);
				if (rb == null) rb = Constants.rb;
				DlgModal dlg = new DlgModal(pan, 300, 500, rb.getString("DlgModal.checkin"));
				dlg.addOkListener(new OkListener(pan, dlg));
				dlg.setVisible(true);
			}
			try {
				if (log.isDebugEnabled()) {
					log.debug("Calling logout on server");
				}
				getClientService().logout();
			} catch (Exception exe) {
			}
			log.info("Goodbye!");
			loggedIn = false;
			return true;
		}
		return false;
	}

	public void setSelectedUnitId(int unitId) {
		selectedUnitId = unitId;
	}

	public int getSelectedUnitId() {
		return selectedUnitId;
	}

	public UserValue getUser() {
		if (user != null) {
			return user.getUser();
		}
		return null;
	}

	public UserValue getUserByName(String userName) {
		return getClientService().getUserForId(userName);
	}

	public String getSiteConfigXML() {
		return user.getSiteConfigXML();
	}

	public String getSiteName() {
		return user.getSiteName();
	}

	public int getSiteId() {
		return activeSiteId;
	}

	public boolean isUserInUnit(int unitId) {
		//getClientService().isUserInUnit(user.getUser().getUserName(), unitId);
		UnitValue[] uv = user.getUnits();
		if (uv == null) {
			return false;
		}
		for (int i = 0; i < uv.length; i++) {
			if (uv[i].getUnitId().intValue() == unitId) {
				return true;
			}
		}
		return false;
	}

	public DbHelper getDbHelper() {
		if (dbHelper == null) {
			dbHelper = new DbHelper();
		}
		return dbHelper;
	}

	public SiteValue[] getSites(String userName, String passwd) throws InvalidUsernameException, NoSitesException, LocalizedException {
		log.info("Trying to fetching Sites for User " + userName);
		try {
			SecurityContextHolder.setStrategyName(SecurityContextHolder.MODE_GLOBAL);
			RemoteAuthenticationManager remoteAuthenticationService = RemoteServiceLocator.instance().getRemoteAuthenticationService();
			GrantedAuthority[] authorities = remoteAuthenticationService.attemptAuthentication(userName, String.valueOf(passwd));
			SecurityContextHolder.getContext().setAuthentication(new UsernamePasswordAuthenticationToken(userName, String.valueOf(passwd), authorities));
			log.debug(SecurityContextHolder.getContext().getAuthentication());
		} catch (RemoteAccessException e) {
			if (e.getCause() != null && e.getCause() instanceof SpringSecurityException) {
				log.info("authentication failed: " + e.getMessage());
				throw new InvalidUsernameException();
			}
			LocalizedException ge = new LocalizedException("communication.login.unkwownError", "unknown error", e);
			ge.logThrowException();
			throw ge;
		}

		try {
			ClientServiceSpring cs = getClientService();
			SiteValue[] sites = cs.getSites();
			return sites;
		} catch (Exception e) {
			//	    e.printStackTrace();
			throw new NoSitesException("No sites associated?", e);
		}
	}

	public UserLoginValue login(String userName, String passwd, int activeSiteId) throws UserException {
		try {
			log.info("Trying to logging in User " + userName + " at activeSiteId " + activeSiteId);
			this.activeSiteId = activeSiteId;
			user = getClientService().login(userName, passwd, Integer.valueOf(activeSiteId));
			groups = getClientService().getGroups();
		} catch (Exception ue) {
			log.error("Error getting login", ue);
			throw new UserException(ue);
		}
		log.info("Login succeeded");
		return user;
	}

	public UnitValue[] getUnits() throws Exception {
		UnitValue[] uda = getClientService().getUnits();
		if (uda != null) Arrays.sort(uda, new UnitDaoComparer());
		return uda;
	}

	/**
	 * 
	 * @author <a href="mailto:s.kulawik@juwimm.com">Sascha-Matthias Kulawik</a>
	 *         company Juwi|MacMillan Group Gmbh, Walsrode, Germany
	 * @version $Id$
	 */
	public static class UnitDaoComparer extends UserValue implements Comparator<UnitValue> {
		private static final long serialVersionUID = 1329857419797304096L;

		public int compare(UnitValue objA, UnitValue objB) {
			return objA.getName().toLowerCase().compareTo(objB.getName().toLowerCase());
		}
	}

	public UnitValue[] getAllUnits() throws Exception {
		UnitValue[] uda = getClientService().getAllUnits();
		if (uda != null) Arrays.sort(uda, new UnitDaoComparer());
		return uda;
	}

	public UnitValue getUnit(int unitId) throws Exception {
		return getClientService().getUnit(Integer.valueOf(unitId));
	}

	public UserValue[] getUser4Unit(int unitId) throws Exception {
		return getClientService().getAllUserForUnit(Integer.valueOf(unitId));
	}

	public void updateUser(UserValue uv) throws Exception {
		getClientService().updateUser(uv);
	}

	public void updateUserMe() {
		try {
			getClientService().updateUser(getUser());
		} catch (Exception exe) {
			log.error(exe);
		}
	}

	public void changePassword(String userName, String passwdNew) throws Exception {
		getClientService().changePassword4User(userName, passwdNew, passwdNew);
		if (userName.equals(user.getUser().getUserName())) {
			getSites(userName, passwdNew);
		}
	}

	public void createUser(String userName, String passwd, String firstName, String lastName, String email, int initialUnitId) throws NeededFieldsMissingException, Exception {
		initialUnitId = (initialUnitId < 0) ? 0 : initialUnitId;
		try {
			getClientService().createUser(userName, passwd, firstName, lastName, email, Integer.valueOf(initialUnitId));
		} catch (Exception ue) {
			/*
			 * if (this.isExceptionOfType(ue, "NeededFieldsMissingException")) {
			 * AxisFault af = (AxisFault) ue; String reason =
			 * af.getFaultReason(); String expected =
			 * Communication.USER_EXCEPTION + "NeededFieldsMissingException";
			 * NeededFieldsMissingException nfme = new
			 * NeededFieldsMissingException(); reason =
			 * reason.substring(expected.length());
			 * nfme.setMissingFields(reason); throw nfme; }
			 */
			// log.error("Error creating user", ue);
			throw new UserException(ue);
		}
	}

	public Integer createUnit(String unitName) throws UnitnameIsAlreadyUsedException, UserException {
		try {
			return getClientService().createUnit(unitName);
		} catch (Exception ue) {
			/*
			 * if (this.isExceptionOfType(ue, "UnitnameIsAlreadyUsedException")) {
			 * UnitnameIsAlreadyUsedException
			 * unitNameInUseExeption = new UnitnameIsAlreadyUsedException();
			 * throw unitNameInUseExeption; }
			 */
			throw new UserException(ue);
		}
	}

	public void removeUnit(UnitValue unitDao) throws Exception {
		getClientService().removeUnit(unitDao);
	}

	public void removeUnit(int unitId) throws Exception {
		getClientService().removeUnit(Integer.valueOf(unitId));
	}

	public void removeTask(int taskId) throws Exception {
		getClientService().removeTask(Integer.valueOf(taskId));
	}

	public void setTaskViewed(int taskId) throws Exception {
		getClientService().setTaskViewed(Integer.valueOf(taskId));
	}

	public void removePerson(long personId) throws Exception {
		getClientService().removePerson(Long.valueOf(personId));
	}

	public void removeDepartment(long departmentId) throws Exception {
		getClientService().removeDepartment(Long.valueOf(departmentId));
	}

	public void removeAddress(long addressId) throws Exception {
		getClientService().removeAddress(Long.valueOf(addressId));
	}

	public void removeTalktime(long talktimeId) throws Exception {
		getClientService().removeTalktime(Long.valueOf(talktimeId));
	}

	public long addTalktime2Person(long personId, String talkTimeType, String talkTimes) throws Exception {
		return getClientService().addTalktime2Person(personId, talkTimeType, talkTimes);
	}

	public long addTalktime2Department(long departmentId, String talkTimeType, String talkTimes) throws Exception {
		return getClientService().addTalktime2Department(Long.valueOf(departmentId), talkTimeType, talkTimes);
	}

	public long addTalktime2Unit(int unitId, String talkTimeType, String talkTimes) throws Exception {
		return getClientService().addTalktime2Unit(Integer.valueOf(unitId), talkTimeType, talkTimes);
	}

	public void addAddress2Person(long personId, long addressId) throws Exception {
		getClientService().addAddress2Person(Long.valueOf(personId), Long.valueOf(addressId));
	}

	public void addAddress2Department(long departmentId, long addressId) throws Exception {
		getClientService().addAddress2Department(Long.valueOf(departmentId), Long.valueOf(addressId));
	}

	public void addAddress2Unit(int unitId, long addressId) throws Exception {
		getClientService().addAddress2Unit(Integer.valueOf(unitId), Long.valueOf(addressId));
	}

	public void updateUnit(UnitValue dao) throws Exception {
		getClientService().updateUnit(dao);
	}

	public void updatePerson(PersonValue personDao) throws Exception {
		getClientService().updatePerson(personDao);
	}

	public void updateDepartment(DepartmentValue departmentDao) throws Exception {
		getClientService().updateDepartment(departmentDao);
	}

	public void updateAddress(AddressValue addressData) throws Exception {
		getClientService().updateAddress(addressData);
	}

	public void updateTalktime(TalktimeValue ttData) throws Exception {
		getClientService().updateTalktime(ttData);
	}

	public void deleteUser(String userName) throws Exception {
		getClientService().deleteUser(userName);
	}

	public void removeUserFromUnit(UnitValue unit) throws Exception {
		getClientService().removeUserFromUnit(unit, user.getUser().getUserName());
	}

	public void removeUserFromUnit(UnitValue unit, String userNameId) throws Exception {
		getClientService().removeUserFromUnit(unit, userNameId);
	}

	public void addUser2Unit(UserValue user, UnitValue unit) throws Exception {
		getClientService().addUser2Unit(user, unit);
	}

	public int getUnit4ViewComponent(int viewComponentId) throws Exception {
		return getClientService().getUnit4ViewComponent(Integer.valueOf(viewComponentId));
	}

	// the returned Array will contain viewDocuments ordered by language
	// but it will put vd's in the languages contained in the array languages first
	public ViewDocumentValue[] getViewDocuments() throws Exception {
		ViewDocumentValue[] documents = getClientService().getViewDocuments();
		int indexFirst = 0;
		int indexSec = 0;
		String[] languages = new String[] {"de", "en", "fr", "it", "es", "ru"};
		ViewDocumentValue[] orderedDocuments = new ViewDocumentValue[documents.length];
		ViewDocumentValue[] firstDocuments = new ViewDocumentValue[documents.length];
		ViewDocumentValue[] secondDocuments = new ViewDocumentValue[documents.length];
		for (int i = 0; i < languages.length; i++) {
			for (int j = 0; j < documents.length; j++) {
				if (documents[j].getLanguage().equalsIgnoreCase(languages[i])) {
					firstDocuments[indexFirst++] = documents[j];
				}
			}
		}
		for (int i = 0; i < documents.length; i++) {
			boolean flag = true;
			for (int j = 0; j < languages.length; j++) {
				if (documents[i].getLanguage().equalsIgnoreCase(languages[j])) {
					flag = false;
				}
			}
			if (flag) {
				secondDocuments[indexSec++] = documents[i];
			}
		}
		if (firstDocuments != null) Arrays.sort(firstDocuments, new DocumentsComparer());
		if (secondDocuments != null) Arrays.sort(secondDocuments, new DocumentsComparer());
		for (int i = 0; i < indexFirst; i++) {
			orderedDocuments[i] = firstDocuments[i];
		}
		for (int i = 0; i < indexSec; i++) {
			orderedDocuments[i + indexFirst] = secondDocuments[i];
		}
		return orderedDocuments;
	}

	public ViewDocumentValue getViewDocument(String viewType, String language) throws Exception {
		return getClientService().getViewDocument4ViewTypeAndLanguage(viewType, language);
	}

	private class DocumentsComparer extends ViewDocumentValue implements Comparator<ViewDocumentValue> {
		private static final long serialVersionUID = 1L;

		public int compare(ViewDocumentValue firstDoc, ViewDocumentValue secondDoc) {
			if ((firstDoc == null) || (secondDoc == null)) {
				return 0;
			}
			String firstLanguage = rb.getString("panel.tree.language." + firstDoc.getLanguage());
			String secondLanguage = rb.getString("panel.tree.language." + secondDoc.getLanguage());
			int retVal = firstLanguage.toLowerCase().compareToIgnoreCase(secondLanguage);
			return retVal;
		}
	}

	public UserValue[] getAllUser() throws Exception {
		UserValue[] ud = getClientService().getAllUser();
		if (ud != null) Arrays.sort(ud, new UserDaoComparer());
		return ud;
	}

	/**
	 * 
	 * @author <a href="mailto:s.kulawik@juwimm.com">Sascha-Matthias Kulawik</a>
	 *         company Juwi|MacMillan Group Gmbh, Walsrode, Germany
	 * @version $Id$
	 */
	private class UserDaoComparer extends UserValue implements Comparator<UserValue> {
		private static final long serialVersionUID = 2497414650147720673L;

		public int compare(UserValue firstUser, UserValue secondUser) {
			int retVal = firstUser.getUserName().toLowerCase().compareTo(secondUser.getUserName().toLowerCase());
			if (retVal != 0) {
				return retVal;
			}
			if (firstUser.getFirstName() == null) return -1;
			if (secondUser.getFirstName() == null) return 1;
			return firstUser.getFirstName().toLowerCase().compareTo(secondUser.getFirstName().toLowerCase());
		}
	}

	private void replaceTaskStrings(TaskValue[] tdao) {
		for (int i = 0; i < tdao.length; i++) {
			if (tdao[i].getTaskType() == Constants.TASK_SYSTEMMESSAGE_ERROR || tdao[i].getTaskType() == Constants.TASK_SYSTEMMESSAGE_INFORMATION) {
				try {
					String comment = tdao[i].getComment();
					if (tdao[i].getTaskType() == Constants.TASK_SYSTEMMESSAGE_ERROR) {
						try {
							comment = rb.getString("SYSTEMMESSAGE_ERROR." + comment);
						} catch (Exception exe) {
							comment = Messages.getString("exception.UnknownError", comment);
						}
					} else {
						comment = rb.getString("SYSTEMMESSAGE_INFORMATION." + comment);
					}
					tdao[i].setComment(comment);
				} catch (Exception exe) {
				}
				tdao[i].setTaskType(Constants.TASK_MESSAGE);
			}
		}
	}

	public TaskValue[] getAllTasks() throws Exception {
		TaskValue[] tdao = getClientService().getAllTasks();
		if (tdao != null) {
			replaceTaskStrings(tdao);
			ArraySorter.sort(tdao, new TaskValueComparer());
		}
		return tdao;
	}

	/**
	 * 
	 * @author <a href="mailto:s.kulawik@juwimm.com">Sascha-Matthias Kulawik</a>
	 *         company Juwi|MacMillan Group Gmbh, Walsrode, Germany
	 * @version $Id$
	 */
	private class TaskValueComparer implements Comparer {
		public int compare(Object objA, Object objB) {
			TaskValue uda = (TaskValue) objA;
			TaskValue ud = (TaskValue) objB;
			return new Long(uda.getCreationDate()).compareTo(new Long(ud.getCreationDate()));
		}
	}

	public boolean isNewTask4User() throws Exception {
		return getClientService().isNewTask4User(user.getUser().getUserName());
	}

	public void reindexSite(Integer siteId) throws Exception {
		getClientService().reindexSite(siteId);
	}

	public void reindexContent(Integer vcId) throws Exception {
		getClientService().reindexPage(vcId);
	}

	public UserValue[] getAllUser(int groupId) throws Exception {
		return getClientService().getAllUser(Integer.valueOf(groupId));
	}

	public UserValue[] getAllUser(int groupId, int unitId) {
		UserValue[] uv = new UserValue[0];
		try {
			uv = getClientService().getAllUser4GroupAndUnit(Integer.valueOf(groupId), Integer.valueOf(unitId));
		} catch (Exception exe) {
			log.error(exe);
		}
		return uv;
	}

	public ViewDocumentValue createViewDocument(ViewDocumentValue vDao) throws Exception {
		return getClientService().createViewDocument(vDao);
	}

	public void setDefaultViewDocument(int viewDocumentId) throws Exception {
		if (viewDocumentId > 0) {
			getClientService().setDefaultViewDocument(Integer.valueOf(viewDocumentId));
		}
	}

	public ContentValue createContent(ContentValue cDao) throws Exception {
		return getClientService().createContent(cDao);
	}

	public void setUnit4ViewComponent(int unitId, ViewDocumentValue viewDocumentDao, int viewComponentId) throws Exception {
		getClientService().setUnit4ViewComponent(Integer.valueOf(unitId), viewDocumentDao, Integer.valueOf(viewComponentId));
	}

	public void removeViewDocument(int viewDocumentId) throws Exception {
		getClientService().removeViewDocument(Integer.valueOf(viewDocumentId));
	}

	@SuppressWarnings("unchecked")
	public boolean removeViewComponent(int intViewComponentId, String viewComponentName, byte onlineState) {
		boolean retVal = false;

		try {
			// CHECK IF THIS NODE CONTAINS SUBNODES
			ViewIdAndInfoTextValue[] str = getAllChildrenNamesWithUnit(intViewComponentId);
			String units = "";
			if (str != null && str.length > 0) {
				StringBuffer sb = new StringBuffer();
				for (int i = 0; i < str.length; i++) {
					sb.append(str[i].getInfoText().trim()).append("\n");
				}
				units = sb.toString();
			}
			if (!units.equalsIgnoreCase("")) {
				if (!isUserInRole(UserRights.SITE_ROOT)) {
					// dazwischen, damit sparen wir uns das zweite...
					String msg = Messages.getString("comm.removevc.containsunitsandcannotremove", units);
					JOptionPane.showMessageDialog(UIConstants.getMainFrame(), msg, rb.getString("dialog.title"), JOptionPane.ERROR_MESSAGE);
					return false;
				}
				units = Messages.getString("comm.removevc.header_units", units);
			}

			String refVcs = "";
			ViewComponentValue[] refDao = getViewComponentsWithReferenceToViewComponentId(intViewComponentId);
			if (refDao != null && refDao.length > 0) {
				StringBuffer sb = new StringBuffer();
				for (int j = 0; j < refDao.length; j++) {
					if (refDao[j].getViewType() == Constants.VIEW_TYPE_INTERNAL_LINK) {
						// InternalLink in the Tree
						sb.append(Messages.getString("comm.removevc.refvc.internallink", ("\"" + refDao[j].getDisplayLinkName() + "\""), ("\"" + refDao[j].getMetaData().trim() + "\""))).append("\n");
					} else if (refDao[j].getViewType() == Constants.VIEW_TYPE_SYMLINK) {
						// reference though Symlink in the Tree
						sb.append(Messages.getString("comm.removevc.refvc.symlink", ("\"" + refDao[j].getDisplayLinkName() + "\""), ("\"" + refDao[j].getMetaData().trim() + "\""))).append("\n");
					} else {
						// reference through links in the content
						sb.append(Messages.getString("comm.removevc.refvc.content", ("\"" + refDao[j].getDisplayLinkName() + "\""), ("\"" + refDao[j].getMetaData().trim() + "\""))).append("\n");
					}
				}
				refVcs = sb.toString();
			}

			if (!refVcs.equals("")) {
				refVcs = Messages.getString("comm.removevc.header_refvcs", refVcs);
			}

			String teaserText = "";
			boolean teaserReferenced = false;
			try {
				StringBuilder refTeaser = new StringBuilder("");
				XmlSearchValue[] xmlSearchValues = this.searchXml(getSiteId(), "//teaserRef");
				if (xmlSearchValues != null && xmlSearchValues.length > 0) {
					// herausfinden, ob es sich um DIESEN Teaser handelt
					String resultRootStartElement = "<searchTeaserResult>";
					String resultRootEndElement = "</searchTeaserResult>";
					for (int i = 0; i < xmlSearchValues.length; i++) {
						StringBuilder stringBuilder = new StringBuilder(xmlSearchValues[i].getContent());
						stringBuilder.insert(0, resultRootStartElement);
						stringBuilder.append(resultRootEndElement);
						Document doc = XercesHelper.string2Dom(stringBuilder.toString());
						Iterator<Element> teaserIterator = XercesHelper.findNodes(doc, "searchTeaserResult/teaserRef");
						while (teaserIterator.hasNext()) {
							Element element = teaserIterator.next();
							String viewComponentIdValue = element.getAttribute("viewComponentId");
							if (viewComponentIdValue != null && viewComponentIdValue.trim().length() > 0) {
								if (intViewComponentId == (new Integer(viewComponentIdValue)).intValue()) {
									teaserReferenced = true;
									refTeaser.append(this.getPathForViewComponentId(xmlSearchValues[i].getViewComponentId().intValue()) + "\n");
								}
							}
						}
					}
					if (teaserReferenced) {
						teaserText = Messages.getString("comm.removevc.header.teaser", refTeaser.toString());
					}
				}
			} catch (Exception exception) {
				log.error(exception.getMessage(), exception);
			}
			String msgHeader = "";
			if (onlineState == Constants.ONLINE_STATUS_UNDEF || onlineState == Constants.ONLINE_STATUS_OFFLINE) {
				msgHeader = rb.getString("comm.removevc.header_offline");
			} else {
				msgHeader = rb.getString("comm.removevc.header_online");
			}

			String msgstr = msgHeader + units + refVcs + teaserText;

			int i = JOptionPane.showConfirmDialog(UIConstants.getMainFrame(), msgstr, rb.getString("dialog.title"), JOptionPane.YES_NO_OPTION, JOptionPane.WARNING_MESSAGE);

			if (i == JOptionPane.YES_OPTION) {
				if (onlineState == Constants.ONLINE_STATUS_UNDEF || onlineState == Constants.ONLINE_STATUS_OFFLINE) {
					getClientService().removeViewComponent(Integer.valueOf(intViewComponentId), true);
					/*
					 * } else { // nothing at the moment, the code for here is
					 * currently in PanTree actionViewComponentPerformed
					 */
				}
				retVal = true;
			}
		} catch (Exception exe) {
			log.error("Error removing vc", exe);
		}

		if (retVal) {
			try {
				checkOutPages.remove(new Integer(getViewComponent(intViewComponentId).getReference()));
			} catch (Exception exe) {
			}
			UIConstants.setStatusInfo(rb.getString("comm.removevc.statusinfo"));
		}
		return retVal;
	}

	/**
	 * delete in case of multiselect
	 * @param entriesPath
	 * @return
	 */
	public ArrayList<TreePath> removeViewComponents(TreePath[] entriesPath) {
		boolean localVal;
		ArrayList<TreePath> deleted = new ArrayList<TreePath>();

		//		Arrays.<ViewComponentValue> sort(listofVC.toArray(arraysViewComponents), new Comparator<ViewComponentValue>() {
		//			public int compare(ViewComponentValue o1, ViewComponentValue o2) {
		//				if ((o1 != null) && (o2 != null)) { return (int) (Integer.valueOf(o2.getViewLevel()) - Integer.valueOf(o1.getViewLevel()));
		//
		//				}
		//				return 0;
		//			}
		//
		//		});
		try {
			for (TreePath treePath : entriesPath) {
				localVal = true;
				PageNode local = (PageNode) treePath.getLastPathComponent();
				byte onlineState = local.getOnline();
				int intViewComponentId = local.getViewComponent().getViewComponentId();
				try {
					ViewIdAndInfoTextValue[] str = getAllChildrenNamesWithUnit(intViewComponentId);
					String units = "";
					if (str != null && str.length > 0) {
						StringBuffer sb = new StringBuffer();
						for (int i = 0; i < str.length; i++) {
							sb.append(str[i].getInfoText().trim()).append("\n");
						}
						units = sb.toString();
					}
					if (!units.equalsIgnoreCase("")) {
						if (!isUserInRole(UserRights.SITE_ROOT)) {
							// dazwischen, damit sparen wir uns das zweite...
							String msg = Messages.getString("comm.removevc.containsunitsandcannotremove", units);
							JOptionPane.showMessageDialog(UIConstants.getMainFrame(), msg, rb.getString("dialog.title"), JOptionPane.ERROR_MESSAGE);
							localVal = false;
						}
						units = Messages.getString("comm.removevc.header_units", units);
					}
					if (localVal) {
						if (onlineState == Constants.ONLINE_STATUS_UNDEF || onlineState == Constants.ONLINE_STATUS_OFFLINE) {
							try {
								getClientService().removeViewComponent(Integer.valueOf(intViewComponentId), true);
							} catch (Exception e) {
							}
						}
					}
				} catch (Exception exe) {
					log.error("Error removing vc", exe);
				}
				if (localVal) {
					try {
						checkOutPages.remove(new Integer(getViewComponent(intViewComponentId).getReference()));
					} catch (Exception exe) {
					}
					UIConstants.setStatusInfo(rb.getString("comm.removevc.statusinfo"));
				}
				if (localVal) deleted.add(treePath);

			}
		} catch (Exception e) {
			log.error("Error at multiple delete");
		}
		return deleted;
	}

	public ViewComponentValue[] getViewComponentsWithReferenceToViewComponentId(int viewComponentId) {
		ViewComponentValue[] vcv = null;
		try {
			vcv = getClientService().getViewComponentsWithReferenceToViewComponentId(Integer.valueOf(viewComponentId));
		} catch (Exception exe) {
		}
		if (vcv == null) vcv = new ViewComponentValue[0];
		return vcv;
	}

	public ViewComponentValue[] getViewComponedntsThatReferenceThisTeaser(int viewComponentId) {
		ViewComponentValue[] vcv = null;
		// try {
		// FIXME
		// }
		return vcv;
	}

	public ViewComponentValue getViewComponent(int viewComponentId) throws Exception {
		return getClientService().getViewComponent(Integer.valueOf(viewComponentId));
	}

	public synchronized ViewComponentValue getViewComponent(int viewComponentId, int depth) throws Exception {
		return getClientService().getViewComponentWithDepth(Integer.valueOf(viewComponentId), depth);
	}

	public ViewComponentValue moveViewComponentUp(int viewComponentId) throws Exception {
		return getClientService().moveViewComponentUp(Integer.valueOf(viewComponentId));
	}

	public ViewComponentValue moveViewComponentDown(int viewComponentId) throws Exception {
		return getClientService().moveViewComponentDown(Integer.valueOf(viewComponentId));
	}

	public ViewComponentValue moveViewComponentLeft(int viewComponentId) throws Exception {
		// send mail on moving viewcomponent with unit
		if (!this.isUnitAndChangesParentUnitLeft(viewComponentId)) {
			log.error(user.getUser().getUserName() + ": moved viewcomponent " + viewComponentId + " left into another unit!");
		}
		return getClientService().moveViewComponentLeft(Integer.valueOf(viewComponentId));
	}

	public ViewComponentValue moveViewComponentRight(int viewComponentId) throws Exception {
		// send mail on moving viewcomponent with unit
		if (!this.isUnitAndChangesParentUnitRight(viewComponentId)) {
			log.error(user.getUser().getUserName() + ": moved viewcomponent " + viewComponentId + " right into another unit!");
		}
		return getClientService().moveViewComponentRight(Integer.valueOf(viewComponentId));
	}

	private boolean isUnitAndChangesParentUnitLeft(int viewComponentId) throws Exception {
		return getClientService().isUnitAndChangesParentUnitLeft(Integer.valueOf(viewComponentId));
	}

	private boolean isUnitAndChangesParentUnitRight(int viewComponentId) throws Exception {
		return getClientService().isUnitAndChangesParentUnitRight(Integer.valueOf(viewComponentId));
	}

	public void cancelApproval(int viewComponentId) throws Exception {
		getClientService().cancelApproval(Integer.valueOf(viewComponentId));
	}

	public void updateStatus4ViewComponent(ViewComponentValue vcDao) throws Exception {
		if (log.isDebugEnabled()) log.debug("updateStatus4ViewComponent");
		getClientService().updateStatus4ViewComponent(vcDao);
	}

	public int createTask(String receiverId, String receiverRole, int unitId, String comment, byte taskType) throws Exception {
		// Funzt das jetzt mit null-Pointer?
		/*
		 * int unit = -1; if(a_UnitId != null) { unit = a_UnitId.intValue(); }
		 */
		return getClientService().createTask(receiverId, receiverRole, Integer.valueOf(unitId), comment, taskType);
	}

	public void addViewComponentsToTask(int taskId, Integer[] vcIds) throws Exception {
		getClientService().addViewComponentsToTask(Integer.valueOf(taskId), vcIds);
	}

	public void removeViewComponentsFromTask(int taskId, Integer[] vcIds) throws Exception {
		getClientService().removeViewComponentsFromTask(Integer.valueOf(taskId), vcIds);
	}

	public ViewComponentValue getViewComponent4Unit(int unitId) throws Exception {
		return getClientService().getViewComponent4Unit(Integer.valueOf(unitId), Integer.valueOf(this.getViewDocumentId()));
	}

	public ViewComponentValue getViewComponent4Unit(int unitId, int depth) throws Exception {
		Integer viewComponentId = getClientService().getViewComponent4Unit(Integer.valueOf(unitId), Integer.valueOf(this.getViewDocumentId())).getViewComponentId();
		return getClientService().getViewComponentWithDepth(viewComponentId, depth);
	}

	// returns 	true if all parents have status ForDeploy or Deployed
	// 			false else
	public boolean isViewComponentPublishable(int viewComponentId) {
		return getClientService().isViewComponentPublishable(Integer.valueOf(viewComponentId));
	}

	public Integer[] getParents4ViewComponent(int viewComponentId) throws Exception {
		Integer[] vcdarr = null;
		try {
			vcdarr = getClientService().getParents4ViewComponent(viewComponentId);
			if (vcdarr == null) vcdarr = new Integer[0];
		} catch (Exception exe) {
			vcdarr = new Integer[0];
		}
		return vcdarr;
	}

	public ContentValue getContent(int contentId) throws Exception {
		ContentValue cdao = getClientService().getContent(Integer.valueOf(contentId));
		if (log.isDebugEnabled()) {
			log.debug("getContent() " + cdao.getHeading());
		}
		return cdao;
	}

	public void updateTemplate(int viewComponentId, String templateName) throws Exception {
		getClientService().updateTemplate(Integer.valueOf(viewComponentId), templateName);
		getDbHelper().setTemplateName(viewComponentId, templateName);
	}

	public String getContentTemplateName(int contentId) throws Exception {
		String templateName = getDbHelper().getTemplateName(contentId);
		if (templateName == null) {
			templateName = getClientService().getContentTemplateName(Integer.valueOf(contentId));
			getDbHelper().setTemplateName(contentId, templateName);
		}
		return templateName;
	}

	/**
	 * @param contentId
	 * @return ContentVersionValue[]
	 */
	public ContentVersionValue[] getAllContentVersionsForContent(int contentId) {
		// erst ID Liste ziehen, danach dann in DbHelper �berpr�fen, ob schon
		// vorhanden.
		try {
			ContentVersionValue[] cvd = null;
			/*
			 * if(getDbHelper().checkContentVersionsForContentAviable(contentId)) {
			 * int[] intContents =
			 * getContentSession().getAllContentVersionsId(contentId); cvd = new
			 * ContentVersionDao[intContents.length]; for(int i=0;i<intContents.length;i++) {
			 * cvd[i] = getDbHelper().getContentVersion(intContents[i]);
			 * if(cvd[i]==null) { cvd[i] =
			 * getContentSession().getContentVersion(intContents[i]);
			 * getDbHelper().setContentVersion(cvd[i].getContentVersionId(),
			 * contentId, cvd[i]); } } }else{
			 */
			cvd = getClientService().getAllContentVersions(Integer.valueOf(contentId));
			if (cvd == null) cvd = new ContentVersionValue[0];
			/*
			 * for(int i=0;i<cvd.length;i++)
			 * getDbHelper().setContentVersion(cvd[i].getContentVersionId(),
			 * contentId, cvd[i]); }
			 */
			return cvd;
		} catch (Exception exe) {
			log.error("Error getting all contentversions for content", exe);
			return null;
		}
	}

	public ContentVersionValue getContentVersion(int contentVersionId) {
		try {
			return getClientService().getContentVersion(Integer.valueOf(contentVersionId));
		} catch (Exception exe) {
			log.error("Error getting contentversion", exe);
			return null;
		}
	}

	public void removeAllOldContentVersions(int contentId) {
		try {
			getClientService().removeAllOldContentVersions(Integer.valueOf(contentId));
		} catch (Exception exe) {
			log.error("Error removing all old contentversions", exe);
		}
	}

	public void removeContentVersion(int contentVersionId) {
		try {
			getClientService().removeContentVersion(Integer.valueOf(contentVersionId));
		} catch (Exception exe) {
			log.error("Error removing content version", exe);
		}

	}

	public Vector getNotReferencedUnits(ViewDocumentValue viewDocumentDao) throws Exception {
		UnitValue[] ud = getClientService().getNotReferencedUnits(viewDocumentDao);
		return arrayToVector(ud);
	}

	public Integer[] getAllPictures4Unit(int unitId) throws Exception {
		Integer[] udd = getClientService().getAllPictures4Unit(Integer.valueOf(unitId));
		if (udd == null) udd = new Integer[0];
		return udd;
	}

	public Vector getAllDocuments4Unit(int unitId) throws Exception {
		Integer[] udd = getClientService().getAllDocuments4Unit(Integer.valueOf(unitId));
		return arrayToVector(udd);
	}

	public DocumentSlimValue[] getAllSlimDocumentValues(Integer unitId) throws Exception {
		DocumentSlimValue[] dsv = getClientService().getAllSlimDocumentValues(unitId);
		if (dsv == null) dsv = new DocumentSlimValue[0];
		return dsv;
	}

	public DocumentSlimValue[] getAllSlimDocumentValues4ViewComponent(Integer viewComponentId) throws Exception {
		DocumentSlimValue[] dsv = getClientService().getAllSlimDocumentValues4ViewComponent(viewComponentId);
		if (dsv == null) dsv = new DocumentSlimValue[0];
		return dsv;
	}

	public PictureSlimstValue[] getAllSlimPictureValues(Integer unitId) throws Exception {
		PictureSlimstValue[] psv = getClientService().getAllSlimPictures4Unit(unitId);
		if (psv == null) psv = new PictureSlimstValue[0];
		return psv;
	}

	public PictureSlimstValue[] getAllSlimPictureValues4ViewComponent(Integer viewComponentId) throws Exception {
		PictureSlimstValue[] psv = getClientService().getAllSlimPictures4View(viewComponentId);
		if (psv == null) psv = new PictureSlimstValue[0];
		return psv;
	}

	public ContentValue checkOut(int contentId, boolean force) throws UserException, AlreadyCheckedOutException {
		try {
			ContentValue cdao = getClientService().checkOut(Integer.valueOf(contentId), force);
			// will be only called, if the content was been successfully
			// checkedOut!
			checkOutPages.add(Integer.valueOf(contentId));
			return cdao;
		} catch (Exception exception) {
			if (exception != null && ((exception.getCause()).getCause() instanceof AlreadyCheckedOutException)) {
				throw (AlreadyCheckedOutException) exception.getCause().getCause();
			}
			if (exception.getCause() != null && exception.getCause() instanceof AlreadyCheckedOutException) {
				throw (AlreadyCheckedOutException) exception.getCause();
			}
			UserException ue = new UserException("Error checking out: " + exception.getMessage());
			log.error("Error checking out ", exception);
			throw ue;
		}
	}

	/**
	 * check-in or save
	 */
	public void checkIn(ContentValue contentDao) throws Exception {
		if (!contentDao.isCreateNewVersion()) {
			dbHelper.deleteContentVersions(contentDao.getContentId().intValue());
		}
		try {
			checkOutPages.remove(new Integer(contentDao.getContentId().intValue()));
		} catch (Exception exe) {
		}
		getClientService().checkIn(contentDao);
		if (log.isDebugEnabled()) {
			log.debug("contentDao " + contentDao.getHeading());
		}
	}

	/**
	 * cancel
	 */
	public void checkIn(int contentId) {
		try {
			getClientService().checkIn4ContentId(Integer.valueOf(contentId));
			checkOutPages.remove(new Integer(contentId));
		} catch (Exception exe) {
			log.error("Error checking in", exe);
		}
	}

	public void saveContent(int contentId, String content) throws Exception {
		getClientService().saveContent(Integer.valueOf(contentId), content);
	}

	public void removeDocument(int documentId) throws Exception {
		try {
			getClientService().removeDocument(Integer.valueOf(documentId));
		} catch (RemoteInvocationFailureException e) {
			throw (Exception) e.getCause();
		}
	}

	/**
	 * @deprecated Causes a OutOfMemory on the Serverside if called many times.
	 * @param documentId
	 * @return the name of this document
	 * @throws java.lang.Exception
	 */
	@Deprecated
	public String getDocumentName(int documentId) throws Exception {
		if (getDbHelper().checkDocumentName(documentId)) {
			String tempString = getClientService().getDocumentName(Integer.valueOf(documentId));
			getDbHelper().setDocumentName(documentId, tempString);
			return tempString;
		}
		return getDbHelper().getDocumentName(documentId);
	}

	public byte[] getPictureData(int pictureId) throws Exception {
		return getClientService().getPictureData(Integer.valueOf(pictureId));
	}

	public PictureSlimValue getPicture(int pictureId) throws Exception {
		return getClientService().getPicture(Integer.valueOf(pictureId));
	}

	public String getFileName(int pictureId) throws Exception {
		return getClientService().getPictureFileName(Integer.valueOf(pictureId));
	}

	public String getAltText(int pictureId) throws Exception {
		return getClientService().getPictureAltText(Integer.valueOf(pictureId));
	}

	public void updatePictureAltText(int pictureId, String altText) throws Exception {
		getClientService().updatePictureAltText(Integer.valueOf(pictureId), altText);
	}

	public boolean getPictureThumbnailPopup(Integer pictureId) {
		return getClientService().getPictureThumbnailPopup(pictureId);
	}

	public void updatePictureThumbnailPopup(boolean withThumbnailPopup, Integer pictureId) {
		getClientService().updatePictureThumbnailPopup(withThumbnailPopup, pictureId);
	}

	public void updatePictureData(int pictureId, byte[] picture, String mimeType, byte[] thumbnail) throws Exception {
		getClientService().updatePictureData(Integer.valueOf(pictureId), picture, mimeType, thumbnail);
	}

	public byte[] getThumbnail(int pictureId) throws Exception {
		String thumbPath = "ejbimage?typ=t&id=" + pictureId;
		File svgFile = new File(Constants.SVG_CACHE + this.encodeSvgImageName(thumbPath) + ".png");
		byte[] svgByte = null;
		if (svgFile.exists()) {
			svgByte = new byte[(int) svgFile.length()];
			try {
				new FileInputStream(svgFile).read(svgByte);
			} catch (Exception exe) {
				throw new UserException("First found image cant be found anymore at location " + svgFile.getAbsoluteFile());
			}
		} else {
			try {
				File cacheDir = new File(Constants.SVG_CACHE);
				cacheDir.mkdirs();

				// Read the response body.
				svgByte = getClientService().getPicture(pictureId).getThumbnail();
				// svgByte =
				// getContentService().getThumbnail(Integer.valueOf(pictureId));

				OutputStream out = new BufferedOutputStream(new FileOutputStream(svgFile));
				out.write(svgByte, 0, svgByte.length);
				out.flush();
				out.close();
			} catch (Exception e) {
				log.error("Image with Id " + pictureId + " has not been found");
			}
		}
		return svgByte;
	}

	/**
	 * Used in case of overwrite picture. Refreshed the cache for that image
	 * @param pictureId
	 */
	public void updateCachedImage(Integer pictureId) {
		String thumbPath = "ejbimage?typ=t&id=" + pictureId;
		File svgFile = new File(Constants.SVG_CACHE + this.encodeSvgImageName(thumbPath) + ".png");
		byte[] svgByte = null;
		try {
			File cacheDir = new File(Constants.SVG_CACHE);
			cacheDir.mkdirs();
			svgByte = getClientService().getPicture(pictureId).getThumbnail();
			OutputStream out = new BufferedOutputStream(new FileOutputStream(svgFile));
			out.write(svgByte, 0, svgByte.length);
			out.flush();
			out.close();
		} catch (IOException ioe) {
			log.warn("Image with Id " + pictureId + " has not been found - " + ioe.getStackTrace());
		}

	}

	public void removePicture(int pictureId) throws Exception {
		try {
			getClientService().removePicture(Integer.valueOf(pictureId));
		} catch (RemoteInvocationFailureException e) {
			throw (Exception) e.getCause();
		}
	}

	public int addPicture2Unit(int unitId, byte[] thumbnail, byte[] picture, String mimeType, String altText, String pictureName, String title) throws Exception {
		return getClientService().addPicture2Unit(Integer.valueOf(unitId), thumbnail, picture, mimeType, altText, pictureName, title);
	}

	public int addPicture2ViewComponent(int viewComponentId, byte[] thumbnail, byte[] picture, String mimeType, String altText, String pictureName, String title) throws Exception {
		return getClientService().addPicture2ViewComponent(Integer.valueOf(viewComponentId), thumbnail, picture, mimeType, altText, pictureName, title);
	}

	public int addPicture2Unit(int unitId, byte[] thumbnail, byte[] picture, byte[] preview, String mimeType, String altText, String pictureName, String title) throws Exception {
		return getClientService().addPictureWithPreview2Unit(Integer.valueOf(unitId), thumbnail, picture, preview, mimeType, altText, pictureName, title);
	}

	public void setPicture4Unit(int unitId, int pictureId) throws Exception {
		getClientService().setPicture4Unit(Integer.valueOf(unitId), Integer.valueOf(pictureId));
	}

	public void setPicture4Person(long personId, int pictureId) throws Exception {
		getClientService().setPicture4Person(Long.valueOf(personId), Integer.valueOf(pictureId));
	}

	public ViewComponentValue saveViewComponent(ViewComponentValue viewComponentValue) throws ViewComponentLinkNameAlreadyExisting, ViewComponentLinkNameIsEmptyException, ViewComponentNotFound, UserException {
		ViewComponentValue vcReturn = null;
		try {
			vcReturn = getClientService().saveViewComponent(viewComponentValue);
		} catch (Exception ue) {
			/*
			 * if (this.isExceptionOfType(ue,
			 * "ViewComponentLinkNameAlreadyExisting")) {
			 * ViewComponentLinkNameAlreadyExisting pd = new
			 * ViewComponentLinkNameAlreadyExisting(); throw pd; } else if
			 * (this.isExceptionOfType(ue, "ViewComponentNotFound")) {
			 * ViewComponentNotFound pd = new
			 * ViewComponentNotFound(); throw pd; } else if
			 * (this.isExceptionOfType(ue, "ViewComponentLinkNameIsEmpty")) {
			 * ViewComponentLinkNameIsEmptyException pd = new
			 * ViewComponentLinkNameIsEmptyException(); throw pd; }
			 */
			log.error("Error saving vc", ue);
			throw new UserException(ue);
		}
		return vcReturn;
	}

	public Object[] getPerson4Name(String firstName, String lastName) throws Exception {
		return getClientService().getPerson4Name(firstName, lastName);
	}

	/**
	 * Component department
	 * 
	 * @param name
	 * @throws Exception
	 */
	public long createDepartment(String name, int unitId) throws Exception {
		return getClientService().createDepartment(name, Integer.valueOf(unitId));
	}

	public long createPerson(PersonValue value) throws Exception {
		return getClientService().createPerson(value);
	}

	/**
	 * Component address
	 */
	public long createAddress(AddressValue value) throws Exception {
		return getClientService().createAddress(value);
	}

	/**
	 * Component get all departments
	 * 
	 * @return departments daos
	 * @throws Exception
	 */
	public Vector getDepartments4Name(String name) throws Exception {
		return arrayToVector(getClientService().getDepartments4Name(name));
	}

	/**
	 * Component get all departments
	 * 
	 * @return departments daos
	 * @throws Exception
	 */
	public DepartmentValue getDepartment(long departmentId) throws Exception {
		return getClientService().getDepartment(Long.valueOf(departmentId));
	}

	/**
	 * Component get all units
	 * 
	 * @return unit daos
	 * @throws Exception
	 */
	public Vector getUnits4Name(String name) throws Exception {
		return arrayToVector(getClientService().getUnits4Name(name));
	}

	public UnitValue[] getUnits4User(String userName) throws Exception {
		UnitValue[] units = getClientService().getUnits4User(userName);
		if (units == null) units = new UnitValue[0];
		return units;
	}

	/**
	 * Component get person
	 * 
	 * @param personId
	 * @return personValue
	 * @throws Exception
	 */
	public PersonValue getPerson(long personId) throws Exception {
		return getClientService().getPerson(Long.valueOf(personId));
	}

	public Vector getAllViewComponents4Status(int status) throws Exception {
		return arrayToVector(getClientService().getAllViewComponents4Status(Integer.valueOf(this.getViewDocumentId()), status));
	}

	/**
	 * 
	 * @param unitId
	 * @return Editions related to the given UnitID and the selected
	 *         ViewDocumentId
	 * @throws Exception
	 */
	public Vector getEditions(int unitId) throws Exception {
		EditionValue[] ud = getClientService().getEditions(Integer.valueOf(unitId), Integer.valueOf(this.getViewDocumentId()));
		return arrayToVector(ud);
	}

	//	/*
	//	 * Deploy
	//	 */
	//	public void createEdition(String comment, int rootViewComponentId, boolean deploy, boolean showMessage) throws UserException {
	//		try {
	//			getClientService().createEdition(comment, Integer.valueOf(rootViewComponentId), deploy, showMessage);
	//		} catch (Exception ue) {
	//			log.error("Error creating edition", ue);
	//			throw new UserException(ue);
	//		}
	//	}

	/*
	 * Deploy - new 
	 * 
	 * @param type - 0: fulldeploy, 1: unitdeploy, 2: pagedeploy, 3: rootdeploy
	 */
	public void createEdition(String comment, int rootViewComponentId, boolean deploy, boolean showMessage, int type) throws UserException {
		try {
			getClientService().createEdition(comment, Integer.valueOf(rootViewComponentId), deploy, showMessage, type);
		} catch (Exception ue) {
			log.error("Error creating edition", ue);
			throw new UserException(ue);
		}
	}

	public void createEditionWithoutDeploy(String comment, int rootViewComponentId) throws UserException {
		try {
			getClientService().createEditionWithoutDeploy(comment, rootViewComponentId);
		} catch (Exception ue) {
			log.error("Error creating edition", ue);
			throw new UserException(ue);
		}
	}

	public void removeEdition(int editionId) throws Exception {
		getClientService().removeEdition(Integer.valueOf(editionId));
	}

	public void setActiveEdition(int editionId) throws Exception {
		getClientService().setActiveEdition(Integer.valueOf(editionId), true);
	}

	/**
	 * 
	 * @param unitId
	 * @param status
	 * @return vector of ViewComponentValue
	 */
	public Vector getViewComponents4Status(int unitId, int status) throws Exception {
		ViewComponentValue[] vcv = getClientService().getAllViewComponents4UnitAndStatus(Integer.valueOf(unitId), Integer.valueOf(this.getViewDocumentId()), status);
		Vector<ViewComponentValue> v = new Vector<ViewComponentValue>(vcv.length);
		for (int i = 0; i < vcv.length; i++) {
			v.add(vcv[i]);
		}
		return v;
	}

	/**
	 * Returns all children of a ViewComponent, that contains a unit.
	 * 
	 * @param viewComponentId
	 *                The viewComponentId
	 * @return Array of Strings[][]
	 *         <ul>
	 *         <li>[i][0] contains ViewComponentId</li>
	 *         <li>[i][1] contains UnitId</li>
	 *         <li>[i][2] contains UnitName</li>
	 *         </ul>
	 */
	public ViewIdAndUnitIdValue[] getAllViewComponentsWithUnits(int viewComponentId) {
		ViewIdAndUnitIdValue[] retVal = null;
		try {
			retVal = getClientService().getAllViewComponentsWithUnits(Integer.valueOf(viewComponentId));
		} catch (Exception exe) {
			log.error("Error getting all vc with units", exe);
		}
		if (retVal == null) retVal = new ViewIdAndUnitIdValue[0];
		return retVal;
	}

	/**
	 * Component get address
	 * 
	 * @param addressId
	 * @return address data
	 * @throws Exception
	 */
	public AddressValue getAddress(long addressId) throws Exception {
		return getClientService().getAddress(Long.valueOf(addressId));
	}

	/**
	 * Component get Talktime
	 * 
	 * @param talktimeId
	 * @return talktime data
	 * @throws Exception
	 */
	public TalktimeValue getTalktime(long talktimeId) throws Exception {
		return getClientService().getTalktime(Long.valueOf(talktimeId));
	}

	public ViewComponentValue insertViewComponent(int childId, String reference, String displayLinkName, String linkDescription, int position) throws Exception {
		return getClientService().insertViewComponent(Integer.valueOf(childId), Integer.valueOf(this.getViewDocumentId()), reference, displayLinkName, linkDescription, position);
	}

	public ViewComponentValue addFirstViewComponent(int parentId, String reference, String displayLinkName, String linkDescription) throws Exception {
		return getClientService().addFirstViewComponent(Integer.valueOf(parentId), Integer.valueOf(this.getViewDocumentId()), reference, displayLinkName, linkDescription);
	}

	public void setTreeModel(CmsTreeModel treeModel) {
		this.treeModel = treeModel;
	}

	public void setStatus4ViewComponentId(int vcId, int status) {
		try {
			PageNode entry = treeModel.findEntry4Id((PageNode) treeModel.getRoot(), vcId);
			entry.setStatus(status);
		} catch (Exception ex) {
		}
	}

	public PageNode findEntry4Id(int id) {
		return treeModel.findEntry4Id((PageNode) treeModel.getRoot(), id);
	}

	public ViewIdAndInfoTextValue[] getAllChildrenNamesWithUnit(int viewComponentId) {
		ViewIdAndInfoTextValue[] retarr = null;
		try {
			retarr = getClientService().getAllChildrenNamesWithUnit(Integer.valueOf(viewComponentId));
		} catch (Exception exe) {
			log.error("Error getallchildrennameswithunit", exe);
		}
		return retarr;
	}

	public String[] getAnchors(int contentId) {
		String[] retArr = null;
		try {
			retArr = getClientService().getAnchors(Integer.valueOf(contentId));
		} catch (Exception exe) {
			log.error("Error getting anchors", exe);
		}
		return retArr;
	}

	public SiteValue createSite(SiteValue vo) {
		try {
			return getClientService().createSite(vo);
		} catch (Exception exe) {
			log.error("Error creating site", exe);
			return null;
		}
	}

	public void removeSite(int siteId) {
		try {
			getClientService().removeSite(Integer.valueOf(siteId));
		} catch (Exception exe) {
			log.error("Error removing site", exe);
		}
	}

	public void updateSite(SiteValue vo) {
		try {
			getClientService().updateSite(vo);
		} catch (Exception exe) {
			log.error("Error updating site", exe);
		}
	}

	public SiteValue[] getAllSites() {
		try {
			return getClientService().getAllSites();
		} catch (Exception exe) {
			log.error("Error get all sites", exe);
			return new SiteValue[0];
		}
	}

	public SiteValue[] getAllSites4CurrentUser() {
		try {
			return getClientService().getAllSites4CurrentUser();
		} catch (Exception exe) {
			log.error("Error get all sites for current user", exe);
			return new SiteValue[0];
		}
	}

	public UserValue[] getAllUsersForAllSites() {
		try {
			return getClientService().getAllUsersForAllSites();
		} catch (Exception exe) {
			log.error("Error getAllUsersForAllSites", exe);
			return new UserValue[0];
		}
	}

	public UserValue[] getAllUsers4OwnSites() {
		try {
			return getClientService().getAllUserOwnSites();
		} catch (Exception exe) {
			log.error("Error getAllUsers4OwnSites", exe);
			return new UserValue[0];
		}
	}

	public String[] getConnectedUsersForSite(int siteId) {
		try {
			return getClientService().getConnectedUsersForSite(Integer.valueOf(siteId));
		} catch (Exception exe) {
			log.error("Error getConnectedUsersForSite", exe);
			return new String[0];
		}
	}

	public void setConnectedUsersForSite(int siteId, String[] userIds) {
		try {
			getClientService().setConnectedUsersForSite(Integer.valueOf(siteId), userIds);
		} catch (Exception exe) {
			log.error("Error set connected users for site", exe);
		}
	}

	public void setSiteConfig(int siteId, String config) {
		try {
			getClientService().setSiteConfig(Integer.valueOf(siteId), config);
			if (siteId == activeSiteId) {
				user.setSiteConfigXML(config);
				Parameters.loadRolesetForActiveSite();
			}
		} catch (Exception exe) {
			log.error("Error set site config", exe);
		}
	}

	public String getSiteConfig(int siteId) {
		try {
			return getClientService().getSiteConfig(Integer.valueOf(siteId));
		} catch (Exception exe) {
			log.error("Error getsiteconfig", exe);
			return "";
		}
	}

	public HostValue createHost(String hostName) throws Exception {
		return (getClientService().createHost(hostName));
	}

	public HostValue[] getAllHosts() {
		HostValue[] hv = null;
		try {
			hv = getClientService().getAllHosts();
			if (hv == null) hv = new HostValue[0];
		} catch (Exception e) {
			log.error(e.getMessage());
		}
		return (hv);
	}

	public HostValue[] getHosts() {
		HostValue[] hv = null;
		try {
			hv = getClientService().getHosts();
			if (hv == null) hv = new HostValue[0];
		} catch (Exception e) {
			log.error(e.getMessage());
		}
		return hv;
	}

	public HostValue[] getAllUnassignedHosts() {
		HostValue[] hv = null;
		try {
			hv = getClientService().getAllUnassignedHosts();
			if (hv == null) hv = new HostValue[0];
		} catch (Exception e) {
			log.error(e.getMessage());
		}
		return (hv);
	}

	public HostValue[] getHostsForSite(int siteId) {
		HostValue[] hv = null;
		try {
			hv = getClientService().getHostsForSite(Integer.valueOf(siteId));
			if (hv == null) hv = new HostValue[0];
		} catch (Exception e) {
			log.error(e.getMessage());
		}
		return hv;
	}

	public void removeHost(String hostName) {
		try {
			getClientService().removeHost(hostName);
		} catch (Exception e) {
			log.error(e.getMessage());
		}
	}

	public SiteValue getSiteForName(String siteName) {
		SiteValue sv = null;
		try {
			sv = getClientService().getSiteForName(siteName);
		} catch (Exception e) {
			log.error(e.getMessage());
		}
		return (sv);
	}

	public void setSite(String hostName, String siteName) {
		try {
			getClientService().setSite(hostName, siteName);
		} catch (Exception e) {
			log.error(e.getMessage());
		}
	}

	public void setSite(String hostName, int siteId) {
		try {
			getClientService().setSite(hostName, Integer.valueOf(siteId));
		} catch (Exception e) {
			log.error(e.getMessage());
		}
	}

	public void setStartPage(String hostName, String vcId) {
		try {
			getClientService().setStartPage(hostName, vcId);
		} catch (Exception e) {
			log.error(e.getMessage());
		}
	}

	public String getSite(String hostName) {
		String result = "";
		try {
			result = getClientService().getSite(hostName);
		} catch (Exception e) {
			log.error(e.getMessage());
		}
		return (result);
	}

	public SiteValue getCurrentSite() {
		try {
			return getClientService().getCurrentSite(Integer.valueOf(this.getSiteId()));
		} catch (Exception e) {
			log.error("Error getting current site: " + e.getMessage(), e);
		}
		return null;
	}

	public String getStartPage(String hostName) {
		String result = "";
		try {
			result = getClientService().getStartPage(hostName);
		} catch (Exception e) {
			log.error(e.getMessage());
		}
		return (result);
	}

	public void removeSiteFromHost(String hostName) {
		try {
			getClientService().removeSiteFromHost(hostName);
		} catch (Exception e) {
			log.error(e.getMessage());
		}
	}

	public void removeStartpageFromHost(String hostName) {
		try {
			getClientService().removeStartpageFromHost(hostName);
		} catch (Exception e) {
			log.error(e.getMessage());
		}
	}

	public void setRedirectUrl(String hostName, String redirectUrl) {
		try {
			getClientService().setRedirectUrl(hostName, redirectUrl);
		} catch (Exception e) {
			log.error(e.getMessage());
		}
	}

	public void setRedirectHost(String hostName, String redirectHostName) {
		try {
			getClientService().setRedirectHost(hostName, redirectHostName);
		} catch (Exception e) {
			log.error(e.getMessage());
		}
	}

	public void setLiveServer(String hostName, boolean liveServer) {
		try {
			getClientService().setLiveServer(hostName, liveServer);
		} catch (Exception e) {
			log.error(e.getMessage());
		}
	}

	/* Safeguard start */

	public void addSimplePwRealmToVC(Integer simplePwRealmId, Integer viewComponentId, String neededRole, Integer loginPageId) throws Exception {
		if (loginPageId == null) loginPageId = new Integer(-1);
		getClientService().addSimplePwRealmToVC(simplePwRealmId, viewComponentId, neededRole, loginPageId);
	}

	public void editSimplePwRealm(RealmSimplePwValue simplePwRealmValue) {
		getClientService().editSimplePwRealm(simplePwRealmValue);
	}

	public void addSqlDbRealmToVC(Integer jdbcRealmId, Integer viewComponentId, String neededRole, Integer loginPageId) throws Exception {
		if (loginPageId == null) loginPageId = new Integer(-1);
		getClientService().addSqlDbRealmToVC(jdbcRealmId, viewComponentId, neededRole, loginPageId);
	}

	public int addSimpleRealmToSite(String realmName, int siteId, String loginPageId) {
		int pk = -1;
		try {
			pk = getClientService().addSimpleRealmToSite(realmName, Integer.valueOf(siteId), loginPageId);
		} catch (Exception e) {
			log.error(e.getMessage());
		}

		return pk;
	}

	public RealmSimplePwValue[] getSimplePwRealmsForUser(String user) {
		RealmSimplePwValue[] val = null;
		val = getClientService().getSimplePwRealmsForUser(user);
		if (val == null) {
			val = new RealmSimplePwValue[0];
		}
		return val;
	}

	public RealmSimplePwValue[] getSimplePwRealmsForSite(Integer siteId) {
		RealmSimplePwValue[] val = null;
		try {
			val = getClientService().getSimplePwRealmsForSite(siteId);
		} catch (RuntimeException rex) {
			log.error(rex.getMessage());
		}
		if (val == null) {
			val = new RealmSimplePwValue[0];
		}
		return val;
	}

	public RealmSimplePwValue[] getSimplePwRealms4CurrentUser() {
		RealmSimplePwValue[] val = null;
		try {
			val = getClientService().getSimplePwRealms4CurrentUser(new Integer(activeSiteId));
		} catch (RuntimeException rex) {
			log.error(rex.getMessage());
		}

		return val;

	}

	public RealmSimplePwUserValue[] getUserForSimplePwRealm(Integer simplePwRealmId) {
		RealmSimplePwUserValue[] val = null;
		try {
			val = getClientService().getUserForSimplePwRealm(simplePwRealmId);
		} catch (RuntimeException rex) {
			log.error(rex.getMessage());
		}
		if (val == null) {
			val = new RealmSimplePwUserValue[0];
		}
		return val;
	}

	public int addUserToSimpleRealm(Integer simplePwRealmId, RealmSimplePwUserValue simplePwRealmUserValue) {
		int pk = -1;

		try {
			pk = getClientService().addUserToSimpleRealm(simplePwRealmId, simplePwRealmUserValue);
		} catch (RuntimeException rex) {
			log.error(rex.getMessage());
		}

		return pk;
	}

	public boolean deleteSimplePwRealmUser(Integer simplePwRealmUserId) {
		boolean del = false;

		try {
			del = getClientService().deleteSimplePwRealmUser(simplePwRealmUserId);
		} catch (RuntimeException rex) {
			log.error(rex.getMessage());
		}

		return del;
	}

	public ActiveRealmValue getActiveRealm(Integer viewComponentId) {
		ActiveRealmValue val = new ActiveRealmValue(false, false, false, false, false, -1, "", "", null);

		try {
			val = getClientService().getActiveRealm(viewComponentId);
		} catch (RuntimeException rex) {
			log.error(rex.getMessage());
		}

		return val;
	}

	public Integer getFirstProtectedParentId(Integer viewComponentId) {
		try {
			return getClientService().getFirstProtectedParentId(viewComponentId);
		} catch (Exception e) {
			log.error(e.getMessage(), e);
		}
		return null;
	}

	public boolean deleteRealmAtVC(Integer viewComponentId) {
		boolean ret = false;

		try {
			ret = getClientService().deleteRealmAtVC(viewComponentId);
		} catch (RuntimeException rex) {
			log.error(rex.getMessage());
		}

		return ret;
	}

	public Integer addSqlDbRealmToSite(Integer siteId, RealmJdbcValue jdbcRealmValue) {
		Integer ret = new Integer(-1);

		try {
			ret = getClientService().addSqlDbRealmToSite(siteId, jdbcRealmValue);
		} catch (RuntimeException rex) {
			log.error(rex.getMessage());
		}

		return ret;
	}

	public RealmJdbcValue[] getSqlDbRealmsForSite(Integer siteId) {
		RealmJdbcValue[] val = null;

		try {
			val = getClientService().getSqlDbRealmsForSite(siteId);
		} catch (RuntimeException rex) {
			log.error(rex.getMessage());
		}

		return val;
	}

	public boolean deleteSqlDbRealm(Integer jdbcRealmId) {
		boolean del = false;

		try {
			del = getClientService().deleteSqlDbRealm(jdbcRealmId);
		} catch (RuntimeException rex) {
			log.error(rex.getMessage());
		}

		return del;
	}

	public void editSqlDbRealm(RealmJdbcValue jdbcRealmValue) {
		try {
			getClientService().editSqlDbRealm(jdbcRealmValue);
		} catch (Exception ex) {
			log.error(ex.getMessage());
		}
	}

	public Integer addLdapRealmToSite(Integer siteId, RealmLdapValue ldapRealmValue) {
		Integer pk = new Integer(-1);

		try {
			pk = getClientService().addLdapRealmToSite(siteId, ldapRealmValue);
		} catch (Exception ex) {
			log.error(ex.getMessage());
		}

		return pk;
	}

	public void deleteLdapRealm(Integer ldapRealmId) {
		try {
			getClientService().deleteLdapRealm(ldapRealmId);
		} catch (Exception ex) {
			log.error(ex.getMessage());
		}
	}

	public void editLdapRealm(RealmLdapValue ldapRealmValue) {
		try {
			getClientService().editLdapRealm(ldapRealmValue);
		} catch (Exception ex) {
			log.error(ex.getMessage());
		}
	}

	public RealmLdapValue[] getLdapRealmsForSite(Integer siteId) {
		RealmLdapValue[] val = null;

		try {
			val = getClientService().getLdapRealmsForSite(siteId);
		} catch (Exception ex) {
			log.error(ex.getMessage());
		}

		return val;
	}

	public void addLdapRealmToVC(Integer viewComponentId, Integer ldapRealmId, String neededRole, Integer loginPageId) {
		try {
			if (loginPageId == null) loginPageId = new Integer(-1);
			getClientService().addLdapRealmToVC(viewComponentId, ldapRealmId, neededRole, loginPageId);
		} catch (Exception ex) {
			log.error(ex.getMessage());
		}
	}

	public Integer addJaasRealmToSite(Integer siteId, RealmJaasValue jaasRealmValue) {
		Integer pk = new Integer(-1);

		try {
			pk = getClientService().addJaasRealmToSite(siteId, jaasRealmValue);
		} catch (Exception ex) {
			log.error(ex.getMessage(), ex);
		}

		return pk;
	}

	public void deleteJaasRealm(Integer jaasRealmId) {
		try {
			getClientService().deleteJaasRealm(jaasRealmId);
		} catch (Exception ex) {
			log.error(ex.getMessage());
		}
	}

	public void editJaasRealm(RealmJaasValue jaasRealmValue) {
		try {
			getClientService().editJaasRealm(jaasRealmValue);
		} catch (Exception ex) {
			log.error(ex.getMessage());
		}
	}

	public RealmJaasValue[] getJaasRealmsForSite(Integer siteId) {
		RealmJaasValue[] val = null;

		try {
			val = getClientService().getJaasRealmsForSite(siteId);
		} catch (Exception ex) {
			log.error(ex.getMessage());
		}

		return val;
	}

	public void addJaasRealmToVC(Integer viewComponentId, Integer jaasRealmId, String neededRole, Integer loginPageId) {
		try {
			if (loginPageId == null) loginPageId = new Integer(-1);
			getClientService().addJaasRealmToVC(viewComponentId, jaasRealmId, neededRole, loginPageId);
		} catch (Exception ex) {
			log.error(ex.getMessage());
		}
	}

	/* Safeguard end */

	public void addAccessRoleToVC(String accessRole, Integer viewComponentId, Integer loginPageId) throws Exception {
		getClientService().addAccessRoleToViewComponent(viewComponentId, accessRole, loginPageId);
	}
	/**
	 * 
	 */
	private class OkListener implements ActionListener {
		private final PanCheckInPages pan;
		private final JDialog dlg;

		public OkListener(PanCheckInPages pan, JDialog dlg) {
			this.pan = pan;
			this.dlg = dlg;
		}

		public void actionPerformed(ActionEvent e) {
			dlg.setVisible(false);
			ModifiedPagesTableModel model = pan.getModel();
			Iterator it = model.getDataVector().iterator();
			while (it.hasNext()) {
				Object[] elements = (Object[]) it.next();
				if (((Boolean) elements[0]).booleanValue()) {
					try {
						checkIn((ContentValue) elements[4]);
					} catch (Exception ex) {
						log.error(ex.getMessage());
					}
				} else {
					try {
						checkIn(((ContentValue) elements[4]).getContentId().intValue());
					} catch (Exception ex) {
						log.error(ex.getMessage());
					}
				}
			}
			try {
				if (log.isDebugEnabled()) {
					log.debug("Calling logout on server");
				}
				getClientService().logout();
			} catch (Exception exe) {
			}
			checkOutPages.clear();
			log.info("Goodbye!");
		}

	}

	public String getSvgUrl(String svgContent) throws UserException {
		File svgFile = new File(Constants.SVG_CACHE + this.encodeSvgImageName(svgContent) + ".png");
		if (svgFile.exists()) {
			return svgFile.getAbsolutePath();
		}
		try {
			fetchRemoteSvg(svgContent, svgFile);
		} catch (Exception e) {
			UserException ue = new UserException("Error fetching svg-url: " + e.getMessage());
			if (log.isDebugEnabled()) {
				log.debug("svgContent: " + svgContent);
				log.debug("svgFile: " + Constants.SVG_CACHE + this.encodeSvgImageName(svgContent) + ".png");
				log.debug("svgUrl: " + Constants.CMS_PATH_WYSIWYGIMAGE + svgContent);
			}
			log.error("Error fetching svg-url: ", e);
			throw ue;
		}
		return svgFile.getAbsolutePath();
	}

	private byte[] fetchRemoteSvg(String svgUrl, File svgFile) throws Exception {
		// create directory if it does not exist
		File cacheDir = new File(Constants.SVG_CACHE);
		cacheDir.mkdirs();
		// Read the response body.
		byte[] svgData = HttpClientWrapper.getInstance().getByte(Constants.CMS_PATH_WYSIWYGIMAGE + svgUrl);
		// svgData = this.getSizedThumbNail(svgData);

		OutputStream out = new BufferedOutputStream(new FileOutputStream(svgFile));
		out.write(svgData, 0, svgData.length);
		out.flush();
		out.close();

		return svgData;
	}

	public void clearSvgCache() {
		File cacheDir = new File(Constants.SVG_CACHE);
		this.delete(cacheDir);
	}

	/**
	 * Recursively deletes a directory (or file)
	 * 
	 * @param file
	 */
	private void delete(File file) {
		if (file.isDirectory()) {
			String[] list = file.list();
			for (int i = 0; i < list.length; i++) {
				delete(new File(file, list[i]));
			}
		}
		file.delete();
	}

	// Admin SiteGroups
	public SiteValue[] getAllNotAssignedSites() {
		try {
			return this.getClientService().getAllNotAssignedSites();
		} catch (Exception e) {
			log.error("Error getting all not assigned to a SiteGroup Sites: " + e.getMessage(), e);
		}
		return new SiteValue[0];
	}

	public SiteValue[] getSites4SiteGroup(SiteGroupValue siteGroupValue) {
		try {
			return this.getClientService().getSites4SiteGroup(siteGroupValue);
		} catch (Exception e) {
			log.error("Error getting all Sites for SiteGroup " + siteGroupValue.getSiteGroupId() + ": " + e.getMessage(), e);
		}
		return new SiteValue[0];
	}

	public SiteGroupValue[] getAllSiteGroups() {
		try {
			return this.getClientService().getAllSiteGroups();
		} catch (Exception e) {
			log.error("Error loading all SiteGroups: " + e.getMessage(), e);
		}
		return new SiteGroupValue[0];
	}

	public SiteGroupValue createSiteGroup(SiteGroupValue value) {
		try {
			return this.getClientService().createSiteGroup(value);
		} catch (Exception e) {
			log.error("Error creating SiteGroups: " + e.getMessage(), e);
			return null;
		}
	}

	public void updateSiteGroup(SiteGroupValue value) {
		try {
			this.getClientService().updateSiteGroup(value);
		} catch (Exception e) {
			log.error("Error updating SiteGroups: " + e.getMessage(), e);
		}
	}

	public void removeSiteGroup(SiteGroupValue value) {
		try {
			this.getClientService().removeSiteGroup(value);
		} catch (Exception e) {
			log.error("Error loading all SiteGroups: " + e.getMessage(), e);
		}
	}

	// -- Admin SiteGroups

	public SiteValue[] getAllRelatedSites(int siteId) {
		try {
			return this.getClientService().getAllRelatedSites(Integer.valueOf(siteId));
		} catch (Exception e) {
			log.error("Error getting all related Sites for Site " + siteId + ": " + e.getMessage(), e);
		}
		return null;
	}

	public ViewDocumentValue[] getAllViewDocuments4Site(int siteId) {
		try {
			return this.getClientService().getAllViewDocuments4Site(Integer.valueOf(siteId));
		} catch (Exception e) {
			log.error(e.getMessage(), e);
		}
		return null;
	}

	public ViewDocumentValue getViewDocument4ViewComponent(int viewComponentId) {
		try {
			return this.getClientService().getViewDocument4ViewComponent(Integer.valueOf(viewComponentId));
		} catch (Exception e) {
			log.error(e.getMessage(), e);
		}
		return null;
	}

	public UserUnitsGroupsValue[] getUserUnitsGroups4UnitAndGroup(int unitId, int groupId) throws Exception {
		return getClientService().getUserUnitsGroups4UnitAndGroup(Integer.valueOf(unitId), Integer.valueOf(groupId));
	}

	// TODO: replace by better algorithm with diffusion
	private int encodeSvgImageName(String svgImageName) {
		if (svgImageName != null && !"".equalsIgnoreCase(svgImageName)) return svgImageName.hashCode();

		return 0;
	}

	/**
	 * @see de.juwimm.cms.util.Communication#searchXmlByUnit(int,
	 *      java.lang.String, boolean)
	 */
	public XmlSearchValue[] searchXmlByUnit(int unitId, String xpathQuery, boolean parentSearch) throws Exception {
		try {
			XmlSearchValue[] value = getClientService().searchXmlByUnit(Integer.valueOf(unitId), Integer.valueOf(this.getViewDocumentId()), xpathQuery, parentSearch);
			if (value != null) return value;
			return new XmlSearchValue[0];
		} catch (Exception e) {
			log.warn("Error calling searchXmlByUnit - unitId " + unitId + " xPathQuery \"" + xpathQuery + "\" parentSearch " + parentSearch + ": " + e.getMessage(), e);
			return new XmlSearchValue[0];
		}
	}

	/** @see de.juwimm.cms.util.Communication#searchXml(int, java.lang.String) */
	public XmlSearchValue[] searchXml(int siteId, String xpathQuery) throws Exception {
		try {
			XmlSearchValue[] value = getClientService().searchXml(Integer.valueOf(siteId), xpathQuery);
			if (value != null) return value;
			return new XmlSearchValue[0];
		} catch (Exception e) {
			log.warn("Error calling searchXml - siteId " + siteId + " xPathQuery \"" + xpathQuery + "\": " + e.getMessage(), e);
			return new XmlSearchValue[0];
		}
	}

	public UnitValue[] getAllUnits4Site(Integer siteId) {
		try {
			return getClientService().getAllUnits4Site(siteId);
		} catch (Exception e) {
			log.error("Error getting all units for site " + siteId + ": " + e.getMessage(), e);
		}
		return new UnitValue[0];
	}

	public ShortLinkValue[] getAllShortLinks4Site(Integer siteId) {
		try {
			return getClientService().getAllShortLinks4Site(siteId);
		} catch (Exception e) {
			log.error("Error getting all shortLinks for site " + siteId + ": " + e.getMessage(), e);
		}
		return new ShortLinkValue[0];
	}

	public HostValue saveHost(HostValue hostValue) {
		try {
			hostValue = getClientService().saveHost(hostValue);
		} catch (Exception e) {
			log.error("Error saving host " + hostValue.getHostName() + ": " + e.getMessage(), e);
		}
		return hostValue;
	}

	public ShortLinkValue createShortLink(ShortLinkValue shortLinkValue) {
		try {
			shortLinkValue = getClientService().createShortLink(shortLinkValue);
		} catch (Exception e) {
			log.error("Error creating shortLinkValue " + shortLinkValue.getShortLink() + ": " + e.getMessage(), e);
		}
		return shortLinkValue;
	}

	public ShortLinkValue saveShortLink(ShortLinkValue shortLinkValue) {
		try {
			shortLinkValue = getClientService().saveShortLink(shortLinkValue);
		} catch (Exception e) {
			log.error("Error saving shortLinkValue " + shortLinkValue.getShortLink() + ": " + e.getMessage(), e);
		}
		return shortLinkValue;
	}

	public void deleteShortLink(Integer shortLinkId) {
		try {
			getClientService().deleteShortLink(shortLinkId);
		} catch (Exception e) {
			log.error("Error deleting shortLinkValue " + shortLinkId + ": " + e.getMessage(), e);
		}
	}

	public void exportXlsPersonData(File outputFile) {
		try {
			log.info("exportXlsPersonData");
			ClientServiceSpring cs = getClientService();
			InputStream is = cs.exportXlsPersonData();
			FileOutputStream fos = new FileOutputStream(outputFile);
			int read = 0;
			while ((read = is.read()) != -1) {
				fos.write(read);
			}
			fos.close();
		} catch (Exception exe) {
			log.error("Error exporting PersonData", exe);
		}
	}

	/**
	 * Adds a document in the database for a given unit or viewComponent.<br> If the parent site has a maximum allowed size parameter defined <b>(PARAM_MAX_DOCUMENT_SIZE)</b>, then the file being sent for upload is checked for allowed size. If the size is above the max size, the method throws @InvalidSizeException
	 * @param documentValue
	 * @return
	 */
	public DocumentValue addOrUpdateDocument(DocumentValue documentValue) throws InvalidSizeException{
		//maximum document size validation
		if(Parameters.getBooleanParameter(Parameters.PARAM_MAX_DOCUMENT_SIZE)){
			int maxAllowedSize=-1;
			try{
				maxAllowedSize=Integer.parseInt(Parameters.getStringParameter(Parameters.PARAM_MAX_DOCUMENT_SIZE));
			}catch (NumberFormatException e) {
				log.error("Could not load site parameter PARAM_MAX_DOCUMENT_SIZE (problem with int parsing)", e);
			}
			if(maxAllowedSize>0){
				long maxSizeBytes=maxAllowedSize*1024*1024;
				if(documentValue.getDocument().length>maxSizeBytes){
					throw new InvalidSizeException("The document is larger than the maximum allowed limit for upload");
				}
			}
		}
		try {
			return getClientService().addOrUpdateDocument(documentValue);
		} catch (Exception re) {
			log.error("Error importing document " + re.getMessage());
		} 
		return null;
	}

	/**
	 * Adds a document in the database for a given unit or viewComponent.<br> If the parent site has a maximum allowed size parameter defined <b>(PARAM_MAX_DOCUMENT_SIZE)</b>, then the file being sent for upload is checked for allowed size. If the size is above the max size, the method throws @InvalidSizeException
	 * @param file
	 * @param unitId
	 * @param viewComponentId
	 * @param fileName
	 * @param mimeType
	 * @param documentId
	 * @return
	 */
	public Integer addOrUpdateDocument(File file, Integer unitId, Integer viewComponentId, String fileName, String mimeType, Integer documentId, String password) throws InvalidSizeException{
		InputStream fis = null;
		//maximum document size validation
		if(Parameters.getBooleanParameter(Parameters.PARAM_MAX_DOCUMENT_SIZE)){
			int maxAllowedSize=-1;
			try{
				maxAllowedSize=Integer.parseInt(Parameters.getStringParameter(Parameters.PARAM_MAX_DOCUMENT_SIZE));
			}catch (NumberFormatException e) {
				log.error("Could not load site parameter PARAM_MAX_DOCUMENT_SIZE (problem with int parsing)", e);
			}
			if(maxAllowedSize>0){
				long maxSizeBytes=maxAllowedSize*1024*1024;
				if(file.length()>maxSizeBytes){
					throw new InvalidSizeException("The document is larger than the maximum allowed limit for upload");
				}
			}
		}
		try {
			fis = new BufferedInputStream(new FileInputStream(file));
			return getClientService().addOrUpdateDocument(fis, unitId, viewComponentId, fileName, mimeType, documentId, password);
		} catch (Exception re) {
			log.error("Error importing document " + re.getMessage());
		} finally {
			IOUtils.closeQuietly(fis);
		}
		return null;
	}

	public Integer addOrUpdateDocument(File file, Integer unitId, Integer viewComponentId, String fileName, String mimeType, Integer documentId) {
		return addOrUpdateDocument(file, unitId, viewComponentId, fileName, mimeType, documentId, null);
	}
	
	/**
	 * Adds a document in the database for a given unit.
	 * 
	 * @param file
	 * @param unitId
	 * @param fileName
	 * @param mimeType
	 * @param documentId
	 * @return
	 */
	public Integer addOrUpdateDocument(File file, Integer unitId, String fileName, String mimeType, Integer documentId) {
		return addOrUpdateDocument(file, unitId, null, fileName, mimeType, documentId, null);
	}

	public Integer addOrUpdateDocument(File file, Integer unitId, String fileName, String mimeType, Integer documentId, String password) {
		return addOrUpdateDocument(file, unitId, null, fileName, mimeType, documentId, password);
	}

	/*
	 * Export of an Edition
	 */
	public void createEditionForExport(File outputFile, int viewComponentIdWithUnit) throws Exception {
		log.info("createEditionForExport ");

		InputStream edition = null;
		if (viewComponentIdWithUnit <= 0) {
			edition = getClientService().exportEditionFull();
		} else {
			edition = getClientService().exportEditionUnit(Integer.valueOf(viewComponentIdWithUnit));
		}
		log.info("got answer... ");

		if (log.isDebugEnabled()) log.debug("tmpFile " + outputFile.getName());
		FileOutputStream fos = new FileOutputStream(outputFile);
		IOUtils.copyLarge(edition, fos);
		IOUtils.closeQuietly(edition);
		IOUtils.closeQuietly(fos);
		outputFile = null;
		System.gc();
	}

	public void importEditionFromImport(File file, Integer viewComponentId, boolean useNewIds) {
		InputStream fis = null;
		try {
			fis = new BufferedInputStream(new FileInputStream(file));
			getClientService().importEditionFromImport(fis, viewComponentId, useNewIds, -1);
		} catch (Exception re) {
			log.error("Error importing edition from import", re);
		} finally {
			IOUtils.closeQuietly(fis);
		}
	}

	public void setDefaultViewDocument(String viewType, String language, Integer siteId) {
		getClientService().setDefaultViewDocument(viewType, language, siteId);
	}

	public ViewDocumentValue getDefaultViewDocument4Site(Integer siteId) {
		return getClientService().getDefaultViewDocument4Site(siteId);
	}

	public ViewComponentValue[] getViewComponentChildren(Integer viewComponentId) {
		return getClientService().getViewComponentChildren(viewComponentId);
	}

	public Integer getPictureIdForUnitAndName(Integer unitId, String name) {
		return getClientService().getPictureIdForUnitAndName(unitId, name);
	}

	public Integer getPictureIdForViewComponentAndName(Integer viewComponentId, String name) {
		return getClientService().getPictureIdForViewComponentAndName(viewComponentId, name);
	}

	public Integer getDocumentIdForNameAndUnit(String name, Integer unitId) {
		return getClientService().getDocumentIdForNameAndUnit(name, unitId);
	}

	public Integer getDocumentIdForNameAndViewComponent(String name, Integer viewComponentId) {
		return getClientService().getDocumentIdForNameAndViewComponent(name, viewComponentId);
	}

	public ViewComponentValue[] moveViewComponentsUp(Integer[] viewComponentsId) {
		return getClientService().moveViewComponentsUp(viewComponentsId);
	}

	public ViewComponentValue[] moveViewComponentsDown(Integer[] viewComponentsId) {
		return getClientService().moveViewComponentsDown(viewComponentsId);
	}

	public ViewComponentValue[] moveViewComponentsLeft(Integer[] viewComponentsId) {
		return getClientService().moveViewComponentsLeft(viewComponentsId);
	}

	public ViewComponentValue[] moveViewComponentsRight(Integer[] viewComponentsId) {
		return getClientService().moveViewComponentsRight(viewComponentsId);
	}

	public HostValue createHost(HostValue hostValue) {
		return getClientService().createHost(hostValue);
	}

	public void updateHost(HostValue hostValue) {
		getClientService().updateHost(hostValue);
	}

	public Map getResources4Unit(Integer unitId, boolean documentsUsed, boolean documentsUnused, boolean picturesUsed, boolean picturesUnused) {
		return getClientService().getResources4Unit(unitId, documentsUsed, documentsUnused, picturesUsed, picturesUnused);
	}

	public Integer getViewComponentChildrenNumber(Integer[] viewComponentsIds) {
		return getClientService().getViewComponentChildrenNumber(viewComponentsIds);
	}

	public void removeResources(Integer[] pictureIds, Integer[] documentIds, boolean forceDeleteHistory) throws Exception {
		try {
			getClientService().removeResources(pictureIds, documentIds, forceDeleteHistory);
		} catch (RemoteInvocationFailureException ex) {
			throw (Exception) ex.getCause();
		}
	}

	public ViewComponentValue[] copyViewComponentToParent(Integer parentId, Integer[] viewComponentsIds, Integer position) {
		return getClientService().copyViewComponentsToParent(parentId, viewComponentsIds, position);
	}

	public String getViewComponentXmlComplete(Integer viewComponentId) {
		return getClientService().getViewComponentXmlComplete(viewComponentId, "local:8080", true);
	}

	public ViewComponentValue importViewComponentToParent(Integer parentId, InputStream xmlString, boolean withMedia, boolean withChildren, Integer unitId, boolean useNewIds, Integer siteId, Integer fulldeploy) {
		return getClientService().importViewComponent(parentId, xmlString, withMedia, withChildren, unitId, useNewIds, siteId, fulldeploy);
	}

	public void createViewComponentForExport(File output, int viewComponentId) throws Exception {
		InputStream viewComponentStream = null;
		/**set view component stream*/
		viewComponentStream = getClientService().exportViewComponent(viewComponentId);
		FileOutputStream fileOutput = new FileOutputStream(output);
		IOUtils.copyLarge(viewComponentStream, fileOutput);
		IOUtils.closeQuietly(viewComponentStream);
		IOUtils.closeQuietly(fileOutput);
		output = null;
		System.gc();
	}

	public ViewComponentValue makeContentOffline(ViewComponentValue viewComponent) {
		getClientService().makeContentOffline(viewComponent.getViewComponentId());
		viewComponent=getClientService().getViewComponent(viewComponent.getViewComponentId());
		return viewComponent;
	}

	public Integer getUnitForViewComponent(Integer viewComponentId) {
		return getClientService().getUnitForViewComponent(viewComponentId);
	}

	public Set getDocumentUsage(Integer documentId) {
		return getClientService().getDocumentUsage(documentId);
	}

	public byte[] getDocumentBytes(Integer documentId) {
		return getClientService().getDocumentBytes(documentId);
	}

	public Set getPictureUsage(Integer pictureId) {
		return getClientService().getPictureUsage(pictureId);
	}

	public void deleteSimplePwRealm(Integer simplePwRealmId) {
		try {
			getClientService().deleteSimplePwRealm(simplePwRealmId);
		} catch (Exception e) {
			if (log.isDebugEnabled()) log.error("Error at delete simplePwRealm");
		}
	}

	public String getUniqueUrlLinkName(Integer viewComponentId, Integer parentId, String urlLinkName) {
		return getClientService().checkForUniqueUrlLinkName(viewComponentId, parentId, urlLinkName);
	}

	public List<EditionValue> getEditions() {
		return getClientService().getEditions();
	}

	public UnitValue getRootUnit4Site(Integer siteId) {
		return getClientService().getRootUnit4Site(siteId);
	}

	/**
	 * Get the status of live deployment from the configuration xml for the site
	 * @return
	 */
	public boolean isLiveDeploymentActive() {
		boolean flag = true;
		//		SiteValue site = getCurrentSite();
		//		String config = site.getConfigXML();
		//		try {
		//			Document doc = XercesHelper.string2Dom(config);
		//			Iterator<Element> iterator = XercesHelper.findNodes(doc, "//liveDeploymentActive");
		//			while (iterator.hasNext()) {
		//				Element element = iterator.next();
		//				String liveDeployment = element.getTextContent();
		//				if (liveDeployment.equalsIgnoreCase("0")) {
		//					return false;
		//				}
		//			}
		//
		//		} catch (Exception e) {
		//			if (log.isDebugEnabled()) {
		//				log.debug("Error at converting string to xml for site cofiguration ", e);
		//			}
		//		}
		return flag;
	}

	public void setViewComponentOnline(Integer viewComponentId) {
		getClientService().setViewComponentOnline(viewComponentId);
	}

	public AccessRoleValue[] getAllAccessRoles() {
		return getClientService().getAllAccessRoles();
	}

	public List<ViewComponentValue> getViewComponentsForSearch(String searchValue) {
		return getClientService().getViewComponentsForSearch(this.getSelectedUnitId(), this.getViewDocumentId(), searchValue);
	}
	
	public DocumentSlimValue getDocumentSlimValue(Integer documentId){
		return getClientService().getDocumentSlimValue(documentId);
	}
	
	public DocumentSlimValue updateDocumentSlimValue(DocumentSlimValue documentSlimValue){
		return getClientService().updateDocument(documentSlimValue);
	}
	
	public SiteValue getSite(Integer siteId){
		return getClientService().getCurrentSite(siteId);
	}

}