ContentServiceSpringImpl.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.
 */
// license-header java merge-point
/**
 * This is only generated once! It will never be overwritten.
 * You can (and have to!) safely modify it by hand.
 */
package de.juwimm.cms.remote;

import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintStream;
import java.sql.Blob;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.Vector;
import java.util.Map.Entry;
import java.util.zip.GZIPOutputStream;

import javax.imageio.ImageIO;

import org.apache.commons.io.IOUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.Hibernate;
import org.springframework.beans.factory.annotation.Autowired;
import org.tizzit.util.DateConverter;
import org.tizzit.util.XercesHelper;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;

import de.juwimm.cms.authorization.model.UserHbm;
import de.juwimm.cms.beans.EditionCronService;
import de.juwimm.cms.common.Constants;
import de.juwimm.cms.common.Constants.LiveserverDeployStatus;
import de.juwimm.cms.common.Constants.ResourceUsageState;
import de.juwimm.cms.exceptions.AlreadyCheckedOutException;
import de.juwimm.cms.exceptions.UserException;
import de.juwimm.cms.model.ContentHbm;
import de.juwimm.cms.model.ContentVersionHbm;
import de.juwimm.cms.model.DocumentHbm;
import de.juwimm.cms.model.EditionHbm;
import de.juwimm.cms.model.LockHbm;
import de.juwimm.cms.model.PictureHbm;
import de.juwimm.cms.model.SiteHbm;
import de.juwimm.cms.model.UnitHbm;
import de.juwimm.cms.model.ViewComponentHbm;
import de.juwimm.cms.model.ViewDocumentHbm;
import de.juwimm.cms.remote.helper.AuthenticationHelper;
import de.juwimm.cms.search.beans.SearchengineDeleteService;
import de.juwimm.cms.util.SmallSiteConfigReader;
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.PictureSlimValue;
import de.juwimm.cms.vo.PictureSlimstValue;
import de.juwimm.cms.vo.UnitValue;
import de.juwimm.cms.vo.ViewComponentValue;
import de.juwimm.cms.vo.ViewDocumentValue;

/**
 * @see de.juwimm.cms.remote.ContentServiceSpring
 * @author <a href="mailto:carsten.schalm@juwimm.com">Carsten Schalm</a> company Juwi|MacMillan Group Gmbh, Walsrode, Germany
 * @version $Id$
 */
public class ContentServiceSpringImpl extends ContentServiceSpringBase {
	private static Log log = LogFactory.getLog(ContentServiceSpringImpl.class);
	public static final byte MAX_NO_OF_CONTENT_VERSIONS_PER_PAGE = 10;
	@Autowired
	EditionCronService editionCronService;
	@Autowired
	private SearchengineDeleteService searchengineDeleteService;


	public class DocumentCountWrapper {
		private HashMap<Integer, Integer> deltaDocuments = null;

		public DocumentCountWrapper(HashMap<Integer, Integer> startMap) {
			this.deltaDocuments = startMap;
		}

		public void addDocument(Integer docId, Integer docDelta) {
			Integer docCount = this.deltaDocuments.get(docId);
			if (docCount == null) docCount = new Integer(0);
			docCount = new Integer(docCount.intValue() + docDelta.intValue());
			this.deltaDocuments.put(docId, docCount);
		}

		public HashMap<Integer, Integer> getDeltaDocuments() {
			return deltaDocuments;
		}

	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#addPicture2Unit(java.lang.Integer, byte[], byte[], java.lang.String, java.lang.String, java.lang.String)
	 */
	@Override
	protected Integer handleAddPicture2Unit(Integer unitId, byte[] thumbnail, byte[] picture, String mimeType, String altText, String pictureName, String title) throws Exception {
		Integer height = null;
		Integer width = null;
		ByteArrayInputStream in = new ByteArrayInputStream(picture);
		try {
			BufferedImage img = ImageIO.read(in);
			height = img.getHeight();
			width = img.getWidth();
		} catch (IOException e) {

		}
		PictureHbm pictureHbm = PictureHbm.Factory.newInstance(thumbnail, picture, null, mimeType, null, altText, pictureName, height, width, false, title, null, null);
		UnitHbm unit = super.getUnitHbmDao().load(unitId);
		pictureHbm.setUnit(unit);
		pictureHbm = getPictureHbmDao().create(pictureHbm);
		return pictureHbm.getPictureId();
	}

	@Override
	protected Integer handleAddPicture2ViewComponent(Integer viewComponentId, byte[] thumbnail, byte[] picture, String mimeType, String altText, String pictureName, String title) throws Exception {
		Integer height = null;
		Integer width = null;
		ByteArrayInputStream in = new ByteArrayInputStream(picture);
		try {
			BufferedImage img = ImageIO.read(in);
			height = img.getHeight();
			width = img.getWidth();
		} catch (IOException e) {

		}
		PictureHbm pictureHbm = PictureHbm.Factory.newInstance(thumbnail, picture, null, mimeType, null, altText, pictureName, height, width, false, title, null, null);
		ViewComponentHbm viewComponent = super.getViewComponentHbmDao().load(viewComponentId);
		pictureHbm.setViewComponent(viewComponent);
		pictureHbm = getPictureHbmDao().create(pictureHbm);
		return pictureHbm.getPictureId();
	}

	@Override
	protected Integer handleAddPictureWithPreview2Unit(Integer unitId, byte[] thumbnail, byte[] picture, byte[] preview, String mimeType, String altText, String pictureName, String title) throws Exception {
		UnitHbm unit = super.getUnitHbmDao().load(unitId);
		PictureHbm pictureHbm = PictureHbm.Factory.newInstance(thumbnail, picture, preview, mimeType, null, altText, pictureName, null, null, false, title, null, null);
		pictureHbm.setUnit(unit);
		pictureHbm = getPictureHbmDao().create(pictureHbm);
		return pictureHbm.getPictureId();
	}

	/**
	 * Save content and create new contentVersion if heading or content is different from saved state
	 * @see de.juwimm.cms.remote.ContentServiceSpring#checkIn(de.juwimm.cms.vo.ContentValue)
	 */
	@Override
	protected void handleCheckIn(ContentValue contentValue) throws Exception {
		if (log.isDebugEnabled()) log.debug("begin checkIn ContentValue");
		try {
			ContentHbm content = super.getContentHbmDao().load(contentValue.getContentId());
			ContentVersionHbm latest = content.getLastContentVersion();
			boolean headingEqual = latest.getHeading() != null && latest.getHeading().equals(contentValue.getHeading());
			boolean textEqual = latest.getText() != null && latest.getText().equals(contentValue.getContentText());
			if (headingEqual && textEqual) {
				contentValue.setCreateNewVersion(false);
				//				this.updateDocumentUseCountLastVersion(latest.getText(), contentValue.getContentText());
			}
			contentValue.setVersion(latest.getVersion());

			LockHbm lock = latest.getLock();
			if (lock != null) {
				if (AuthenticationHelper.getUserName().equalsIgnoreCase(lock.getOwner().getUserId())) {
					if (contentValue.isCreateNewVersion()) {
						try {
							ContentVersionHbm newContentVersion = ContentVersionHbm.Factory.newInstance();
							newContentVersion.setCreateDate(System.currentTimeMillis());
							newContentVersion.setText(contentValue.getContentText());
							newContentVersion.setHeading(contentValue.getHeading());

							Integer version = Integer.parseInt(latest.getVersion());
							if (version == null) {
								version = 1;
							} else {
								version++;
							}
							newContentVersion.setVersion(version.toString());
							newContentVersion = super.getContentVersionHbmDao().create(newContentVersion);
							content.getContentVersions().add(newContentVersion);
						} catch (Exception exe) {
							throw new UserException(exe.getMessage());
						}
					} else {
						latest.setText(contentValue.getContentText());
						latest.setHeading(contentValue.getHeading());
						latest.setCreateDate(System.currentTimeMillis());
						latest.setCreator(AuthenticationHelper.getUserName());
					}
					// -- Indexing through No-Messaging
					if (contentValue.getContentText() != null) {
						content.setUpdateSearchIndex(true);
					}
					try {
						if (log.isDebugEnabled()) {
							log.debug("Removing Lock");
						}
						latest.setLock(null);
						getLockHbmDao().remove(lock);
					} catch (Exception exe) {
						throw new UserException(exe.getMessage());
					}
				} else {
					throw new UserException("checked out by another User: " + lock.getOwner().getUserId());
				}
			}
			if (log.isDebugEnabled()) log.debug("end checkIn()");
			//FIXME FIX THIS this.removeSpareContentVersions(contentValue.getContentId());
			/**
			 * Caused by: org.hibernate.ObjectDeletedException: deleted object would be re-saved by cascade (remove deleted object from associations): [de.juwimm.cms.model.ContentVersionHbmImpl#993]

			 */
		} catch (Exception e) {
			log.error("Error checking in: " + e.getMessage(), e);
			throw new UserException("Error checking in: " + e);
		}
		if (log.isDebugEnabled()) log.debug("end checkIn ContentValue");
	}

	/*
	private void updateDocumentCounters(ContentVersionHbm formerContentVersion, ContentVersionHbm newContentVersion) {
		if (newContentVersion.getVersion().equals("PUBLS")) {
			this.updateDocumentUseCountPublishVersion(null, newContentVersion.getText());
		} else {
			String oldLastContentText = (formerContentVersion == null || formerContentVersion.getText() == null) ? null : formerContentVersion.getText();
			this.updateDocumentUseCountLastVersion(oldLastContentText, newContentVersion.getText());
		}
	}
	*/

	/**
	 * Checkin only without creating a specialized version <br/>
	 * This is used for checking in all remaining pages while exiting the app<br/>
	 * Just remove any lock
	 * 
	 * @throws UserException
	 * 
	 * @see de.juwimm.cms.remote.ContentServiceSpring#checkIn4ContentId(java.lang.Integer)
	 */
	@Override
	protected void handleCheckIn4ContentId(Integer contentId) throws Exception {
		try {
			ContentHbm content = getContentHbmDao().load(contentId);
			ContentVersionHbm latest = content.getLastContentVersion();
			LockHbm lock = latest.getLock();
			if (lock != null) {
				latest.setLock(null);
				super.getLockHbmDao().remove(lock);
			}
		} catch (Exception e) {
			throw new UserException(e.getMessage());
		}
	}

	/**
	 * Lock this content-page exclusively for the current user
	 * @see de.juwimm.cms.remote.ContentServiceSpring#checkOut(java.lang.Integer, boolean)
	 */
	@Override
	protected ContentValue handleCheckOut(Integer contentId, boolean force) throws Exception {
		try {
			String caller = AuthenticationHelper.getUserName();
			ContentHbm content = getContentHbmDao().load(contentId);
			ContentVersionHbm contentVersion = content.getLastContentVersion();
			if (contentVersion == null) {
				//if does not have a content version
				contentVersion = ContentVersionHbm.Factory.newInstance();
				contentVersion.setVersion("1");
				contentVersion = getContentVersionHbmDao().create(contentVersion);
				content.getContentVersions().add(contentVersion);
			}
			LockHbm lock = content.getLastContentVersion().getLock();
			UserHbm user = getUserHbmDao().load(caller);
			if (lock == null || force || lock.getOwner() == null) {
				this.checkOut(content, force, user);
				return content.getDao();
			}
			String lockOwner = lock.getOwner().getUserId();
			if (caller.equals(lockOwner)) {
				if (log.isDebugEnabled()) log.debug("AlreadyCheckedOut by mysqlf - " + caller);
				throw new AlreadyCheckedOutException("");
			}
			if (log.isDebugEnabled()) {
				log.debug("AlreadyCheckedOut by - " + lockOwner);
			}
			throw new AlreadyCheckedOutException(lockOwner);
		} catch (AlreadyCheckedOutException acoe) {
			log.warn("Content with id " + contentId + " already checked out.", acoe);
			throw new AlreadyCheckedOutException(acoe.getMessage());
		} catch (Exception e) {
			log.error("Exception: " + e.getMessage(), e);
			throw new UserException(e.getMessage());
		}
	}

	private void checkOut(ContentHbm content, boolean force, UserHbm user) throws UserException, AlreadyCheckedOutException {
		if (log.isDebugEnabled()) log.debug("begin checkOut()");
		ContentVersionHbm latest = content.getLastContentVersion();
		LockHbm lock = latest.getLock();

		if (lock != null && lock.getOwner() != null) {
			if (!force) {
				if (user.getUserId().equals(lock.getOwner().getUserId())) {
					if (log.isDebugEnabled()) {
						log.debug("AlreadyCheckedOut by mysqlf - " + user.getUserId());
					}
					throw new AlreadyCheckedOutException("");
				}
				if (log.isDebugEnabled()) {
					log.debug("AlreadyCheckedOut by - " + lock.getOwner().getUserId());
				}
				throw new AlreadyCheckedOutException(lock.getOwner().getUserId());
			}
			try {
				super.getLockHbmDao().remove(lock);
				LockHbm newLock = LockHbm.Factory.newInstance();
				newLock.setOwner(user);
				newLock.setCreateDate(System.currentTimeMillis());
				newLock = getLockHbmDao().create(newLock);
				latest.setLock(newLock);
			} catch (Exception exe) {
				log.error("Error occured", exe);
			}
		} else {
			try {
				LockHbm newLock = LockHbm.Factory.newInstance();
				newLock.setOwner(user);
				newLock.setCreateDate(System.currentTimeMillis());
				newLock = getLockHbmDao().create(newLock);
				latest.setLock(newLock);
				if (log.isDebugEnabled()) {
					log.debug("Setting lock for checkout " + user.getUserId());
				}
			} catch (Exception exe) {
				log.error("Error occured", exe);
				throw new UserException(exe.getMessage());
			}
		}
		if (log.isDebugEnabled()) {
			log.debug("end checkOut()");
		}
	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#createContent(de.juwimm.cms.vo.ContentValue)
	 */
	@Override
	protected ContentValue handleCreateContent(ContentValue contentValue) throws Exception {
		ContentHbm contentHbm = getContentHbmDao().create(contentValue, AuthenticationHelper.getUserName());

		ContentVersionHbm cv = ContentVersionHbm.Factory.newInstance();
		cv.setVersion("1");
		cv.setText(contentValue.getContentText());
		cv.setHeading(contentValue.getHeading());
		cv = getContentVersionHbmDao().create(cv);
		contentHbm.getContentVersions().add(cv);
		return contentHbm.getDao();
	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#createEdition(java.lang.String, java.lang.Integer, boolean, boolean)
	 */
	@Override
	protected void handleCreateEdition(String commentText, Integer rootViewComponentId, boolean deploy, boolean succMessage, Integer deployType) throws Exception {
		if (log.isInfoEnabled()) log.info("Enqueue createEdition-Event " + AuthenticationHelper.getUserName() + " rootVCID " + rootViewComponentId);
		SiteHbm site = null;
		ViewComponentHbm vc = null;
		try {
			site = getUserHbmDao().load(AuthenticationHelper.getUserName()).getActiveSite();
			vc = getViewComponentHbmDao().load(rootViewComponentId);
		} catch (Exception exe) {
			log.error("Havent found either site or viewcomponent: (rootVc)" + rootViewComponentId + " " + exe.getMessage());
		}
		if (site != null) {
			if (log.isInfoEnabled()) log.info("Enqueue createEdition-Event for viewComponentId: " + rootViewComponentId);
			try {
				boolean needsDeploy = true;
				//TODO Edition
				// site, vc, vd, unit in one value - difference makes deploy type
				// type = 3 rootDeploy
				// type = 0 fulldeploy - value is site; 1 unitdeploy - value is unit, 2 pagedeploy - value is vc, rest for export...
				EditionHbm newEdition = getEditionHbmDao().create(AuthenticationHelper.getUserName(), commentText, rootViewComponentId, vc.getUnit4ViewComponent(), site.getDefaultViewDocument().getViewDocumentId(), site.getSiteId(), needsDeploy);
				newEdition.setDeployType(deployType);
				newEdition.setStartActionTimestamp(System.currentTimeMillis());
				newEdition.setDeployStatus(LiveserverDeployStatus.EditionCreated.name().getBytes());
				if (log.isDebugEnabled()) log.debug("Finished createEdtion Task on Queue");
			} catch (Exception e) {
				throw new UserException(e.getMessage());
			}
		} else {
			throw new UserException("User was not loggedin to the site he is willing to deploy. Deploy has been CANCELED.");
		}
	}

	@Override
	protected void handleCreateEditionWithoutDeploy(String commentText, Integer rootViewComponentId) throws Exception {
		if (log.isInfoEnabled()) log.info("Enqueue createEdition-Event " + AuthenticationHelper.getUserName() + " rootVCID " + rootViewComponentId);
		SiteHbm site = null;
		ViewComponentHbm vcParent = null;
		try { 
			site = getUserHbmDao().load(AuthenticationHelper.getUserName()).getActiveSite();
			vcParent = getViewComponentHbmDao().load(rootViewComponentId);
			Vector<ViewComponentValue> vec = new Vector<ViewComponentValue>();
			vec.addElement(vcParent.getDao());
			this.getAllViewComponentsChildren4Status(vcParent, vec, Constants.DEPLOY_STATUS_APPROVED, vcParent.getUnit4ViewComponent());
			this.getAllViewComponentsChildren4Status(vcParent, vec, Constants.DEPLOY_STATUS_DEPLOYED, vcParent.getUnit4ViewComponent());
			this.getAllViewComponentsChildren4Status(vcParent, vec, Constants.DEPLOY_STATUS_FOR_DEPLOY, vcParent.getUnit4ViewComponent());
			for (ViewComponentValue viewComponentValue : vec) {
				ViewComponentHbm vc = super.getViewComponentHbmDao().load(viewComponentValue.getViewComponentId());
				vc.setDeployCommand(viewComponentValue.getDeployCommand());
				vc.setOnline((byte)1);
				vc.setOnlineStart(viewComponentValue.getOnlineStart());
				vc.setStatus(Constants.DEPLOY_STATUS_DEPLOYED);
				vc.setLastModifiedDate(System.currentTimeMillis());
				vc.setUserLastModifiedDate(viewComponentValue.getUserLastModifiedDate());
				super.getViewComponentHbmDao().update(vc);
				if(vc.getViewType()==Constants.VIEW_TYPE_CONTENT || vc.getViewType()==Constants.VIEW_TYPE_UNIT){
					super.getContentHbmDao().setLatestContentVersionAsPublishVersion(new Integer(vc.getReference()));
				}
			}

		} catch (Exception exe) {
			log.error("Havent found either site or viewcomponent: (rootVc)" + rootViewComponentId + " " + exe.getMessage());
		}
//		if (site != null) {
//			if (log.isInfoEnabled()) log.info("Enqueue createEdition-Event for viewComponentId: " + rootViewComponentId);
//			try {
//				boolean needsDeploy = false;
//				//TODO Edition
//				// site, vc, vd, unit in one value - difference makes deploy type
//				// type = 3 rootDeploy
//				// type = 0 fulldeploy - value is site; 1 unitdeploy - value is unit, 2 pagedeploy - value is vc, rest for export...
//				EditionHbm newEdition = getEditionHbmDao().create(AuthenticationHelper.getUserName(), commentText, rootViewComponentId, vcParent.getUnit4ViewComponent(), site.getDefaultViewDocument().getViewDocumentId(), site.getSiteId(), needsDeploy);
//				newEdition.setDeployType(3);
//				newEdition.setStartActionTimestamp(System.currentTimeMillis());
////				newEdition.setDeployStatus(LiveserverDeployStatus.EditionCreated.name().getBytes());
//				if (log.isDebugEnabled()) log.debug("Finished createEdtion Task on Queue");
//			} catch (Exception e) {
//				throw new UserException(e.getMessage());
//			}
//		} else {
//			throw new UserException("User was not loggedin to the site he is willing to deploy. Deploy has been CANCELED.");
//		}
	}
	
	private void getAllViewComponentsChildren4Status(ViewComponentHbm view, Vector<ViewComponentValue> vec, int status, Integer unitId) throws Exception {
		if (view.getStatus() == status && !view.isRoot()) {
			ViewComponentValue viewDao = view.getDeployDao();
			viewDao.setPath2Unit(this.getParents4View(view));
			vec.addElement(viewDao);
		}
		Iterator it = view.getChildren().iterator();
		while (it.hasNext()) {
			ViewComponentHbm vcl = (ViewComponentHbm) it.next();
			if (vcl.getAssignedUnit() == null || vcl.getAssignedUnit().getUnitId().equals(unitId)) {
				this.getAllViewComponentsChildren4Status(vcl, vec, status, unitId);
			}
		}
	}
	
	private String getParents4View(ViewComponentHbm viewComponent) {
		try {
			if (viewComponent.getParent().isRoot()) {
				return "\\";
			}
		} catch (Exception ex) {
			return "\\";
		}
		Vector<ViewComponentHbm> vec = new Vector<ViewComponentHbm>();
		ViewComponentHbm parentView = viewComponent.getParent();

		while (parentView.getAssignedUnit() == null) {
			vec.addElement(parentView);
			parentView = parentView.getParent();
			try {
				if (parentView.isRoot()) {
					break;
				}
			} catch (Exception ex) {
				break;
			}
		}
		if (parentView.getAssignedUnit() != null) {
			vec.addElement(parentView);
		}
		StringBuffer sb = new StringBuffer("\\");

		for (int i = vec.size() - 1; i > -1; i--) {
			sb.append((vec.elementAt(i)).getUrlLinkName());
			if (i != 0) {
				sb.append("\\");
			}
		}
		sb.append("\\").append(viewComponent.getUrlLinkName());
		return sb.toString();
	}


	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#createPicture(byte[], byte[], java.lang.String, java.lang.String, java.lang.String)
	 */
	@Override
	protected Integer handleCreatePicture(byte[] thumbnail, byte[] picture, String mimeType, String altText, String pictureName, String title) throws Exception {
		PictureHbm pictureHbm = PictureHbm.Factory.newInstance(thumbnail, picture, null, mimeType, null, altText, pictureName, null, null, false, title, null, null);
		pictureHbm = getPictureHbmDao().create(pictureHbm);
		return pictureHbm.getPictureId();
	}

	/**
	 * Creates a new FULL-Edition for the active site and returns it as SOAP-Attachment.
	 * 
	 * @see de.juwimm.cms.remote.ContentServiceSpring#exportEditionFull()
	 */
	@Override
	protected InputStream handleExportEditionFull() throws Exception {
		try {
			if (log.isInfoEnabled()) log.info("createEditionForExport " + AuthenticationHelper.getUserName());
			File fle = File.createTempFile("edition_full_export", ".xml.gz");
			FileOutputStream fout = new FileOutputStream(fle);
			GZIPOutputStream gzoudt = new GZIPOutputStream(fout);
			PrintStream out = new PrintStream(gzoudt, true, "UTF-8");

			UserHbm invoker = getUserHbmDao().load(AuthenticationHelper.getUserName());
			SiteHbm site = invoker.getActiveSite();
			if (log.isDebugEnabled()) log.debug("Invoker is: " + invoker.getUserId() + " within Site " + site.getName());
			EditionHbm edition = getEditionHbmDao().create("INTERIMEDITION", null, null, true);
			if (log.isDebugEnabled()) log.debug("Dummy-Editon create");
			out.println("<edition>");
			if (log.isDebugEnabled()) log.debug("picturesToXmlRecursive");
			getEditionHbmDao().picturesToXmlRecursive(null, site.getSiteId(), out, edition);
			System.gc();
			if (log.isDebugEnabled()) log.debug("documentsToXmlRecursive");
			getEditionHbmDao().documentsToXmlRecursive(null, site.getSiteId(), out, true, edition);
			System.gc();
			if (log.isDebugEnabled()) log.debug("unitsToXmlRecursive");
			getEditionHbmDao().unitsToXmlRecursive(site.getSiteId(), out, edition);
			System.gc();
			if (log.isDebugEnabled()) log.debug("hostsToXmlRecursive");
			getEditionHbmDao().hostsToXmlRecursive(site.getSiteId(), out, edition);
			if (log.isDebugEnabled()) log.debug("viewdocumentsToXmlRecursive");
			getEditionHbmDao().viewdocumentsToXmlRecursive(site.getSiteId(), out, edition);
			if (log.isDebugEnabled()) log.debug("realmsToXmlRecursive");
			getEditionHbmDao().realmsToXmlRecursive(site.getSiteId(), out, edition);
			System.gc();
			if (log.isDebugEnabled()) log.debug("Creating ViewComponent Data");
			Iterator vdIt = getViewDocumentHbmDao().findAll(site.getSiteId()).iterator();
			while (vdIt.hasNext()) {
				ViewDocumentHbm vdl = (ViewDocumentHbm) vdIt.next();
				// vdl.getViewComponent().toXml(null, 0, true, false, 1, false, false, out);
				getViewComponentHbmDao().toXml(vdl.getViewComponent(), null, true, false, -1, false, false, out);

			}
			if (log.isDebugEnabled()) log.debug("Finished creating ViewComponent Data");
			out.println("</edition>");
			getEditionHbmDao().remove(edition);
			out.flush();
			out.close();
			out = null;
			return new FileInputStream(fle);
		} catch (Exception e) {
			throw new UserException(e.getMessage(), e);
		}
	}

	/**
	 * Creates a new Unit-Edition for the active site and returns it as SOAP-Attachment.
	 * 
	 * @throws UserException
	 * 
	 * @see de.juwimm.cms.remote.ContentServiceSpring#exportEditionUnit(java.lang.Integer)
	 */
	@Override
	protected InputStream handleExportEditionUnit(Integer rootViewComponentId) throws Exception {
		try {
			File fle = File.createTempFile("edition_unit_export", ".xml.gz");
			FileOutputStream fout = new FileOutputStream(fle);
			GZIPOutputStream gzoudt = new GZIPOutputStream(fout);
			PrintStream out = new PrintStream(gzoudt, true, "UTF-8");
			EditionHbm edition = super.getEditionHbmDao().create("RETURNEDITION", rootViewComponentId, out, true);
			super.getEditionHbmDao().remove(edition);
			out.flush();
			out.close();
			out = null;
			return new FileInputStream(fle);
		} catch (Exception e) {
			log.error("Could not export edition unit", e);
			throw new UserException(e.getMessage());
		}
	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#getAllContentVersions(java.lang.Integer)
	 */
	@Override
	protected ContentVersionValue[] handleGetAllContentVersions(Integer contentId) throws UserException {
		try {
			ContentHbm content = super.getContentHbmDao().load(contentId);
			Collection<ContentVersionHbm> coll = content.getContentVersions();
			Iterator<ContentVersionHbm> it = coll.iterator();
			TreeMap<Integer, ContentVersionHbm> tm = new TreeMap<Integer, ContentVersionHbm>();
			while (it.hasNext()) {
				ContentVersionHbm cvd = it.next();
				if (!cvd.getVersion().equals("PUBLS")) {
					tm.put(new Integer(cvd.getVersion()), cvd);
				}
			}

			it = tm.values().iterator();
			int siz = tm.values().size();
			ContentVersionValue[] arr = new ContentVersionValue[siz];
			for (int i = 0; i < siz; i++) {
				ContentVersionHbm cv = it.next();
				arr[i] = getContentVersionHbmDao().getDao(cv);
				if (i == (siz - 1)) {
					arr[i].setVersionComment(arr[i].getCreator() + " (" + DateConverter.getSql2String(new Date(arr[i].getCreateDate())) + ")");
				} else {
					arr[i].setVersionComment(arr[i].getVersion() + " - " + arr[i].getCreator() + " (" + DateConverter.getSql2String(new Date(arr[i].getCreateDate())) + ")");
				}
				arr[i].setText(null);
			}
			return arr;
		} catch (Exception e) {
			throw new UserException(e.getMessage());
		}
	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#getAllContentVersionsId(java.lang.Integer)
	 */
	@Override
	protected Integer[] handleGetAllContentVersionsId(Integer contentId) throws Exception {
		try {
			ContentHbm content = super.getContentHbmDao().load(contentId);
			Collection coll = content.getContentVersions();
			Iterator it = coll.iterator();
			TreeMap<Integer, ContentVersionHbm> tm = new TreeMap<Integer, ContentVersionHbm>();
			while (it.hasNext()) {
				ContentVersionHbm cvd = (ContentVersionHbm) it.next();
				if (!cvd.getVersion().equals("PUBLS")) {
					tm.put(new Integer(cvd.getVersion()), cvd);
				}
			}

			it = tm.values().iterator();
			int siz = tm.values().size();
			Integer[] arr = new Integer[siz];
			for (int i = 0; i < siz; i++) {
				arr[i] = ((ContentVersionHbm) it.next()).getContentVersionId();
			}
			return arr;
		} catch (Exception e) {
			throw new UserException(e.getMessage());
		}
	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#getAllDocuments4Unit(java.lang.Integer)
	 */
	@Override
	protected Integer[] handleGetAllDocuments4Unit(Integer unitId) throws Exception {
		try {
			Collection coll = super.getDocumentHbmDao().findAll(unitId);
			Iterator it = coll.iterator();
			int siz = coll.size();
			Integer[] itarr = new Integer[siz];
			for (int i = 0; i < siz; i++) {
				itarr[i] = ((de.juwimm.cms.model.DocumentHbm) it.next()).getDocumentId();
			}
			return itarr;
		} catch (Exception e) {
			throw new UserException(e.getMessage());
		}
	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#getAllPictures4Unit(java.lang.Integer)
	 */
	@SuppressWarnings("unchecked")
	@Override
	protected Integer[] handleGetAllPictures4Unit(Integer unitId) throws Exception {
		try {
			Collection<PictureHbm> coll = getPictureHbmDao().findAllPerUnit(unitId);
			int i = 0;
			Integer[] itarr = new Integer[coll.size()];
			for (PictureHbm pic : coll) {
				itarr[i++] = pic.getPictureId();
			}
			return itarr;
		} catch (Exception e) {
			throw new UserException(e.getMessage());
		}
	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#getAllSlimDocuments4Unit(java.lang.Integer)
	 */
	@Override
	protected DocumentSlimValue[] handleGetAllSlimDocuments4Unit(Integer unitId) throws Exception {
		DocumentSlimValue[] dvArr = null;
		try {
			Collection<DocumentHbm> coll = getDocumentHbmDao().findAll(unitId);
			dvArr = new DocumentSlimValue[coll.size()];
			int i = 0;
			for (DocumentHbm doc : coll) {
				dvArr[i++] = doc.getSlimValue();
			}
			return dvArr;
		} catch (Exception e) {
			throw new UserException(e.getMessage());
		}
	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#getAllSlimPictures4Unit(java.lang.Integer)
	 */
	@Override
	protected PictureSlimstValue[] handleGetAllSlimPictures4Unit(Integer unitId) throws Exception {
		PictureSlimstValue[] pvArr = null;
		try {
			Collection coll = super.getPictureHbmDao().findAllPerUnit(unitId);
			Iterator it = coll.iterator();
			int siz = coll.size();
			pvArr = new PictureSlimstValue[siz];
			for (int i = 0; i < siz; i++) {
				PictureHbm pic = (PictureHbm) it.next();
				pvArr[i] = pic.getSlimstValue();
			}
			return pvArr;
		} catch (Exception e) {
			throw new UserException(e.getMessage(), e);
		}
	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#getAnchors(java.lang.Integer)
	 */
	@Override
	protected String[] handleGetAnchors(Integer contentId) throws Exception {
		try {
			String[] anchArr = new String[0];
			ContentHbm content = super.getContentHbmDao().load(contentId);
			ContentVersionHbm cvl = content.getLastContentVersion();
			String contentText = cvl.getText();
			org.w3c.dom.Document doc = XercesHelper.string2Dom(contentText);
			Iterator nit = XercesHelper.findNodes(doc, "//anchor/a");
			Vector<String> vec = new Vector<String>();
			while (nit.hasNext()) {
				Element elm = (Element) nit.next();
				try {
					String anchor = elm.getAttribute("name");
					vec.add(anchor);
				} catch (Exception exe) {
				}
			}
			anchArr = vec.toArray(new String[0]);
			return anchArr;
		} catch (Exception e) {
			throw new UserException(e.getMessage());
		}
	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#getContent(java.lang.Integer)
	 */
	@Override
	protected ContentValue handleGetContent(Integer contentId) throws Exception {
		try {
			ContentHbm content = super.getContentHbmDao().load(contentId);
			return content.getDao();
		} catch (Exception e) {
			throw new UserException(e.getMessage());
		}
	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#getContentTemplateName(java.lang.Integer)
	 */
	@Override
	protected String handleGetContentTemplateName(Integer viewComponentId) throws Exception {
		ContentHbm content = null;
		ViewComponentHbm view = null;
		try {
			view = super.getViewComponentHbmDao().load(viewComponentId);
			if (view.getViewType() == Constants.VIEW_TYPE_INTERNAL_LINK || view.getViewType() == Constants.VIEW_TYPE_SYMLINK) {
				view = super.getViewComponentHbmDao().load(new Integer(view.getReference()));
				content = super.getContentHbmDao().load(new Integer(view.getReference()));
			} else {
				content = super.getContentHbmDao().load(new Integer(view.getReference()));
			}
			if (log.isDebugEnabled()) {
				log.debug("content: " + content + " vcId: " + viewComponentId);
				if (content != null) {
					log.debug("content: " + content.getTemplate());
				}
			}
			if (content != null) return content.getTemplate();
			return null;
		} catch (Exception e) {
			throw new UserException("Could not find referenced ContentVersion with Id: " + view.getReference() + " vcid:" + viewComponentId + "\n" + e.getMessage());
		}
	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#getContentVersion(java.lang.Integer)
	 */
	@Override
	protected ContentVersionValue handleGetContentVersion(Integer contentVersionId) throws Exception {
		try {
			ContentVersionHbm contentVersion = super.getContentVersionHbmDao().load(contentVersionId);
			return getContentVersionHbmDao().getDao(contentVersion);
		} catch (Exception e) {
			throw new UserException(e.getMessage());
		}
	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#getContentWithPUBLSVersion(java.lang.Integer)
	 */
	@Override
	protected ContentValue handleGetContentWithPUBLSVersion(Integer contentId) throws Exception {
		try {
			ContentHbm content = super.getContentHbmDao().load(contentId);
			return content.getDaoWithPUBLSVersion();
		} catch (Exception e) {
			throw new UserException(e.getMessage());
		}
	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#getDocument(java.lang.Integer)
	 */
	@Override
	protected byte[] handleGetDocument(Integer documentId) throws Exception {
		byte[] retArr = null;
		try {
			if (log.isDebugEnabled()) log.debug("LOOKING FOR DOCUMENT");
			//TODO: @TODO: Just a hack for the moment
			retArr = getDocumentHbmDao().getDocumentContent(documentId);
			if (log.isDebugEnabled()) {
				try {
					if (log.isDebugEnabled()) {
						log.debug("GOT THE DOCUMENT");

						log.debug("DOCUMENT SIZE " + retArr.length);
					}
				} catch (Exception inew) {
					if (log.isDebugEnabled()) log.debug(inew.getMessage());
				}
			}
		} catch (Exception e) {
			if (log.isDebugEnabled()) log.debug("CANNOT GET DOCUMENT " + e.getMessage());
			throw new UserException(e.getMessage());
		}
		return retArr;
	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#getDocumentName(java.lang.Integer)
	 */
	@Override
	protected String handleGetDocumentName(Integer documentId) throws Exception {
		try {
			DocumentHbm document = super.getDocumentHbmDao().load(documentId);
			return document.getDocumentName();
		} catch (Exception e) {
			throw new UserException(e.getMessage());
		}
	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#getEchoDAO(java.lang.String)
	 */
	@Override
	protected ContentValue handleGetEchoDAO(String echoString) throws Exception {
		try {
			System.out.println("GOT AN ECHO REQUEST " + echoString);
			ContentValue cdao = new ContentValue();
			cdao.setHeading(echoString);
			return cdao;
		} catch (Exception e) {
			throw new UserException(e.getMessage());
		}
	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#getEchoString(java.lang.String)
	 */
	@Override
	protected String handleGetEchoString(String echoString) throws Exception {
		try {
			ContentVersionHbm cvl = super.getContentVersionHbmDao().load(new Integer(999999));
			System.out.println("GOT AN ECHO REQUEST cvl.getHeading() " + cvl.getHeading());
			return cvl.getHeading();
		} catch (Exception e) {
			throw new UserException(e.getMessage());
		}
	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#getEditions(java.lang.Integer, java.lang.Integer)
	 */
	@Override
	protected EditionValue[] handleGetEditions(Integer unitId, Integer viewDocumentId) throws Exception {
		try {
			Collection<EditionHbm> editions = super.getEditionHbmDao().findByUnitAndViewDocument(unitId, viewDocumentId);
			EditionValue[] editionValues = new EditionValue[editions.size()];
			int i = 0;
			for (EditionHbm edition : editions) {
				editionValues[i++] = edition.getDao();
			}
			return editionValues;
		} catch (Exception e) {
			log.error("Could not get edition values", e);
			throw new UserException(e.getMessage());
		}
	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#getMimeType4Document(java.lang.Integer)
	 */
	@Override
	protected String handleGetMimeType4Document(Integer pictureId) throws Exception {
		DocumentHbm document = super.getDocumentHbmDao().load(pictureId);
		try {
			return document.getMimeType();
		} catch (Exception e) {
			log.error("Could not get mime type for document with id: " + pictureId, e);
			throw new UserException(e.getMessage());
		}
	}

	/**
	 * Get mime type for document
	 * 
	 * @see de.juwimm.cms.remote.ContentServiceSpring#getMimeType4Picture(java.lang.Integer)
	 */
	@Override
	protected String handleGetMimeType4Picture(Integer pictureId) throws Exception {
		PictureHbm picture = super.getPictureHbmDao().load(pictureId);
		try {
			return picture.getMimeType();
		} catch (Exception e) {
			log.error("Could not get mime type for picture with id: " + pictureId, e);
			throw new UserException(e.getMessage());
		}
	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#getNotReferencedUnits(de.juwimm.cms.vo.ViewDocumentValue)
	 */
	@Override
	protected UnitValue[] handleGetNotReferencedUnits(ViewDocumentValue viewDocument) throws Exception {
		if (log.isInfoEnabled()) log.info("starting getNotReferencedUnits for Site " + viewDocument.getSiteId() + " and Language " + viewDocument.getLanguage());
		try {
			Collection coll = super.getViewComponentHbmDao().findAllWithUnit(viewDocument.getViewDocumentId());
			Collection u = super.getUnitHbmDao().findAll(viewDocument.getSiteId());
			Vector<Integer> units = new Vector<Integer>();

			Iterator itUnits = u.iterator();
			while (itUnits.hasNext()) {
				UnitHbm unit = (UnitHbm) itUnits.next();
				units.add(unit.getUnitId());
			}

			Iterator it = coll.iterator();
			while (it.hasNext()) {
				ViewComponentHbm vcl = (ViewComponentHbm) it.next();
				try {
					units.remove(vcl.getAssignedUnit().getUnitId());
				} catch (Exception e) {
					if (log.isDebugEnabled()) {
						log.debug("Could not remove assigned unit: " + e.getMessage());
					}
				}
			}

			UnitValue[] unitdaos = new UnitValue[units.size()];
			it = units.iterator();
			int i = 0;
			while (it.hasNext()) {
				Integer unitId = (Integer) it.next();
				UnitHbm ul = super.getUnitHbmDao().load(unitId);
				unitdaos[i++] = getUnitHbmDao().getDao(ul);
			}
			if (log.isDebugEnabled()) log.debug("end getNotReferencedUnits for Site " + viewDocument.getSiteId() + " and Language " + viewDocument.getLanguage());
			return unitdaos;
		} catch (Exception e) {
			log.warn("Error getNotReferencedUnits for Site " + viewDocument.getSiteId() + " and Language " + viewDocument.getLanguage() + ": " + e.getMessage(), e);
			throw new UserException(e.getMessage());
		}
	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#getPicture(java.lang.Integer)
	 */
	@Override
	protected PictureSlimValue handleGetPicture(Integer pictureId) throws Exception {
		PictureHbm picture = super.getPictureHbmDao().load(pictureId);
		return picture.getSlimValue();
	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#getPictureAltText(java.lang.Integer)
	 */
	@Override
	protected String handleGetPictureAltText(Integer pictureId) throws Exception {
		PictureHbm picture = super.getPictureHbmDao().load(pictureId);
		return picture.getAltText();
	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#getPictureData(java.lang.Integer)
	 */
	@Override
	protected byte[] handleGetPictureData(Integer pictureId) throws Exception {
		PictureHbm picture = super.getPictureHbmDao().load(pictureId);
		try {
			return picture.getPicture();
		} catch (Exception e) {
			if (log.isErrorEnabled()) {
				log.error("Could not get data for picture with id: " + pictureId, e);
			}
			throw new UserException(e.getMessage());
		}

	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#getPictureFileName(java.lang.Integer)
	 */
	@Override
	protected String handleGetPictureFileName(Integer pictureId) throws Exception {
		PictureHbm picture = super.getPictureHbmDao().load(pictureId);
		return picture.getPictureName();
	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#getThumbnail(java.lang.Integer)
	 */
	@Override
	protected byte[] handleGetThumbnail(Integer pictureId) throws Exception {
		PictureHbm picture = super.getPictureHbmDao().load(pictureId);
		if (picture != null) {
			return picture.getThumbnail();
		}
		return new byte[0];
	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#getTimestamp4Document(java.lang.Integer)
	 */
	@Override
	protected Long handleGetTimestamp4Document(Integer pictureId) throws Exception {
		DocumentHbm document = super.getDocumentHbmDao().load(pictureId);
		try {
			return document.getTimeStamp();
		} catch (Exception e) {
			log.error("Could not get timestamp for document with id: " + pictureId, e);
			throw new UserException(e.getMessage());
		}
	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#getTimestamp4Picture(java.lang.Integer)
	 */
	@Override
	protected Long handleGetTimestamp4Picture(Integer pictureId) throws Exception {
		PictureHbm picture = super.getPictureHbmDao().load(pictureId);
		try {
			return picture.getTimeStamp();
		} catch (Exception e) {
			log.error("Could not get timestamp for picture with id: " + pictureId, e);
			throw new UserException(e.getMessage());
		}
	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#importDocument(java.lang.Integer, java.lang.String, java.lang.String, java.io.InputStream)
	 */
	@Override
	protected Integer handleAddOrUpdateDocument(Integer unitId, Integer viewComponentId, String documentName, String mimeType, InputStream documentData, Integer documentId, String password) throws Exception {
		try {
			if (log.isDebugEnabled()) log.debug("addOrUpdateDocument for user " + AuthenticationHelper.getUserName());

			UnitHbm unit = null;
			ViewComponentHbm viewComponent = null;
			if (viewComponentId != null) {
				viewComponent = getViewComponentHbmDao().load(viewComponentId);
			}
			if (unitId != null) {
				unit = getUnitHbmDao().load(unitId);
			}
			DocumentHbm doc = null;

			File tmp = this.storeTempFile(documentData, documentName);
			
			//check if we have configured a max allowed size for this site in site configuration
			int maxSize = -1;
			UnitHbm configUnit=null;
			try {
				if(viewComponent!=null){
					configUnit=viewComponent.getViewComponentUnit().getAssignedUnit();
				}
				SmallSiteConfigReader cfg = new SmallSiteConfigReader(configUnit!=null?configUnit.getSite():unit.getSite());
				if (cfg != null) {
					boolean hasMaxDocSize = cfg.getConfigElementValue("parameters/maxDocumentSize_1").equalsIgnoreCase("true");
					if(hasMaxDocSize){
						maxSize=Integer.parseInt(cfg.getConfigElementValue("parameters/maxDocumentSize_2"));
					}
				}
			} catch (Exception ex) {
				log.warn("could not read siteConfig of site: " + (configUnit!=null?configUnit.getSite().getName():"site unavailable"), ex);
			}
			if (maxSize > 0) {
				long maxByteSize = maxSize * 1024 * 1024;
				if (tmp.length() > maxByteSize) {
					throw new UserException("Invalid document size. Max size is defined in site config to the value of " + maxSize + " MB.");
				}
			}
			// finished checking document size
			
			FileInputStream in = new FileInputStream(tmp);
			Blob b = Hibernate.createBlob(in);

			if (documentId == null) {
				doc = DocumentHbm.Factory.newInstance();
				doc.setDocumentName(documentName);
				doc.setMimeType(mimeType);
				doc.setUnit(unit);
				doc.setViewComponent(viewComponent);
				doc.setPassword(password);
				doc = getDocumentHbmDao().create(doc);
				doc.setDocument(b);
			} else {
				doc = getDocumentHbmDao().load(documentId);
				doc.setTimeStamp(System.currentTimeMillis());
				doc.setDocumentName(documentName);
				doc.setMimeType(mimeType);
				doc.setPassword(password);
				getDocumentHbmDao().setDocumentContent(doc.getDocumentId(), IOUtils.toByteArray(in));
			}
			return doc.getDocumentId();
		} catch (Exception e) {
			throw new UserException(e.getMessage(),e);
		}
	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#addOrUpdateDocument(DocumentValue)
	 */
	@Override
	protected DocumentValue handleAddOrUpdateDocument(DocumentValue documentValue) throws Exception {
		try {
			if (log.isDebugEnabled()) log.debug("addOrUpdateDocument for user " + AuthenticationHelper.getUserName());

			UnitHbm unit = null;
			ViewComponentHbm viewComponent = null;
			if (documentValue.getViewDocumentId() != null) {
				viewComponent = getViewComponentHbmDao().load(documentValue.getViewDocumentId());
			}
			if (documentValue.getUnitId() != null) {
				unit = getUnitHbmDao().load(documentValue.getUnitId());
			}
			DocumentHbm doc = null;

			//check if we have configured a max allowed size for this site in site configuration
			int maxSize = -1;
			UnitHbm configUnit=null;
			try {
				if(viewComponent!=null){
					configUnit=viewComponent.getViewComponentUnit().getAssignedUnit();
				}
				SmallSiteConfigReader cfg = new SmallSiteConfigReader(configUnit!=null?configUnit.getSite():unit.getSite());
				if (cfg != null) {
					boolean hasMaxDocSize = cfg.getConfigElementValue("parameters/maxDocumentSize_1").equalsIgnoreCase("true");
					if(hasMaxDocSize){
						maxSize=Integer.parseInt(cfg.getConfigElementValue("parameters/maxDocumentSize_2"));
					}
				}
			} catch (Exception ex) {
				log.warn("could not read siteConfig of site: " + (configUnit!=null?configUnit.getSite().getName():"site unavailable"), ex);
			}
			if (maxSize > 0) {
				long maxByteSize = maxSize * 1024 * 1024;
				if (documentValue.getDocument().length > maxByteSize) {
					throw new UserException("Invalid document size. Max size is defined in site config to the value of " + maxSize + " MB.");
				}
			}
			// finished checking document size
			
//			FileInputStream in = new FileInputStream(tmp);
			Blob b = Hibernate.createBlob(documentValue.getDocument());

			if (documentValue.getDocumentId() != null) {
				doc = getDocumentHbmDao().load(documentValue.getDocumentId());
				doc.setTimeStamp(System.currentTimeMillis());
			} else {
				doc = DocumentHbm.Factory.newInstance();
				doc.setTimeStamp(System.currentTimeMillis());
			}
			doc.setDocumentName(documentValue.getDocumentName());
			doc.setMimeType(documentValue.getMimeType());
			doc.setUnit(unit);
			doc.setViewComponent(viewComponent);
			doc.setPassword(documentValue.getPassword());
			doc.setDocument(b);
			doc.setLabel(documentValue.getLabel());
			doc.setPassword(documentValue.getPassword());
			doc.setDescription(documentValue.getDescription());
			doc.setSearchable(documentValue.isSearchable());
			doc.setAuthor(documentValue.getAuthor());
			doc.setCategory(documentValue.getCategory());
			if (documentValue.getDocumentId() != null) {
				getDocumentHbmDao().update(doc);
			} else {
				getDocumentHbmDao().create(doc);
			}
			return doc.getValue();
		} catch (Exception e) {
			throw new UserException(e.getMessage(),e);
		}
	}

	/**
	 * Imports an Edition though an <b>.xml.gz </b> Upload. <br>
	 * It will be expected as a SOAP Attachment.
	 * 
	 * @see de.juwimm.cms.remote.ContentServiceSpring#importEdition(java.lang.Integer, java.io.InputStream)
	 */
	@Override
	protected void handleImportEdition(Integer viewComponentId, InputStream in, boolean useNewIds, Integer workServerEditionId) throws Exception {
		try {
			if (log.isInfoEnabled()) log.info("importEdition " + AuthenticationHelper.getUserName());
			String tmpFileName = "";
			try {
				tmpFileName = this.storeEditionFile(in);
			} catch (IOException e) {
				log.warn("Unable to copy received inputstream: " + e.getMessage(), e);
			}
			if (log.isInfoEnabled()) log.info("end importEdition - please wait for cronjob to pick up!");
		} catch (Exception e) {
			throw new UserException(e.getMessage());
		}

	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#removeAllOldContentVersions(java.lang.Integer)
	 */
	@Override
	protected void handleRemoveAllOldContentVersions(Integer contentId) throws Exception {
		try {
			Integer[] allContentVersionIds = getAllContentVersionsId(contentId);
			ContentHbm content = super.getContentHbmDao().load(contentId);
			ContentVersionHbm lastContentVersion = content.getLastContentVersion();
			Integer lastContentVersionId = lastContentVersion.getContentVersionId();
			for (int i = 0; i < allContentVersionIds.length; i++) {
				if (!lastContentVersionId.equals(allContentVersionIds[i])) {
					removeContentVersion(allContentVersionIds[i]);
				}
			}
			lastContentVersion.setVersion("1");
		} catch (Exception e) {
			log.error("Could not remove all old content versions from content with id " + contentId, e);
			throw new UserException(e.getMessage());
		}
	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#removeContentVersion(java.lang.Integer)
	 */
	@Override
	protected void handleRemoveContentVersion(Integer contentVersionId) throws Exception {
		super.getContentVersionHbmDao().remove(contentVersionId);
	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#removeDocument(java.lang.Integer)
	 */
	@Override
	protected void handleRemoveDocument(Integer documentId) throws Exception {
		Set viewComponents = getDocumentUsage(documentId);
		if (viewComponents.size() > 0) {
			throw new UserException("validation exception");
		}
		DocumentHbm documentHbm=super.getDocumentHbmDao().load(documentId);
		Integer siteId=null;
		if(documentHbm.getUnit()==null){
			Integer unitId=documentHbm.getViewComponent().getUnit4ViewComponent();
			UnitHbm unitHbm=super.getUnitHbmDao().load(unitId);
			siteId=unitHbm.getSite().getSiteId();
		} else {
			siteId=documentHbm.getUnit().getSite().getSiteId();
		}
		searchengineDeleteService.deleteDocument(documentHbm.getDocumentId(), siteId);

		super.getDocumentHbmDao().remove(documentId);
	}

	/**
	 * Deletes an Edition
	 * 
	 * @see de.juwimm.cms.remote.ContentServiceSpring#removeEdition(java.lang.Integer)
	 */
	@Override
	protected void handleRemoveEdition(Integer editionId) throws Exception {
		try {
			super.getEditionHbmDao().remove(editionId);
		} catch (Exception e) {
			log.error("Could not remove edition with id: " + editionId, e);
			throw new UserException(e.getMessage());
		}
	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#removePicture(java.lang.Integer)
	 */
	@Override
	protected void handleRemovePicture(Integer pictureId) throws Exception {
		Set viewComponents = getPictureUsage(pictureId);
		if (viewComponents.size() > 0) {
			throw new UserException("validation exception");
		}
		super.getPictureHbmDao().remove(pictureId);

	}

	/**
	 * 
	 * @see de.juwimm.cms.remote.ContentServiceSpring#restoreEdition(java.lang.Integer)
	 */
	@Override
	protected void handleRestoreEdition(Integer editionId) throws Exception {
		throw new UnsupportedOperationException("Method importEdition(Integer editionId) not yet implemented.");
		/*
		 * try { if(log.isDebugEnabled()) log.debug("importEdition"); EditionLocal edition = getEditionLocalHome().findByPrimaryKey(editionId); int unitId = edition.getUnitId(); int viewDocumentId =
		 * edition.getViewDocumentId(); // because of this transaction won't be completely rolledback, we try to parse this document at first ByteArrayInputStream barr = new
		 * ByteArrayInputStream(edition.getEditionText()); GZIPInputStream gzIn = new GZIPInputStream(barr); InputSource in = new InputSource(new InputStreamReader(gzIn, "UTF-8")); DOMParser parser =
		 * new DOMParser(); parser.parse(in); Document doc = parser.getDocument(); // end of parsing the document Viewde.juwimm.cms.model.Document vdl = ViewgetDocumentLocalHome().findByPrimaryKey(new
		 * Integer(viewDocumentId)); UnitLocal unit = getUnitLocalHome().findByPrimaryKey(new Integer(unitId)); importViewComponentFile(doc, unit, viewDocumentId, false); }catch(AxisFault ae) { throw
		 * ae; }catch(Exception exe) { AxisFault af = new AxisFault(); af.setFaultDetailString(exe.getMessage()); throw af; }
		 */
	}

	/**
	 * Saves a content directly. ONLY for migration use! <br/>
	 * Is currently used to implement the XML-Lasche.
	 * 
	 * @see de.juwimm.cms.remote.ContentServiceSpring#saveContent(java.lang.Integer, java.lang.String)
	 */
	@Override
	protected void handleSaveContent(Integer contentId, String contentText) throws Exception {
		try {
			ContentHbm content = getContentHbmDao().load(contentId);
			getContentHbmDao().setContent(content, contentText);
		} catch (Exception e) {
			throw new UserException(e.getMessage());
		}
	}

	/**
	 * Sets the ActiveEdition and deploy it to liveServer
	 * 
	 * @see de.juwimm.cms.remote.ContentServiceSpring#setActiveEdition(java.lang.Integer, boolean)
	 */
	@Override
	protected void handleSetActiveEdition(Integer editionId, boolean deploy) throws Exception {
		try {
			EditionHbm edac = super.getEditionHbmDao().load(editionId);
			Collection coll = super.getEditionHbmDao().findByUnitAndViewDocument(new Integer(edac.getUnitId()), new Integer(edac.getViewDocumentId()));
			Iterator it = coll.iterator();
			EditionHbm edition = null;
			while (it.hasNext()) {
				edition = (EditionHbm) it.next();
				if (edition.getEditionId().equals(editionId)) {
					if (edition.getStatus() == 0) {
						if (log.isDebugEnabled()) log.debug("CALLING importEdition AND/OR publishToLiveserver");
						if (deploy) {
							edition = super.getEditionHbmDao().create(edition);
							super.getEditionServiceSpring().publishEditionToLiveserver(edition.getEditionId());
						}
						edition.setStatus((byte) 1);
					}
				} else {
					edition.setStatus((byte) 0);
				}
			}
		} catch (Exception e) {
			throw new UserException(e.getMessage());
		}
	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#setPicture4Unit(java.lang.Integer, java.lang.Integer)
	 */
	@Override
	protected void handleSetPicture4Unit(Integer unitId, Integer pictureId) throws Exception {
		UnitHbm unit = super.getUnitHbmDao().load(unitId);
		unit.setImageId(pictureId);
	}

	/**
	 * @see de.juwimm.cms.remote.ContentServiceSpring#updatePictureAltText(java.lang.Integer, java.lang.String)
	 */
	@Override
	protected void handleUpdatePictureAltText(Integer pictureId, String altText) throws Exception {
		PictureHbm picture = super.getPictureHbmDao().load(pictureId);
		picture.setAltText(altText);
	}

	/**
	 * Changes the TemplateName. This should be used carefully by the siteRoot, because it could corrupt the content after a second "save". <br>
	 * In general this should be used only to change templates for pages, that can't be deleted - for example the root-page.
	 * 
	 * @param viewComponentId
	 *            The ViewComponent to which the templateName should be updated in the content bean
	 * @param templateName
	 *            The template Name
	 * 
	 * @see de.juwimm.cms.remote.ContentServiceSpring#updateTemplate(java.lang.Integer, java.lang.String)
	 */
	@Override
	protected void handleUpdateTemplate(Integer viewComponentId, String templateName) throws Exception {
		ViewComponentHbm viewComponent = super.getViewComponentHbmDao().load(viewComponentId);
		ContentHbm content = super.getContentHbmDao().load(new Integer(viewComponent.getReference()));
		content.setTemplate(templateName);
	}

	/**
	 * If this page has more than ContentServiceSpringImpl.MAX_NO_OF_CONTENT_VERSIONS_PER_PAGE contentVersions, the oldest ones are deleted, the rest gets renumbered. An existing PUBLS-Version is
	 * conserved.
	 */
	private void removeSpareContentVersions(Integer contentId) {
		try {
			Collection allContentVersions = super.getContentHbmDao().load(contentId).getContentVersions();
			if (allContentVersions != null && allContentVersions.size() > ContentServiceSpringImpl.MAX_NO_OF_CONTENT_VERSIONS_PER_PAGE) {
				Iterator<ContentVersionHbm> it = allContentVersions.iterator();
				TreeMap<Integer, ContentVersionHbm> tm = new TreeMap<Integer, ContentVersionHbm>();
				while (it.hasNext()) {
					ContentVersionHbm cvd = it.next();
					if (!cvd.getVersion().equals("PUBLS")) {
						tm.put(new Integer(cvd.getVersion()), cvd);
					}
				}
				List<Integer> cvList2Delete = new ArrayList<Integer>();
				List<ContentVersionHbm> cvList = new ArrayList<ContentVersionHbm>();
				it = tm.values().iterator();
				while (it.hasNext()) {
					cvList.add(it.next());
				}
				int firstCoolIndex = tm.values().size() - ContentServiceSpringImpl.MAX_NO_OF_CONTENT_VERSIONS_PER_PAGE;
				int currentIndex = 1;
				for (int i = 0; i < cvList.size(); i++) {
					ContentVersionHbm current = cvList.get(i);
					if (i < firstCoolIndex) {
						cvList2Delete.add(current.getContentVersionId());
					} else {
						current.setVersion(Integer.toString(currentIndex++));
					}
				}
				Iterator<Integer> delIt = cvList2Delete.iterator();
				while (delIt.hasNext()) {
					Integer currContentVersionId = delIt.next();
					if (log.isDebugEnabled()) log.debug("Content: " + contentId + " Contentversion to delete: " + currContentVersionId);
					super.getContentVersionHbmDao().remove(currContentVersionId);
				}
			}
		} catch (Exception e) {
			log.error("Error removing spare ContentVersions: " + e.getMessage(), e);
		}
	}

	private String storeEditionFile(InputStream in) throws IOException {
		String dir = getTizzitPropertiesBeanSpring().getDatadir() + File.separatorChar + "edition";
		if (log.isInfoEnabled()) log.info("Storing Edition File in: " + dir);
		File fDir = new File(dir);
		fDir.mkdirs();
		if (log.isInfoEnabled()) log.info("deploy dir created");
		DateFormat dateFormat = new SimpleDateFormat("yyyyMMdd_HHmmss");
		String date = dateFormat.format(new Date());
		File storedEditionFile = new File(fDir.getAbsolutePath() + File.separatorChar + "edition_import_" + date + ".xml.gz");
		if (log.isInfoEnabled()) log.info("edition file is named: " + storedEditionFile.getAbsolutePath());
		//File.createTempFile("edition_import_" + date, ".xml.gz", fDir);
		FileOutputStream out = new FileOutputStream(storedEditionFile);
		IOUtils.copyLarge(in, out);
		IOUtils.closeQuietly(out);
		IOUtils.closeQuietly(in);
		if (log.isInfoEnabled()) log.info("Storing Edition File finished");
		return storedEditionFile.getAbsolutePath();
	}

	private File storeTempFile(InputStream in, String name) throws IOException {
		String dir = getTizzitPropertiesBeanSpring().getDatadir() + File.separatorChar + "tmp";
		File fDir = new File(dir);
		fDir.mkdirs();
		File storedEditionFile = File.createTempFile(name, "bak", fDir);
		FileOutputStream out = new FileOutputStream(storedEditionFile);
		IOUtils.copyLarge(in, out);
		IOUtils.closeQuietly(out);
		IOUtils.closeQuietly(in);
		if (log.isDebugEnabled()) {
			log.debug("Stored document file stream temporarily in: " + storedEditionFile.getAbsolutePath());
		}
		return storedEditionFile;
	}

	//		/**
	//		 * @param oldContentText
	//		 * @param newContentText
	//		 */
	//		private void updateDocumentUseCountLastVersion(String oldContentText, String newContentText) {
	//			/*  
	//			HashMap<Integer, Integer> deltaMap = this.getDeltaDocumentCounts(oldContentText, newContentText);
	//			this.updateDocumentUseCounts(deltaMap, true);
	//			*/
	//		}
	//
	//	private void updateDocumentUseCountPublishVersion(String oldContentText, String newContentText) {
	//		/*  
	//		HashMap<Integer, Integer> deltaMap = this.getDeltaDocumentCounts(oldContentText, newContentText);
	//		this.updateDocumentUseCounts(deltaMap, false);
	//		*/
	//	}
	//
	//	private void updateDocumentUseCounts(HashMap<Integer, Integer> deltaMap, boolean isLastVersion) {
	//		Iterator<Integer> it = deltaMap.keySet().iterator();
	//		while (it.hasNext()) {
	//			Integer docId = it.next();
	//			Integer docCountDelta = deltaMap.get(docId);
	//			if (docCountDelta != null && docCountDelta.intValue() != 0) {
	//				try {
	//					DocumentHbm doc = super.getDocumentHbmDao().load(docId);
	//					if (isLastVersion) {
	//						int newCount = doc.getUseCountLastVersion() + docCountDelta.intValue();
	//						if (newCount < 0) newCount = 0;
	//						doc.setUseCountLastVersion(newCount);
	//					} else {
	//						int newCount = doc.getUseCountPublishVersion() + docCountDelta.intValue();
	//						if (newCount < 0) newCount = 0;
	//						doc.setUseCountPublishVersion(newCount);
	//					}
	//				} catch (Exception e) {
	//					log.warn("Error updating documentCount for document " + docId + ": " + e.getMessage());
	//				}
	//			}
	//		}
	//	}

	/* (non-Javadoc)
	 * @see de.juwimm.cms.remote.ContentServiceSpringBase#handleUpdatePictureData(java.lang.Integer, byte[], byte[])
	 */
	@Override
	protected void handleUpdatePictureData(Integer pictureId, byte[] picture, String mimeType, byte[] thumbnail) throws Exception {
		PictureHbm pic = getPictureHbmDao().load(pictureId);
		pic.setTimeStamp(System.currentTimeMillis());
		pic.setMimeType(mimeType);
		pic.setPicture(picture);
		pic.setThumbnail(thumbnail);
	}

	@Override
	protected Integer handleGetPictureIdForUnitAndName(Integer unitId, String name) throws Exception {
		return getPictureHbmDao().getIdForNameAndUnit(unitId, name);
	}

	@Override
	protected Integer handleGetPictureIdForViewComponentAndName(Integer viewComponentId, String name) throws Exception {
		return getPictureHbmDao().getIdForNameAndViewComponent(name, viewComponentId);
	}

	@Override
	protected Integer handleGetDocumentIdForNameAndUnit(String name, Integer unitId) throws Exception {
		return getDocumentHbmDao().getIdForNameAndUnit(name, unitId);
	}

	@SuppressWarnings("unchecked")
	@Override
	protected Map handleGetResources4Unit(Integer unitId, boolean usedDoc, boolean unusedDoc, boolean usedPict, boolean unusedPict) throws Exception {
		Map<Object, ResourceUsageState> result = new HashMap<Object, ResourceUsageState>();
		Map<Integer, ResourceUsageState> documents = new HashMap<Integer, ResourceUsageState>();
		Map<Integer, ResourceUsageState> pictures = new HashMap<Integer, ResourceUsageState>();

		DocumentSlimValue[] dbDocuments = this.getAllSlimDocuments4Unit(unitId);
		PictureSlimstValue[] dbPictures = this.getAllSlimPictures4Unit(unitId);

		Map<ViewComponentHbm, List<ContentVersionHbm>> contentVersions = getAllContentVersions4Unit(unitId);
		getUsedResourcesFromContentVersions(contentVersions, documents, pictures);

		result.putAll(new DocumentResourceComparer().extract(dbDocuments, documents, usedDoc, unusedDoc));
		result.putAll(new PictureResourceComparer().extract(dbPictures, pictures, usedPict, unusedPict));

		return result;
	}

	private Map<ViewComponentHbm, List<ContentVersionHbm>> getAllContentVersions4Unit(Integer unitId) {
		Map<ViewComponentHbm, List<ContentVersionHbm>> contentVersions = new HashMap<ViewComponentHbm, List<ContentVersionHbm>>();
		List<ViewComponentHbm> rootViewDocuments = (List<ViewComponentHbm>) getViewComponentHbmDao().findRootViewComponents4Unit(unitId);

		if (rootViewDocuments != null && rootViewDocuments.size() > 0) {
			for (ViewComponentHbm root : rootViewDocuments) {
				contentVersions.putAll(getAllContentVersionsRecursive(root));
			}
		}
		return contentVersions;
	}

	private Map<ViewComponentHbm, List<ContentVersionHbm>> getAllContentVersionsRecursive(ViewComponentHbm root) {

		Map<ViewComponentHbm, List<ContentVersionHbm>> contentVersions = new HashMap<ViewComponentHbm, List<ContentVersionHbm>>();
		try{
			long contentId=Long.parseLong(root.getReference());
			contentVersions.put(root, (List<ContentVersionHbm>) getContentVersionHbmDao().findContentVersionsByViewComponent(root.getViewComponentId()));
		}catch (Exception e) {
			log.debug("Reference field not a number",e);
		} finally {
		Collection children = root.getChildren();
		if (children != null && children.size() > 0) {
			for (Object child : children) {
				contentVersions.putAll(getAllContentVersionsRecursive((ViewComponentHbm) child));
			}
		}
		}

		return contentVersions;
		
	}

	/**
	 * Used to compare list of resources from database (image/pictures) with used resources in contents
	 * to extract resources that are not used
	 * @param <T> can be PictureSlimstValue or DocumentValue
	 */
	private static abstract class UnusedResourceComparer<T, K> {
		abstract Integer getId(T resource);

		abstract K load(Integer id);

		abstract UnitHbm getUnit(K resource);

		abstract K createResource(Integer id);

		public Map<T, ResourceUsageState> extract(T[] resources, Map<Integer, ResourceUsageState> used, boolean usedRes, boolean unusedRes) {
			Map<T, ResourceUsageState> resourceResult = new HashMap<T, ResourceUsageState>();
			if (resources != null && resources.length > 0) {
				boolean emptyUsedResources = false;
				if (used == null || used.size() == 0) {
					emptyUsedResources = true;
				}
				for (T resource : resources) {
					if (emptyUsedResources && unusedRes) {
						resourceResult.put(resource, ResourceUsageState.Unsused);
						continue;
					}
					Integer resourceId = this.getId(resource);
					if (!used.containsKey(resourceId)) {
						if (unusedRes) {
							resourceResult.put(resource, ResourceUsageState.Unsused);
						}
					} else {
						if (usedRes) {
							resourceResult.put(resource, used.get(resourceId));
						}
					}
				}
			}
			return resourceResult;
		}

		public Map<UnitHbm, List<K>> groupResourcesByUnit(Integer[] resourceIds) {
			Map<UnitHbm, List<K>> ressourcesPerUnit = new HashMap<UnitHbm, List<K>>();
			if (resourceIds != null && resourceIds.length > 0) {
				for (Integer resourceId : resourceIds) {
					K resource = load(resourceId);
					UnitHbm unit = getUnit(resource);
					if (ressourcesPerUnit.containsKey(unit)) {
						ressourcesPerUnit.get(unit).add(resource);
					} else {
						List<K> rsources = new ArrayList<K>();
						rsources.add(resource);
						ressourcesPerUnit.put(unit, rsources);
					}
				}
			}
			return ressourcesPerUnit;
		}

		public boolean checkResourcesInContentText(Node contentVersionNode, ResourceUsageState state, Boolean withHistory, List<K> resources, String type, String attributeName) throws Exception {
			Iterator it = XercesHelper.findNodes(contentVersionNode, "//" + type);
			boolean keepVersionForDelete = false;
			while (it.hasNext()) {
				Node node = (Node) it.next();
				Node attributeNode = node.getAttributes().getNamedItem(attributeName);
				if (attributeNode == null) {
					continue;
				}
				Integer resourceId = null;
				try {
					resourceId = Integer.parseInt(attributeNode.getNodeValue());
				} catch (NumberFormatException ex) {
					continue;
				}
				K resourceTemp = createResource(resourceId);
				if (resources.contains(resourceTemp)) {
					//if user does not want to delete history revisions also then error
					if (!withHistory) {
						if (state != ResourceUsageState.Unsused) {
							throw new Exception("validation exception");
						}
					} else {
						if (state != ResourceUsageState.Used) {
							//select history version for delete
							keepVersionForDelete = true;
						} else if (state == ResourceUsageState.Used) {
							throw new Exception("validation exception");
						}
					}
				}
			}
			return keepVersionForDelete;
		}
	}

	private class DocumentResourceComparer extends UnusedResourceComparer<DocumentSlimValue, DocumentHbm> {

		@Override
		Integer getId(DocumentSlimValue resource) {
			return resource.getDocumentId();
		}

		@Override
		DocumentHbm load(Integer id) {
			return getDocumentHbmDao().load(id);
		}

		@Override
		UnitHbm getUnit(DocumentHbm resource) {
			return resource.getUnit();
		}

		@Override
		DocumentHbm createResource(Integer id) {
			DocumentHbm resource = DocumentHbm.Factory.newInstance();
			resource.setDocumentId(id);
			return resource;
		}

	}

	private class PictureResourceComparer extends UnusedResourceComparer<PictureSlimstValue, PictureHbm> {

		@Override
		Integer getId(PictureSlimstValue resource) {
			return resource.getPictureId();
		}

		@Override
		PictureHbm load(Integer id) {
			return getPictureHbmDao().load(id);
		}

		@Override
		UnitHbm getUnit(PictureHbm resource) {
			return resource.getUnit();
		}

		@Override
		PictureHbm createResource(Integer id) {
			PictureHbm resource = PictureHbm.Factory.newInstance();
			resource.setPictureId(id);
			return resource;
		}

	}

	/**
	 * Gets used documents and pictures
	 * @param contentVersions - content versions where to find
	 * @param withHistory - if true selects the history version also
	 * @param documents - list of used documents
	 * @param pictures - list of used pictures
	 */
	private void getUsedResourcesFromContentVersions(Map<ViewComponentHbm, List<ContentVersionHbm>> contentVersions, Map<Integer, ResourceUsageState> documents, Map<Integer, ResourceUsageState> pictures) {
		if (contentVersions == null || contentVersions.size() == 0) {
			return;
		}

		for (Entry<ViewComponentHbm, List<ContentVersionHbm>> contentVersionGroup : contentVersions.entrySet()) {
			Integer maxVersion = getMaxVersion(contentVersionGroup.getValue());
			for (ContentVersionHbm contentVersion : contentVersionGroup.getValue()) {
				String content = contentVersion.getText();
				ResourceUsageState state = null;
				Integer currentVersion = Integer.decode(contentVersion.getVersion());
				if (currentVersion < maxVersion) {
					state = ResourceUsageState.UsedInOlderVersions;
				} else if (currentVersion == maxVersion) {
					state = ResourceUsageState.Used;
				}
				if (content != null) {
					try {
						Document domDocument = XercesHelper.string2Dom(content);
						//tags from content that represent documents and pictures
						getResourcesFromContentVersion(domDocument, state, documents, "document", "src");
						getResourcesFromContentVersion(domDocument, state, pictures, "picture", "description");
						getResourcesFromContentVersion(domDocument, state, pictures, "image", "src");
					} catch (Exception e) {
						log.info("could not parse used ressources: " + e.getMessage());
						if (log.isDebugEnabled()) log.debug("Parsing Error", e);
					}
				}
			}
		}
	}

	/**
	 * 
	 * @param contentVersions
	 * @param resourceId
	 * @param type
	 * @param attributeNameId
	 * @return
	 */
	private List<ContentVersionHbm> getContentVersionUsingResource(List<ContentVersionHbm> contentVersions, Integer resourceId, String type, String attributeNameId) {
		List<ContentVersionHbm> usedContentVersion = new ArrayList<ContentVersionHbm>();
		if (contentVersions == null || contentVersions.size() == 0) {
			return usedContentVersion;
		}
		for (ContentVersionHbm contentVersion : contentVersions) {
			String content = contentVersion.getText();
			if (content != null) {
				try {
					Document document = XercesHelper.string2Dom(content);
					if (isResourceInContentVersion(document, resourceId, type, attributeNameId)) {
						usedContentVersion.add(contentVersion);
					}
				} catch (Exception e) {
					log.info("could not parse used ressources: " + e.getMessage());
					if (log.isDebugEnabled()) log.debug("Parsing Error", e);
				}
			}
		}
		return usedContentVersion;
	}

	/**
	 * 
	 * @param contentVersionNode xml node
	 * @param state 
	 * @param resources used resources list ids
	 * @param type tag name of the resource
	 * @param attributeName attribute that indicates the id of the resource
	 */
	private void getResourcesFromContentVersion(Node contentVersionNode, ResourceUsageState state, Map<Integer, ResourceUsageState> resources, String type, String attributeName) {
		Iterator it = XercesHelper.findNodes(contentVersionNode, "//" + type);
		while (it.hasNext()) {
			Node node = (Node) it.next();
			Node attributeNode = node.getAttributes().getNamedItem(attributeName);
			if (attributeNode == null) {
				continue;
			}
			Integer resourceId = null;
			try {
				resourceId = Integer.parseInt(attributeNode.getNodeValue());
			} catch (NumberFormatException e) {
				continue;
			}
			if (resources.containsKey(resourceId)) {
				//if state is Used I don't care if they are used in older version too
				//State Used is powerfull than UsedInOlderVersions
				if (resources.get(resourceId) == ResourceUsageState.Used) {
					continue;
				}
			}
			resources.put(resourceId, state);
		}
	}

	private boolean isResourceInContentVersion(Node contentVersionNode, Integer resourceId, String type, String attributeName) {
		Iterator it = XercesHelper.findNodes(contentVersionNode, "//" + type + "[@" + attributeName + "=" + resourceId.toString() + "]");
		return it.hasNext();
	}

	private PrintStream createEditionOutputStream(EditionHbm edition) throws IOException {
		//create dir for deploys
		log.info("Start creating edition output file");
		String dir = getTizzitPropertiesBeanSpring().getDatadir() + File.separatorChar + "deploys";
		log.info("deployDir: " + dir);
		File fDir = new File(dir);
		fDir.mkdirs();
		log.info("outputdir created");
		String fileName = fDir.getAbsolutePath() + File.separatorChar + "deploy_file_edition_" + edition.getEditionId() + "_byUser_" + edition.getCreator().getUserId() + "_" + edition.getCreationDate() + ".xml.gz";
		log.info("fileName: " + fileName);
		File fle = new File(fileName);
		edition.setEditionFileName(fle.getAbsolutePath());
		log.info("output file opend: " + fle.getAbsolutePath());
		FileOutputStream fout = new FileOutputStream(fle);
		GZIPOutputStream gzoudt = new GZIPOutputStream(fout);
		PrintStream out = new PrintStream(gzoudt, true, "UTF-8");
		//if (log.isDebugEnabled()) log.debug("Invoker is: " + edition.getCreator() + " within Site " + site.getName());
		if (log.isDebugEnabled()) log.debug("Dummy-Editon create");
		out.println("<edition>");
		if (log.isDebugEnabled()) log.debug("editionToXml");
		out.println(edition.toXml());
		System.gc();
		return out;
	}

	/* (non-Javadoc)
	 * @see de.juwimm.cms.remote.ContentServiceSpringBase#handleDeployEdition(de.juwimm.cms.model.EditionHbm)
	 */
	@Override
	protected void handleDeployEdition(Integer editionId) throws Exception {
		try {
			editionCronService.logEditionStatusInfo(LiveserverDeployStatus.CreateDeployFileForExport, editionId);
			if (log.isDebugEnabled()) log.debug("Start creating Edition");
			EditionHbm edition = getEditionHbmDao().load(editionId);

			PrintStream out = createEditionOutputStream(edition);
			//
			if (log.isDebugEnabled()) log.debug("siteToXml");
			getEditionHbmDao().siteToXml(edition.getSiteId(), out, edition);
			System.gc();
			if (log.isDebugEnabled()) log.debug("picturesToXmlRecursive");
			getEditionHbmDao().picturesToXmlRecursive(null, edition.getSiteId(), out, edition);
			System.gc();
			if (log.isDebugEnabled()) log.debug("documentsToXmlRecursive");
			getEditionHbmDao().documentsToXmlRecursive(null, edition.getSiteId(), out, true, edition);
			System.gc();
			if (log.isDebugEnabled()) log.debug("unitsToXmlRecursive");
			getEditionHbmDao().unitsToXmlRecursive(edition.getSiteId(), out, edition);
			System.gc();
			if (log.isDebugEnabled()) log.debug("hostsToXmlRecursive");
			getEditionHbmDao().hostsToXmlRecursive(edition.getSiteId(), out, edition);
			if (log.isDebugEnabled()) log.debug("viewdocumentsToXmlRecursive");
			getEditionHbmDao().viewdocumentsToXmlRecursive(edition.getSiteId(), out, edition);
			if (log.isDebugEnabled()) log.debug("realmsToXmlRecursive");
			getEditionHbmDao().realmsToXmlRecursive(edition.getSiteId(), out, edition);
			System.gc();
			if (log.isDebugEnabled()) log.debug("Creating ViewComponent Data");
			Iterator vdIt = getViewDocumentHbmDao().findAll(edition.getSiteId()).iterator();
			while (vdIt.hasNext()) {
				ViewDocumentHbm vdl = (ViewDocumentHbm) vdIt.next();
				getViewComponentHbmDao().toXml(vdl.getViewComponent(), null, true, true, false, false, -1, false, false, Constants.DEPLOY_TYPE_FULL, out);
			}
			if (log.isDebugEnabled()) log.debug("Finished creating ViewComponent Data");
			out.println("</edition>");

			out.flush();
			out.close();
			out = null;
			if (log.isDebugEnabled()) log.debug("Finished creating Edition");
		} catch (Exception e) {
			if (log.isDebugEnabled()) log.debug("Error while creating Edition", e);
			editionCronService.logEditionStatusException(editionId, e.getMessage());
			throw new UserException(e.getMessage(), e);
		}
	}

	@Override
	protected void handleDeployUnitEdition(Integer editionId, Integer unitId) throws Exception {
		try {
			if (log.isDebugEnabled()) log.debug("Start creating unitEdition");
			editionCronService.logEditionStatusInfo(LiveserverDeployStatus.CreateDeployFileForExport, editionId);
			//if (log.isInfoEnabled())log.info("createDeployFile " + AuthenticationHelper.getUserName());
			EditionHbm edition = getEditionHbmDao().load(editionId);

			PrintStream out = createEditionOutputStream(edition);
			if (log.isDebugEnabled()) log.debug("creating outputstream for unitEdition");
			// site info is needed to connect to the live server
			if (log.isDebugEnabled()) log.debug("siteToXml");
			getEditionHbmDao().siteToXml(edition.getSiteId(), out, edition);
			System.gc();
			// Alle ..toXML + unitID to reuse them in unitDeploy
			if (log.isDebugEnabled()) log.debug("picturesToXmlRecursive");
			getEditionHbmDao().picturesToXmlRecursive(unitId, edition.getSiteId(), out, edition);
			System.gc();
			if (log.isDebugEnabled()) log.debug("documentsToXmlRecursive");
			getEditionHbmDao().documentsToXmlRecursive(unitId, edition.getSiteId(), out, true, edition);
			System.gc();
			if (log.isDebugEnabled()) log.debug("unitToXml");
			getEditionHbmDao().unitToXml(unitId, out, edition);
			System.gc();
			//			if (log.isDebugEnabled()) log.debug("viewdocumentsToXmlRecursive");
			//			getEditionHbmDao().viewdocumentsToXmlRecursive(edition.getSiteId(), out, edition);
			if (log.isDebugEnabled()) log.debug("realmsToXmlUsed: unit - " + unitId);
			getEditionHbmDao().realmsToXmlUsed(unitId, out, edition);
			System.gc();
			if (log.isDebugEnabled()) log.debug("Creating ViewComponent Data");
			Iterator vdIt = getViewDocumentHbmDao().findAll(edition.getSiteId()).iterator();

			//

			while (vdIt.hasNext()) {
				ViewDocumentHbm vdl = (ViewDocumentHbm) vdIt.next();
				ViewComponentHbm vch = getViewComponentHbmDao().find4Unit(unitId, vdl.getViewDocumentId());
				if (vch != null) getViewComponentHbmDao().toXml(vch, unitId, true, true, true, false, -1, false, false, Constants.DEPLOY_TYPE_UNIT, out);
			}
			if (log.isDebugEnabled()) log.debug("Finished creating ViewComponent Data");
			out.println("</edition>");

			out.flush();
			out.close();
			out = null;
			if (log.isDebugEnabled()) log.debug("Finished creating unitEdition");
		} catch (Exception e) {
			if (log.isDebugEnabled()) log.debug("error while creating unitEdition", e);
			editionCronService.logEditionStatusException(editionId, e.getMessage());
			throw new UserException(e.getMessage(), e);
		}
	}

	@SuppressWarnings("unchecked")
	@Override
	protected void handleRemoveResources(Integer[] pictureIds, Integer[] documentsIds, boolean forceDeleteHistory) throws Exception {
		Map<UnitHbm, List<PictureHbm>> picturesPerUnits = new PictureResourceComparer().groupResourcesByUnit(pictureIds);
		Map<UnitHbm, List<DocumentHbm>> documentsPerUnits = new DocumentResourceComparer().groupResourcesByUnit(documentsIds);

		Map<UnitHbm, List<List>> resourcesPerUnits = new HashMap<UnitHbm, List<List>>();

		//compact unit per resources
		//conventionon <UnitHbm,List<List>>: first object in list are the pictures, second the documents
		for (Entry<UnitHbm, List<PictureHbm>> picturePerUnit : picturesPerUnits.entrySet()) {
			List<List> resourcesList = new ArrayList<List>();
			resourcesList.add(0, picturePerUnit.getValue());
			if (documentsPerUnits.containsKey(picturePerUnit.getKey())) {
				resourcesList.add(1, documentsPerUnits.get(picturePerUnit.getKey()));
				documentsPerUnits.remove(picturePerUnit.getKey());
			} else {
				resourcesList.add(1, new ArrayList());
			}
			resourcesPerUnits.put(picturePerUnit.getKey(), resourcesList);
		}

		for (Entry<UnitHbm, List<DocumentHbm>> documentsPerUnit : documentsPerUnits.entrySet()) {
			List<List> resourcesList = new ArrayList<List>();
			resourcesList.add(0, new ArrayList());
			resourcesList.add(1, documentsPerUnit.getValue());
			resourcesPerUnits.put(documentsPerUnit.getKey(), resourcesList);
		}

		//Validate resources are used or not
		List<ContentVersionHbm> historyContentVersion = new ArrayList<ContentVersionHbm>();
		for (Entry<UnitHbm, List<List>> resourcesPerUnit : resourcesPerUnits.entrySet()) {
			Map<ViewComponentHbm, List<ContentVersionHbm>> contentVersions = getAllContentVersions4Unit(resourcesPerUnit.getKey().getUnitId());
			historyContentVersion.addAll(checkResourcesInContentVersions(contentVersions, forceDeleteHistory, resourcesPerUnit.getValue().get(0), resourcesPerUnit.getValue().get(1)));
		}

		if (forceDeleteHistory) {
			getContentVersionHbmDao().remove(historyContentVersion);
		}

		getDocumentHbmDao().deleteDocuments(documentsIds);
		getPictureHbmDao().deletePictures(pictureIds);
	}

	private List<ContentVersionHbm> checkResourcesInContentVersions(Map<ViewComponentHbm, List<ContentVersionHbm>> contentVersions, boolean withHistory, List<PictureHbm> pictures, List<DocumentHbm> documents) throws Exception {
		DocumentResourceComparer documentComparer = new DocumentResourceComparer();
		PictureResourceComparer pictureComparer = new PictureResourceComparer();
		List<ContentVersionHbm> contentsToDelete = new ArrayList<ContentVersionHbm>();
		if (contentVersions == null || contentVersions.size() == 0) {
			return contentsToDelete;
		}

		for (Entry<ViewComponentHbm, List<ContentVersionHbm>> contentVersionGroup : contentVersions.entrySet()) {
			Integer maxVersion = getMaxVersion(contentVersionGroup.getValue());
			for (ContentVersionHbm contentVersion : contentVersionGroup.getValue()) {
				String content = contentVersion.getText();
				ResourceUsageState state = null;
				Integer currentVersion = Integer.decode(contentVersion.getVersion());
				if (currentVersion < maxVersion) {
					state = ResourceUsageState.UsedInOlderVersions;
				} else if (currentVersion == maxVersion) {
					state = ResourceUsageState.Used;
				}
				if (content != null) {
					Document domDocument = null;
					try {
						domDocument = XercesHelper.string2Dom(content);
					} catch (Exception e) {
						log.info("could not parse used ressources: " + e.getMessage());
						if (log.isDebugEnabled()) log.debug("Parsing Error", e);
					}
					if (domDocument != null) {
						boolean deleteContent = false;
						deleteContent = deleteContent || documentComparer.checkResourcesInContentText(domDocument, state, withHistory, documents, "document", "src");
						deleteContent = deleteContent || pictureComparer.checkResourcesInContentText(domDocument, state, withHistory, pictures, "picture", "description");
						deleteContent = deleteContent || pictureComparer.checkResourcesInContentText(domDocument, state, withHistory, pictures, "image", "src");
						if (deleteContent) {
							contentsToDelete.add(contentVersion);
						}
					}

				}
			}
		}
		return contentsToDelete;
	}

	/**
	 * Also in the contentVersions it replaces the PUBLS version with the max version  
	 * @param contentVersions - The list of contents should be all the contents from a view
	 * @return
	 */
	private Integer getMaxVersion(List<ContentVersionHbm> contentVersions) {
		Integer maxVersion = 0;
		ContentVersionHbm publishContentVersion = null;
		//search max revision
		for (ContentVersionHbm contentVersion : contentVersions) {
			if (contentVersion.getVersion().equals(Constants.PUBLISH_VERSION)) {
				publishContentVersion = contentVersion;
				break;
			}
			int versionNumber = Integer.decode(contentVersion.getVersion());
			if (versionNumber > maxVersion) {
				maxVersion = versionNumber;
			}
		}

		if (publishContentVersion != null) {
			publishContentVersion.setVersion(Integer.toString(++maxVersion));
		}
		return maxVersion;
	}

	@Override
	protected void handleMakeContentOffline(Integer viewComponentId) throws Exception {
		ViewComponentHbm viewComponent = getViewComponentHbmDao().load(viewComponentId);
		//update online status
		viewComponent.setOnline((byte) 0);
		viewComponent.setStatus(Constants.DEPLOY_STATUS_EDITED);
		getViewComponentHbmDao().update(viewComponent);
		try{
		ContentHbm content = getContentHbmDao().load(Integer.decode(viewComponent.getReference()));
		ContentVersionHbm publishContentVersion = content!=null?content.getContentVersionForPublish():null;
		if (publishContentVersion == null) {
			return;
		}
		//remove publish content version
		content.getContentVersions().remove(publishContentVersion);
		getContentHbmDao().update(content);
		removeContentVersion(publishContentVersion.getContentVersionId());
		}catch(Exception e){
			log.error(e.getMessage(),e);
		}
	}

	@Override
	protected boolean handleGetPictureThumbnailPopup(Integer pictureId) throws Exception {
		PictureHbm picture = super.getPictureHbmDao().load(pictureId);
		return picture.isThumbnailPopup();
	}

	@Override
	protected void handleUpdatePictureThumbnailPopup(boolean withThumbnailPopup, Integer pictureId) throws Exception {
		PictureHbm picture = super.getPictureHbmDao().load(pictureId);
		picture.setThumbnailPopup(withThumbnailPopup);

	}

	@Override
	protected Set handleGetDocumentUsage(Integer documentId) throws Exception {
		DocumentHbm document = super.getDocumentHbmDao().load(documentId);
		Integer unitId=null;
		if(document.getUnit()==null){
			unitId=document.getViewComponent().getUnit4ViewComponent();
		} else {
			unitId=document.getUnit().getUnitId();
		}
		Set<ViewComponentValue> result = new HashSet<ViewComponentValue>();
		Map<ViewComponentHbm, List<ContentVersionHbm>> contentVersions = getAllContentVersions4Unit(unitId);
		for (Entry<ViewComponentHbm, List<ContentVersionHbm>> contentVersion : contentVersions.entrySet()) {
			List<ContentVersionHbm> usedContentVersions = getContentVersionUsingResource(contentVersion.getValue(), documentId, "document", "src");
			if (usedContentVersions != null && usedContentVersions.size() > 0) {
				result.add(contentVersion.getKey().getDao());
			}
		}
		return result;
	}

	@Override
	protected Set handleGetPictureUsage(Integer pictureId) throws Exception {
		PictureHbm picture = getPictureHbmDao().load(pictureId);
		Integer unitId=null;
		if(picture.getUnit()==null){
			unitId=picture.getViewComponent().getUnit4ViewComponent();
		} else {
			unitId=picture.getUnit().getUnitId();
		}
		Set<ViewComponentValue> result = new HashSet<ViewComponentValue>();
		Map<ViewComponentHbm, List<ContentVersionHbm>> contentVersions = getAllContentVersions4Unit(unitId);
		for (Entry<ViewComponentHbm, List<ContentVersionHbm>> contentVersion : contentVersions.entrySet()) {
			List<ContentVersionHbm> usedContentVersions = getContentVersionUsingResource(contentVersion.getValue(), pictureId, "picture", "description");
			if (usedContentVersions != null && usedContentVersions.size() > 0) {
				result.add(contentVersion.getKey().getDao());
				continue;
			}
			usedContentVersions = getContentVersionUsingResource(contentVersion.getValue(), pictureId, "image", "src");
			if (usedContentVersions != null && usedContentVersions.size() > 0) {
				result.add(contentVersion.getKey().getDao());
			}
		}
		return result;
	}

	@Override
	protected List handleGetEditions() throws Exception {
		List<EditionHbm> editions = (List<EditionHbm>) getEditionHbmDao().loadAll();
		List<EditionValue> editionValues = new ArrayList<EditionValue>();
		if (editions.size() > 0) {
			for (EditionHbm edition : editions) {
				editionValues.add(edition.getDao());
			}
		}
		return editionValues;
	}

	/* (non-Javadoc)
	 * @see de.juwimm.cms.remote.ContentServiceSpringBase#handleDeployRootUnitEdition(java.lang.Integer)
	 */
	@Override
	protected void handleDeployRootUnitEdition(Integer editionId) throws Exception {
		try {
			editionCronService.logEditionStatusInfo(LiveserverDeployStatus.CreateDeployFileForExport, editionId);
			if (log.isDebugEnabled()) log.debug("Start creating RootEdition");
			EditionHbm edition = getEditionHbmDao().load(editionId);

			PrintStream out = createEditionOutputStream(edition);
			// site info is needed to connect to the live server
			if (log.isDebugEnabled()) log.debug("siteToXml");
			getEditionHbmDao().siteToXml(edition.getSiteId(), out, edition);
			System.gc();
			// Alle ..toXML + unitID to reuse them in unitDeploy
			if (log.isDebugEnabled()) log.debug("picturesToXmlRecursive");
			//TODO: change -1 to null and check edition.type later .... - for the moment -1 = rootdeploy
			getEditionHbmDao().picturesToXmlRecursive(-1, edition.getSiteId(), out, edition);
			System.gc();
			if (log.isDebugEnabled()) log.debug("documentsToXmlRecursive");
			//TODO: change -1 to null and check edition.type later .... - for the moment -1 = rootdeploy
			getEditionHbmDao().documentsToXmlRecursive(-1, edition.getSiteId(), out, true, edition);
			System.gc();

			if (log.isDebugEnabled()) log.debug("unitsToXmlRecursive");
			getEditionHbmDao().unitsToXmlRecursive(edition.getSiteId(), out, edition);
			System.gc();
			//			if (log.isDebugEnabled()) log.debug("viewdocumentsToXmlRecursive");
			//			getEditionHbmDao().viewdocumentsToXmlRecursive(edition.getSiteId(), out, edition);
			if (log.isDebugEnabled()) log.debug("hostsToXmlRecursive");
			getEditionHbmDao().hostsToXmlRecursive(edition.getSiteId(), out, edition);

			if (log.isDebugEnabled()) log.debug("viewdocumentsToXmlRecursive");
			getEditionHbmDao().viewdocumentsToXmlRecursive(edition.getSiteId(), out, edition);
			if (log.isDebugEnabled()) log.debug("realmsToXmlRecursive");
			getEditionHbmDao().realmsToXmlUsed(edition.getUnitId(), out, edition);
			System.gc();
			if (log.isDebugEnabled()) log.debug("Creating ViewComponent Data");
			Iterator vdIt = getViewDocumentHbmDao().findAll(edition.getSiteId()).iterator();
			while (vdIt.hasNext()) {
				ViewDocumentHbm vdl = (ViewDocumentHbm) vdIt.next();
				getViewComponentHbmDao().toXml(vdl.getViewComponent(), edition.getUnitId(), true, true, true, false, -1, false, false, Constants.DEPLOY_TYPE_ROOT, out);

			}

			out.println("</edition>");

			out.flush();
			out.close();
			log.info("output file closed.");
			out = null;
			if (log.isDebugEnabled()) log.debug("Finished creating Edition");
		} catch (Exception e) {
			if (log.isWarnEnabled()) log.warn("Error while creating RootEdition");
			editionCronService.logEditionStatusException(editionId, e.getMessage());
			throw new UserException(e.getMessage(), e);
		}
	}

	/* (non-Javadoc)
	 * @see de.juwimm.cms.remote.ContentServiceSpringBase#handleRemoveLocks(java.lang.String)
	 */
	@Override
	protected void handleRemoveLocks(String userName) throws Exception {
		Collection locks = getLockHbmDao().findAll("from de.juwimm.cms.model.LockHbm as l where l.owner.userId = '" + userName + "'");
		Collection cvs = getContentVersionHbmDao().findAll("select cv from de.juwimm.cms.model.LockHbm as l, de.juwimm.cms.model.ContentVersionHbm as cv where l.owner.userId = '" + userName + "' and cv.lock.lockId = l.lockId");
		if (locks != null) {
			if (cvs != null && !cvs.isEmpty()) {
				Iterator it = cvs.iterator();
				while (it.hasNext()) {
					ContentVersionHbm cv = (ContentVersionHbm) it.next();
					cv.setLock(null);
				}
				getContentVersionHbmDao().update(cvs);
			}
			getLockHbmDao().remove(locks);
		}

	}

	@Override
	protected PictureSlimstValue[] handleGetAllSlimPictures4View(Integer viewComponentId) throws Exception {
		PictureSlimstValue[] pvArr = null;
		try {
			Collection coll = super.getPictureHbmDao().findAllPerViewComponent(viewComponentId);
			Iterator it = coll.iterator();
			int siz = coll.size();
			pvArr = new PictureSlimstValue[siz];
			for (int i = 0; i < siz; i++) {
				PictureHbm pic = (PictureHbm) it.next();
				pvArr[i] = pic.getSlimstValue();
			}
			return pvArr;
		} catch (Exception e) {
			throw new UserException(e.getMessage(), e);
		}
	}

	@Override
	protected DocumentSlimValue[] handleGetAllSlimDocuments4ViewComponent(Integer viewComponentId) throws Exception {
		DocumentSlimValue[] dvArr = null;
		try {
			Collection<DocumentHbm> coll = getDocumentHbmDao().findAllPerViewComponent(viewComponentId);
			dvArr = new DocumentSlimValue[coll.size()];
			int i = 0;
			for (DocumentHbm doc : coll) {
				dvArr[i++] = doc.getSlimValue();
			}
			return dvArr;
		} catch (Exception e) {
			throw new UserException(e.getMessage());
		}
	}

	@Override
	protected Integer handleGetDocumentIdForNameAndViewComponent(String name, Integer viewComponentId) throws Exception {
		return getDocumentHbmDao().getIdForNameAndViewComponent(name, viewComponentId);
	}

	@Override
	protected DocumentSlimValue handleGetDocumentSlimValue(Integer documentId)
			throws Exception {
		DocumentHbm document=getDocumentHbmDao().load(documentId);
		return document.getSlimValue();
	}

	@Override
	protected DocumentSlimValue handleUpdateDocument(
			DocumentSlimValue documentSlimValue) throws Exception {
		try {
			if (log.isDebugEnabled()) log.debug("addOrUpdateDocument for user " + AuthenticationHelper.getUserName());

			UnitHbm unit = null;
			ViewComponentHbm viewComponent = null;
			if (documentSlimValue.getViewDocumentId() != null) {
				viewComponent = getViewComponentHbmDao().load(documentSlimValue.getViewDocumentId());
			}
			if (documentSlimValue.getUnitId() != null) {
				unit = getUnitHbmDao().load(documentSlimValue.getUnitId());
			}
			DocumentHbm doc = null;

			if (documentSlimValue.getDocumentId() != null) {
				doc = getDocumentHbmDao().load(
						documentSlimValue.getDocumentId());
			} else {
				doc = DocumentHbm.Factory.newInstance();
				doc.setTimeStamp(System.currentTimeMillis());
			}
			doc.setDocumentName(documentSlimValue.getDocumentName());
			doc.setMimeType(documentSlimValue.getMimeType());
			doc.setUnit(unit);
			doc.setViewComponent(viewComponent);
			doc.setLabel(documentSlimValue.getLabel());
			doc.setPassword(documentSlimValue.getPassword());
			doc.setDescription(documentSlimValue.getDescription());
			doc.setAuthor(documentSlimValue.getAuthor());
			doc.setCategory(documentSlimValue.getCategory());
			doc.setSearchable(documentSlimValue.isSearchable());
			if (documentSlimValue.getDocumentId() != null) {
				getDocumentHbmDao().update(doc);
			} else {
				getDocumentHbmDao().create(doc);
			}

			return doc.getSlimValue();
		} catch (Exception e) {
			throw new UserException(e.getMessage(),e);
		}	}

}