/**
* 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.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
import java.io.StringReader;
import java.sql.Blob;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.Map.Entry;
import java.util.zip.GZIPInputStream;
import javax.ejb.CreateException;
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.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.security.GrantedAuthority;
import org.springframework.security.SpringSecurityException;
import org.springframework.security.context.SecurityContextHolder;
import org.springframework.security.providers.UsernamePasswordAuthenticationToken;
import org.springframework.security.providers.rcp.RemoteAuthenticationManager;
import org.tizzit.util.XercesHelper;
import org.tizzit.util.xml.XMLWriter;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.xml.sax.InputSource;
import org.xml.sax.XMLFilter;
import org.xml.sax.helpers.XMLFilterImpl;
import org.xml.sax.helpers.XMLReaderFactory;
import de.juwimm.cms.authorization.model.UserHbm;
import de.juwimm.cms.authorization.remote.AuthorizationServiceSpring;
import de.juwimm.cms.beans.EditionCronService;
import de.juwimm.cms.common.Constants;
import de.juwimm.cms.common.Constants.LiveserverDeployStatus;
import de.juwimm.cms.components.model.AddressHbm;
import de.juwimm.cms.components.model.DepartmentHbm;
import de.juwimm.cms.components.model.PersonHbm;
import de.juwimm.cms.components.model.TalktimeHbm;
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.HostHbm;
import de.juwimm.cms.model.HostHbmImpl;
import de.juwimm.cms.model.PictureHbm;
import de.juwimm.cms.model.ShortLinkHbm;
import de.juwimm.cms.model.ShortLinkHbmImpl;
import de.juwimm.cms.model.SiteHbm;
import de.juwimm.cms.model.TaskHbm;
import de.juwimm.cms.model.TaskHbmImpl;
import de.juwimm.cms.model.UnitHbm;
import de.juwimm.cms.model.ViewComponentHbm;
import de.juwimm.cms.model.ViewComponentHbmImpl;
import de.juwimm.cms.model.ViewDocumentHbm;
import de.juwimm.cms.remote.helper.AuthenticationHelper;
import de.juwimm.cms.safeguard.model.Realm2viewComponentHbm;
import de.juwimm.cms.safeguard.model.Realm2viewComponentHbmImpl;
import de.juwimm.cms.safeguard.model.RealmJaasHbm;
import de.juwimm.cms.safeguard.model.RealmJdbcHbm;
import de.juwimm.cms.safeguard.model.RealmLdapHbm;
import de.juwimm.cms.safeguard.model.RealmSimplePwHbm;
import de.juwimm.cms.safeguard.model.RealmSimplePwUserHbm;
import de.juwimm.cms.safeguard.model.RealmSimplePwUserHbmDaoImpl;
import de.juwimm.cms.util.EditionBlobContentHandler;
import de.juwimm.cms.vo.EditionValue;
import de.juwimm.cms.vo.ShortLinkValue;
/**
* @see de.juwimm.cms.remote.EditionServiceSpring
* @author <a href="mailto:carsten.schalm@juwimm.com">Carsten Schalm</a> company Juwi|MacMillan Group Gmbh, Walsrode, Germany
* @version $Id$
*/
public class EditionServiceSpringImpl extends EditionServiceSpringBase {
private static Log log = LogFactory.getLog(EditionServiceSpringImpl.class);
@Autowired
EditionCronService editionCronService;
/*
* These Hashtables are needed for the FullEdition-Import only
*/
private Hashtable<Integer, Integer> mappingUnits = null;
private Hashtable<Integer, Integer> mappingUnitsReverse = null;
private Hashtable<Integer, Integer> mappingVDs = null;
private Hashtable<Integer, Integer> mappingVCs = null;
private Hashtable<Integer, Integer> mappingPics = null;
private Hashtable<Integer, Integer> mappingDocs = null;
private Hashtable<Integer, Long> mappingAddresses = null;
private Hashtable<Integer, Long> mappingDepartments = null;
private Hashtable<Integer, Long> mappingPersons = null;
private Hashtable<Integer, Long> mappingTalktime = null;
private Hashtable<String, Integer> startPageBackup = null;
/**
* Key: RealmId, Value: old LoginPageId
*/
private Hashtable<Integer, Integer> loginPagesSimplePwRealmBackup = null;
private Hashtable<Integer, Integer> loginPagesJdbcRealmBackup = null;
private Hashtable<Integer, Integer> loginPagesJaasRealmBackup = null;
private Hashtable<Integer, Integer> loginPagesLdapRealmBackup = null;
private Hashtable<Integer, Integer> loginPagesRealm2viewComponentBackup = null;
private Hashtable<Integer, Integer> mappingRealmsSimplePw = null;
private Hashtable<Integer, Integer> mappingRealmsJdbc = null;
private Hashtable<Integer, Integer> mappingRealmsLdap = null;
private Hashtable<Integer, Integer> mappingRealmsJaas = null;
/**
* Key: old SimplePwRealmId Value: old LoginPageId
*/
private Hashtable<Integer, Integer> loginPagesRealmsSimplePw = null;
private Hashtable<Integer, Integer> loginPagesRealmsJdbc = null;
private Hashtable<Integer, Integer> loginPagesRealmsLdap = null;
private Hashtable<Integer, Integer> loginPagesRealmsJaas = null;
/**
* Key: old protected ViewComponentId Value: old LoginPageId
*/
private Hashtable<Integer, Integer> loginPagesRealm2vc = null;
@Override
public void handleRemoveEdition(Integer editionId) {
EditionHbm edition = getEditionHbmDao().load(editionId);
if (log.isInfoEnabled()) log.info("Deleting edition and attachments: " + edition.getEditionId());
if (edition.getEditionFileName() != null) {
File f = new File(edition.getEditionFileName());
try {
f.delete();
} catch (SecurityException se) {
log.warn("Could not delete file: " + f.getAbsolutePath() + " " + se.getStackTrace());
}
}
//getEditionHbmDao().remove(edition);
}
private Document getDocumentFromFile(File preparsedXMLfile, String editionFileName) throws Exception {
if (log.isInfoEnabled()) log.info("Finished writing Edition to File, starting to import it as GZIP-InputStream...");
XMLFilter filter = new XMLFilterImpl(XMLReaderFactory.createXMLReader());
preparsedXMLfile = File.createTempFile("edition_import_preparsed_", ".xml");
if (log.isDebugEnabled()) log.debug("preparsedXMLfile: " + preparsedXMLfile.getAbsolutePath());
XMLWriter xmlWriter = new XMLWriter(new OutputStreamWriter(new FileOutputStream(preparsedXMLfile)));
filter.setContentHandler(new EditionBlobContentHandler(xmlWriter, preparsedXMLfile));
InputSource saxIn = null;
try {
try {
saxIn = new InputSource(new GZIPInputStream(new FileInputStream(editionFileName)));
} catch (Exception exe) {
saxIn = new InputSource(new BufferedReader(new FileReader(editionFileName)));
}
} catch (FileNotFoundException exe) {
log.error("Edition file isnt available anymore. Edition needs to be deleted!");
}
filter.parse(saxIn);
xmlWriter.flush();
xmlWriter = null;
filter = null;
System.gc();
if (log.isInfoEnabled()) log.info("Finished cutting BLOBs, starting to open XML Document...");
// BufferedReader br = new BufferedReader(new InputStreamReader(inStream, "UTF-8"));
// InputSource in = new InputSource(br);
InputSource domIn = new InputSource(new FileInputStream(preparsedXMLfile));
return XercesHelper.inputSource2Dom(domIn);
}
@Override
public void handleImportEdition(Integer siteId, Integer editionId, String editionFileName, Integer rootVcId, boolean useNewIds) throws Exception {
this.editionCronService.logEditionStatusInfo(LiveserverDeployStatus.ImportStarted, editionId);
mappingUnits = new Hashtable<Integer, Integer>();
mappingUnitsReverse = new Hashtable<Integer, Integer>();
mappingVDs = new Hashtable<Integer, Integer>();
mappingVCs = new Hashtable<Integer, Integer>();
mappingPics = new Hashtable<Integer, Integer>();
mappingDocs = new Hashtable<Integer, Integer>();
mappingAddresses = new Hashtable<Integer, Long>();
mappingDepartments = new Hashtable<Integer, Long>();
mappingPersons = new Hashtable<Integer, Long>();
mappingTalktime = new Hashtable<Integer, Long>();
startPageBackup = new Hashtable<String, Integer>();
mappingRealmsSimplePw = new Hashtable<Integer, Integer>();
mappingRealmsJdbc = new Hashtable<Integer, Integer>();
mappingRealmsLdap = new Hashtable<Integer, Integer>();
mappingRealmsJaas = new Hashtable<Integer, Integer>();
loginPagesRealmsSimplePw = new Hashtable<Integer, Integer>();
loginPagesRealmsJdbc = new Hashtable<Integer, Integer>();
loginPagesRealmsLdap = new Hashtable<Integer, Integer>();
loginPagesRealmsJaas = new Hashtable<Integer, Integer>();
loginPagesRealm2vc = new Hashtable<Integer, Integer>();
File preparsedXMLfile = null;
EditionHbm edition = null;
try {
if (log.isInfoEnabled()) {
if (rootVcId == null) {
log.info("processFileImport for Site: " + siteId);
} else {
log.info("processFileImport for Site: " + siteId + " in the RootVCId: " + rootVcId);
}
}
edition = getEditionHbmDao().load(editionId);
UnitHbm rootUnit = null;
Integer rootUnitId = null;
ViewComponentHbm viewComponent = null;
if (edition.getDeployType().compareTo(Constants.DEPLOY_TYPE_PAGE) == 0 || edition.getDeployType().compareTo(Constants.DEPLOY_TYPE_UNIT) == 0) {
try {
log.info("try to load ViewComponent: " + rootVcId);
viewComponent = getViewComponentHbmDao().load(rootVcId);
rootUnit = viewComponent.getAssignedUnit();
// if (viewComponent.isRoot()) {
// rootVcId = null;
// // context.setRollbackOnly();
// // throw new RuntimeException("You can't import an Unit-Deploy as Root-Unit at this moment");
// }
} catch (Exception e) {
if (log.isInfoEnabled()) log.info("The given rootVcId " + rootVcId + " does not belong to any viewcomponent");
}
}
if (log.isInfoEnabled()) log.info("Finished writing Edition to File, starting to import it as GZIP-InputStream...");
preparsedXMLfile = File.createTempFile("edition_import_preparsed_", ".xml");
Document doc = getDocumentFromFile(preparsedXMLfile, editionFileName);
/*
* DOMParser parser = new DOMParser(); parser.parse(domIn); org.w3c.dom.Document doc = parser.getDocument();
*/
/*
* ####################################################################################
* S T E P 0.5 create/update Site
* ####################################################################################
*/
SiteHbm importSite = null;
try {
importSite = getSiteHbmDao().load(siteId);
} catch (Exception e) {
if (log.isDebugEnabled()) log.debug("Could not find site with Id: " + siteId + " will create it now");
}
boolean siteIsNew = false;
if (importSite == null) {
importSite = SiteHbm.Factory.newInstance();
siteIsNew = true;
importSite.setSiteId(siteId);
} else {
if (log.isDebugEnabled()) log.debug("Site with id: " + siteId + " found - updating it now");
}
Element node = (Element) XercesHelper.findNode(doc, "/edition/site");
importSite.setName(getNValNotNull(node, "name"));
importSite.setShortName(getNValNotNull(node, "shortName"));
importSite.setConfigXML(getNValNotNull(node, "siteConfig"));
importSite.setMandatorDir(getNValNotNull(node, "mandatorDir"));
importSite.setCacheExpire(new Integer(getNVal(node, "cacheExpire")));
importSite.setWysiwygImageUrl(getNValNotNull(node, "wysiwygImageUrl"));
importSite.setHelpUrl(getNValNotNull(node, "helpUrl"));
importSite.setDcfUrl(getNValNotNull(node, "dcfUrl"));
importSite.setPreviewUrlWorkServer(getNValNotNull(node, "previewUrlWorkServer"));
importSite.setPreviewUrlLiveServer(getNValNotNull(node, "previewUrlLiveServer"));
importSite.setPageNameFull(getNValNotNull(node, "pageNameFull"));
importSite.setPageNameContent(getNValNotNull(node, "pageNameContent"));
importSite.setPageNameSearch(getNValNotNull(node, "pageNameSearch"));
importSite.setLastModifiedDate(new Long(getNVal(node, "lastModifiedDate")));
String str = getNVal(node, "rootUnitId");
Integer defaultViewDocumentId_import = null;
Integer siteGroupId_import = null;
if (str != null) {
rootUnitId = Integer.decode(str);
}
str = getNVal(node, "defaultViewDocumentId");
if (str != null) {
defaultViewDocumentId_import = Integer.decode(str);
}
str = getNVal(node, "siteGroupId");
if (str != null) {
siteGroupId_import = new Integer(str);
}
if (siteIsNew) {
getSiteHbmDao().create(importSite);
}
// set this site as active site for user
// in case the site was new it could not be done at login
getUserHbmDao().load(AuthenticationHelper.getUserName()).setActiveSite(importSite);
if (rootUnit != null) {
// if provided a unit import, we will fillup the mapping for this unit
Integer newUnitId = rootUnit.getUnitId();
Element unitNode = (Element) XercesHelper.findNode(doc, "/edition/units/unit");
Integer oldUnitId = new Integer(unitNode.getAttribute("id"));
if (log.isDebugEnabled()) log.debug("mapping for unit-import: OLD:" + oldUnitId + " NEW:" + newUnitId);
mappingUnits.put(oldUnitId, newUnitId);
mappingUnitsReverse.put(newUnitId, oldUnitId);
}
/*
* ####################################################################################
* S T E P 1 Clean the complete Database
* ####################################################################################
*/
//TODO: on UnitDeploy delete just unit relevant stuff, for rootImport site stuff too
this.editionCronService.logEditionStatusInfo(LiveserverDeployStatus.ImportCleanDatabase, editionId);
if (log.isDebugEnabled()) log.debug("Starting with STEP 1/6");
if (edition.getDeployType().compareTo(Constants.DEPLOY_TYPE_ROOT) == 0 || edition.getDeployType().compareTo(Constants.DEPLOY_TYPE_FULL) == 0) {
Collection vdocs = getViewDocumentHbmDao().findAll(siteId);
Iterator vdocsIt = vdocs.iterator();
while (vdocsIt.hasNext()) {
ViewDocumentHbm viewDocument = (ViewDocumentHbm) vdocsIt.next();
if (log.isDebugEnabled()) log.debug("Found VDocument to remove: " + viewDocument.getLanguage() + " " + viewDocument.getViewType());
ViewComponentHbm rootViewComponent = viewDocument.getViewComponent();
if (log.isDebugEnabled()) log.debug("Removing rootVC: " + rootViewComponent.getViewComponentId());
getViewComponentHbmDao().remove(rootViewComponent);
getViewDocumentHbmDao().remove(viewDocument);
if (log.isDebugEnabled()) log.debug("Removing SUCC!");
}
Collection units = getUnitHbmDao().findAll(siteId);
getUnitHbmDao().remove(units);
}
if (edition.getDeployType().compareTo(Constants.DEPLOY_TYPE_UNIT) == 0 || edition.getDeployType().compareTo(Constants.DEPLOY_TYPE_FULL) == 0 || edition.getDeployType().compareTo(Constants.DEPLOY_TYPE_ROOT) == 0) {
ViewComponentHbm rootViewComponent = getViewComponentHbmDao().find4Unit(edition.getUnitId(), edition.getViewDocumentId());
if (rootViewComponent != null) {
Collection vComps = rootViewComponent.getChildren();
while (vComps.iterator().hasNext()) {
ViewComponentHbm vc = (ViewComponentHbm) vComps.iterator().next();
if (vc.getAssignedUnit().equals(rootUnit)) {
Realm2viewComponentHbm r2vc = getRealm2viewComponentHbmDao().findByViewComponent(vc.getViewComponentId());
if (r2vc != null) {
if (r2vc.getJaasRealm() != null) getRealmJaasHbmDao().remove(r2vc.getJaasRealm());
if (r2vc.getJdbcRealm() != null) getRealmJdbcHbmDao().remove(r2vc.getJdbcRealm());
if (r2vc.getLdapRealm() != null) getRealmLdapHbmDao().remove(r2vc.getLdapRealm());
if (r2vc.getSimplePwRealm() != null) getRealmSimplePwHbmDao().remove(r2vc.getSimplePwRealm());
}
}
//vc.getChildren();
}
if (log.isDebugEnabled()) log.debug("Removing rootVC: " + rootViewComponent.getViewComponentId());
//getViewComponentHbmDao().remove(rootViewComponent);
if (log.isDebugEnabled()) log.debug("Removing SUCC!");
} else {
if (log.isDebugEnabled()) log.debug("RootVC: " + edition.getViewDocumentId() + " not found - first deploy?");
}
}
if (edition.getDeployType().compareTo(Constants.DEPLOY_TYPE_PAGE) == 0) {
ViewComponentHbm vc = getViewComponentHbmDao().load(edition.getViewComponentId());
Realm2viewComponentHbm r2vc = getRealm2viewComponentHbmDao().findByViewComponent(vc.getViewComponentId());
if (r2vc != null) {
if (r2vc.getJaasRealm() != null) getRealmJaasHbmDao().remove(r2vc.getJaasRealm());
if (r2vc.getJdbcRealm() != null) getRealmJdbcHbmDao().remove(r2vc.getJdbcRealm());
if (r2vc.getLdapRealm() != null) getRealmLdapHbmDao().remove(r2vc.getLdapRealm());
if (r2vc.getSimplePwRealm() != null) getRealmSimplePwHbmDao().remove(r2vc.getSimplePwRealm());
}
if (log.isDebugEnabled()) log.debug("Removing vC: " + vc.getViewComponentId());
getViewComponentHbmDao().remove(vc);
if (log.isDebugEnabled()) log.debug("Removing SUCC!");
}
/*
* ####################################################################################
* S T E P 2 Import Units WITHOUT IMAGEID, ViewDocuments WITHOUT rootVC, Hosts WITHOUT vcId
* ####################################################################################
*/
this.editionCronService.logEditionStatusInfo(LiveserverDeployStatus.ImportUnits, editionId);
if (log.isDebugEnabled()) log.debug("Starting with STEP 2/6");
if (edition.getDeployType().compareTo(Constants.DEPLOY_TYPE_FULL) == 0 || edition.getDeployType().compareTo(Constants.DEPLOY_TYPE_ROOT) == 0) {
importUnitsAndViewDocumentsAndRealms(doc, siteId, useNewIds);
} else {
// perhaps protected pages should stay protected after an import?
importRealms(doc, siteId, useNewIds);
}
/*
* ####################################################################################
* S T E P 3 Import Pic / Docs, UPDATE Units
* ####################################################################################
*/
this.editionCronService.logEditionStatusInfo(LiveserverDeployStatus.ImportResources, editionId);
if (log.isDebugEnabled()) log.debug("Starting with STEP 3/6");
importDocumentsAndPictures(doc, rootUnit, useNewIds, preparsedXMLfile);
// pics and docs are in full, unit and root
if (edition.getDeployType().compareTo(Constants.DEPLOY_TYPE_PAGE) != 0) {
Collection units = getUnitHbmDao().findAll(siteId);
Iterator unitsIt = units.iterator();
while (unitsIt.hasNext()) {
UnitHbm unit = (UnitHbm) unitsIt.next();
Integer newId = unit.getUnitId();
if (edition.getDeployType().compareTo(Constants.DEPLOY_TYPE_UNIT) == 0 && rootUnit != null && newId.compareTo(rootUnit.getUnitId()) != 0) continue;
Element unitNode = null;
if (useNewIds) {
unitNode = (Element) XercesHelper.findNode(doc, "/edition/units/unit[@id='" + mappingUnitsReverse.get(newId) + "']");
if (log.isDebugEnabled()) log.debug("newId " + newId + " mappingUnitsReverse.get(newId)" + mappingUnitsReverse.get(newId) + " unitNode " + unitNode);
} else {
unitNode = (Element) XercesHelper.findNode(doc, "/edition/units/unit[@id='" + newId + "']");
if (log.isDebugEnabled()) log.debug("newId " + newId + " mappingUnitsReverse.get(newId)" + newId + " unitNode " + unitNode);
}
String imageIdstr = unitNode.getAttribute("imageId");
if (imageIdstr != null && !imageIdstr.equalsIgnoreCase("") && !imageIdstr.equalsIgnoreCase("null")) {
Integer newImageId = new Integer(imageIdstr);
if (useNewIds) {
newImageId = mappingPics.get(newImageId);
}
unit.setImageId(newImageId);
}
String logoIdstr = unitNode.getAttribute("logoId");
if (logoIdstr != null && !logoIdstr.equalsIgnoreCase("") && !logoIdstr.equalsIgnoreCase("null")) {
Integer newLogoId = new Integer(logoIdstr);
if (useNewIds) {
newLogoId = mappingPics.get(newLogoId);
}
unit.setLogoId(newLogoId);
}
}
}
/*
* ####################################################################################
* S T E P 3 U Import Database Components
* ####################################################################################
*/
this.editionCronService.logEditionStatusInfo(LiveserverDeployStatus.ImportDatabaseComponents, editionId);
Iterator it = XercesHelper.findNodes(doc, "/edition/units/unit");
while (it.hasNext()) {
Element unitNode = (Element) it.next();
Integer newUnitId = new Integer(unitNode.getAttribute("id"));
if (useNewIds) {
newUnitId = mappingUnits.get(newUnitId);
}
if (log.isDebugEnabled()) log.debug("Import Database Components for UnitId: " + newUnitId + " (old was:" + unitNode.getAttribute("id") + ")");
UnitHbm unit = getUnitHbmDao().load(newUnitId);
importDatabaseComponents(unitNode, unit, useNewIds);
}
/*
* ####################################################################################
* S T E P 4+5 Import ViewComponents. DONT UPDATE InternalLink IDs Update ViewDocument rootVCIDs
* ####################################################################################
*/
this.editionCronService.logEditionStatusInfo(LiveserverDeployStatus.ImportViewComponents, editionId);
if (log.isDebugEnabled()) log.debug("Starting with STEP 4+5(6)/6");
if (XercesHelper.findNode(doc, "/edition/viewcomponent") != null) {
//if (edition.getDeployType().compareTo(Constants.DEPLOY_TYPE_FULL) == 0) {
if (viewComponent == null) {
Iterator vcNodeIt = XercesHelper.findNodes(doc, "/edition/viewcomponent");
while (vcNodeIt.hasNext()) {
Element vcNode = (Element) vcNodeIt.next();
String oldVcId = vcNode.getAttribute("id");
String oldVdId = null;
try {
oldVdId = ((Element) XercesHelper.findNode(doc, "/edition/viewDocuments/viewDocument[@rootViewComponentId='" + oldVcId + "']")).getAttribute("id");
} catch (Exception e) {
oldVdId = XercesHelper.getNodeValue(vcNode, "./viewDocumentId");
new Integer(oldVdId);
// Integer tempParent = Integer.decode(vcNode.getAttribute("parent"));
// oldVdId = getViewComponentHbmDao().load(tempParent).getViewDocument().getViewDocumentId().toString();
}
Integer newVdlId = new Integer(oldVdId);
if (useNewIds) {
newVdlId = mappingVDs.get(newVdlId);
}
if (log.isDebugEnabled()) log.debug("Importing one of the Root-ViewComponents with oldVcId:" + oldVcId + " oldVdId:" + oldVdId + " newVdlId:" + newVdlId);
ViewDocumentHbm viewDocument = getViewDocumentHbmDao().load(newVdlId);
ViewComponentHbm parentVc = null;
ViewComponentHbm prevVc = null;
Integer id = null;
if ((id = getIntegerAttributeValue(vcNode, "parent")) != null) {
parentVc = getViewComponentHbmDao().load(id);
}
if ((id = getIntegerAttributeValue(vcNode, "prev")) != null) {
prevVc = getViewComponentHbmDao().load(id);
}
ViewComponentHbm rootViewComponent = createViewComponent(null, viewDocument, null, vcNode, parentVc, prevVc, false, 1, useNewIds);
//getViewComponentHbmDao().remove(viewDocument.getViewComponent());
//viewDocument.setViewComponent(rootViewComponent);
}
} else {
// Unit-Import or Unit-Deploy!
{
// backing-up hosts with startpage
Collection hosts = getHostHbmDao().findAllWithStartPage4Site(siteId);
Iterator<HostHbm> hostIt = hosts.iterator();
while (hostIt.hasNext()) {
HostHbm currHost = hostIt.next();
this.startPageBackup.put(currHost.getHostName(), currHost.getStartPage().getViewComponentId());
}
}
Element vcNode = (Element) XercesHelper.findNode(doc, "/edition/viewcomponent");
ViewComponentHbm prev = null;
ViewComponentHbm next = null;
ViewComponentHbm parent = null;
ViewDocumentHbm viewDocument = null;
boolean wasFirstChild = false;
// After removing we need this information to localize the ViewComponent to reimport
prev = viewComponent.getPrevNode();
next = viewComponent.getNextNode();
parent = viewComponent.getParent();
viewDocument = viewComponent.getViewDocument();
if (parent != null && parent.getFirstChild().getViewComponentId().equals(viewComponent.getViewComponentId())) wasFirstChild = true;
// REMOVE
if (log.isDebugEnabled()) {
log.debug("Removing ViewComponent for clean Import: " + viewComponent.getLinkDescription() + " PREV" + viewComponent.getPrevNode() + " NEXT" + viewComponent.getNextNode() + " PARENT" + viewComponent.getParent());
}
ViewComponentHbm temp, temp2;
if (viewComponent.getPrevNode() == null && viewComponent.getNextNode() == null) {
viewComponent.getParent().setFirstChild(null);
} else if (viewComponent.getPrevNode() == null) {
viewComponent.getParent().setFirstChild(viewComponent.getNextNode());
viewComponent.getNextNode().setPrevNode(null);
} else if (viewComponent.getNextNode() != null) {
temp2 = viewComponent.getNextNode();
temp = viewComponent.getPrevNode();
temp2.setPrevNode(temp);
temp.setNextNode(viewComponent.getNextNode());
} else {
viewComponent.getPrevNode().setNextNode(null);
}
if (log.isDebugEnabled()) log.debug("Trying to remove Unit-ViewComponent " + viewComponent.getViewComponentId());
getViewComponentHbmDao().remove(viewComponent);
if (log.isDebugEnabled()) log.debug("SUCC remove!");
Integer myOldUnitId = new Integer(vcNode.getAttribute("unitId"));
//FIXME useNewIds or not
ViewComponentHbm rootview = createViewComponent(myOldUnitId, viewDocument, null, vcNode, parent, prev, false, 2, useNewIds);
if (log.isDebugEnabled()) log.debug("rootview " + rootview + " next " + next);
// Linkname check begin
try {
String linkname = rootview.getUrlLinkName();
rootview.setUrlLinkName(UUID.randomUUID().toString());
if (rootview.hasSiblingsWithLinkName(linkname)) {
int id = 0;
String tempText = "";
while (true) {
id++;
tempText = linkname + id;
if (!rootview.hasSiblingsWithLinkName(tempText)) {
rootview.setUrlLinkName(tempText);
break;
}
}
} else {
rootview.setUrlLinkName(linkname);
}
} catch (Exception exe) {
log.error("Error occured", exe);
}
// Linkname check end
rootview.setNextNode(next);
if (next != null) {
next.setPrevNode(rootview);
}
rootview.setAssignedUnit(rootUnit);
if (wasFirstChild) {
parent.setFirstChild(rootview);
}
if (log.isDebugEnabled()) log.debug("Starting with STEP 6/6 for Unit-Import");
reparseViewComponent(rootview);
}
}
/*
* ####################################################################################
* S T E P 6 Reparse ViewComponents / Content for Internal Links, Pics, Docs Must be done in a second
* 'while', because there could be Internal Links from other languages/viewtypes as well
*
* Importing Hosts, there is no other dependency on them
* ####################################################################################
*/
this.editionCronService.logEditionStatusInfo(LiveserverDeployStatus.ImportHosts, editionId);
if (log.isDebugEnabled()) log.debug("Starting with STEP 6/6");
// hosts are only depoyed with full and root
if (edition.getDeployType().compareTo(Constants.DEPLOY_TYPE_FULL) == 0 || edition.getDeployType().compareTo(Constants.DEPLOY_TYPE_ROOT) == 0) {
Collection vdocs = getViewDocumentHbmDao().findAll(siteId);
Iterator vdocsIt = vdocs.iterator();
while (vdocsIt.hasNext()) {
ViewDocumentHbm vdl = (ViewDocumentHbm) vdocsIt.next();
reparseViewComponent(vdl.getViewComponent());
}
if (log.isDebugEnabled()) log.debug("Root-Deploy, importing Hosts");
importHosts(doc, siteId);
} else {
if (log.isDebugEnabled()) log.debug("Unit-Import, restoring Hosts");
{
Enumeration<String> hosts = this.startPageBackup.keys();
while (hosts.hasMoreElements()) {
try {
String hostName = hosts.nextElement();
Integer startPageId = this.startPageBackup.get(hostName);
HostHbm currHost = getHostHbmDao().load(hostName);
ViewComponentHbm currStartPage = getViewComponentHbmDao().load(startPageId);
currHost.setStartPage(currStartPage);
} catch (Exception e) {
log.warn("Error restoring startpage ", e);
}
}
}
}
this.restoreSafeguardLoginPages(true);
} catch (Exception exe) {
// context.setRollbackOnly();
if (exe.getMessage() != null) {
editionCronService.logEditionStatusException(editionId, exe.getMessage());
} else {
editionCronService.logEditionStatusException(editionId, exe.getClass().toString());
}
log.error("Error occured processFileImport", exe);
throw exe;
} finally {
// try {
// new File(editionFileName).delete();
// } catch (Exception exe) {
// }
// try {
// preparsedXMLfile.delete();
// } catch (Exception exe) {
// }
System.gc();
}
this.editionCronService.logEditionStatusInfo(LiveserverDeployStatus.ImportSuccessful, editionId);
if (log.isInfoEnabled()) log.info("End processFileImport");
}
/**
* @see de.juwimm.cms.remote.EditionServiceSpring#importUnitsAndViewDocumentsAndRealms(org.w3c.dom.Document, Integer, boolean)
*/
@Override
protected void handleImportUnitsAndViewDocumentsAndRealms(org.w3c.dom.Document doc, Integer siteId, boolean useNewIds) throws Exception {
if (log.isDebugEnabled()) log.debug("begin importUnitsAndViewDocumentsAndRealms with useNewIDs=" + useNewIds);
// if (!context.getRollbackOnly()) {
this.importUnits(doc, useNewIds);
// }
// if (!context.getRollbackOnly()) {
this.importViewDocuments(doc, useNewIds);
// }
// if (!context.getRollbackOnly()) {
this.importRealms(doc, siteId, useNewIds);
// }
if (log.isDebugEnabled()) log.debug("end importUnitsAndViewDocumentsAndRealms");
}
private void importUnits(org.w3c.dom.Document doc, boolean useNewIDs) {
if (log.isDebugEnabled()) log.debug("start importUnits with useNewIDs=" + useNewIDs);
try {
if (XercesHelper.findNode(doc, "/edition/units") != null) {
Iterator itUnits = XercesHelper.findNodes(doc, "/edition/units/unit");
while (itUnits.hasNext()) {
Element elmUnit = (Element) itUnits.next();
String unitName = "";
try {
unitName = XercesHelper.getNodeValue(elmUnit).trim();
} catch (Exception exe) {
}
Integer unitId = new Integer(elmUnit.getAttribute("id"));
UnitHbm unit = null;
if (useNewIDs) {
unit = getUnitHbmDao().create(createUnitHbm(unitName, null));
mappingUnits.put(unitId, unit.getUnitId()); // mapping OLD-ID to NEW-ID
mappingUnitsReverse.put(unit.getUnitId(), unitId); // mapping NEW-ID to OLD-ID
} else {
try {
if (log.isDebugEnabled()) log.debug("Searching for unit " + unitId);
unit = getUnitHbmDao().load(unitId);
unit.setName(unitName);
} catch (Exception exe) {
if (log.isDebugEnabled()) log.debug("Creating unit " + unitId + " (" + unitName + ")");
unit = createUnitHbm(unitName, null);
unit.setUnitId(unitId);
unit = getUnitHbmDao().create(unit);
}
Integer imageId = null;
try {
imageId = new Integer(elmUnit.getAttribute("imageId"));
} catch (Exception exe) {
}
unit.setImageId(imageId);
Integer logoId = null;
try {
logoId = new Integer(elmUnit.getAttribute("logoId"));
} catch (Exception exe) {
}
unit.setLogoId(logoId);
}
boolean isRootUnitForThisSite = false;
try {
isRootUnitForThisSite = Boolean.valueOf(elmUnit.getAttribute("isRootUnit")).booleanValue();
} catch (Exception exe) {
}
if (log.isDebugEnabled()) log.debug("The Unit " + unit.getUnitId() + " (" + unit.getName().trim() + ")" + " isRootUnitForThisSite " + isRootUnitForThisSite);
if (isRootUnitForThisSite) {
unit.getSite().setRootUnit(unit);
}
}
} else {
if (log.isDebugEnabled()) log.debug("importUnits reports: There are no /edition/units nodes, so nothing to do");
}
} catch (Exception exe) { // here are also only finder exceptions thrown
// context.setRollbackOnly();
log.error("Error occured importUnits: " + exe.getMessage(), exe);
}
}
private UnitHbm createUnitHbm(String unitName, Integer unitId) {
UnitHbm unit;
if (unitId == null) {
unit = UnitHbm.Factory.newInstance();
} else {
unit = getUnitHbmDao().load(unitId);
}
unit.setName(unitName);
return unit;
}
private void importViewDocuments(org.w3c.dom.Document doc, boolean useNewIDs) {
if (log.isDebugEnabled()) log.debug("start importViewDocuments with useNewIDs=" + useNewIDs);
try {
if (XercesHelper.findNode(doc, "/edition/viewDocuments") != null) {
Iterator itViewDocuments = XercesHelper.findNodes(doc, "/edition/viewDocuments/viewDocument");
while (itViewDocuments.hasNext()) {
if (log.isDebugEnabled()) log.debug("Found ViewDocument to import...");
Element emlViewDocument = (Element) itViewDocuments.next();
Integer vdId = new Integer(emlViewDocument.getAttribute("id"));
Integer rootViewComponentId = new Integer(emlViewDocument.getAttribute("rootViewComponentId"));
String lang = emlViewDocument.getAttribute("language");
String viewType = emlViewDocument.getAttribute("viewType");
if (log.isDebugEnabled()) log.debug("VD " + vdId + " rootVcId " + rootViewComponentId + " language " + lang + " viewType " + viewType);
ViewDocumentHbm vdoc = null;
if (useNewIDs) {
vdoc = getViewDocumentHbmDao().create(createViewDocumentHbm(lang, viewType, null, null));
mappingVDs.put(vdId, vdoc.getViewDocumentId()); // mapping OLD-ID to NEW-ID
} else {
// if (log.isDebugEnabled()) log.debug("...creating...");
try {
if (log.isDebugEnabled()) log.debug("searching ViewDocument: " + vdId);
vdoc = getViewDocumentHbmDao().load(vdId);
//nur um null abzufangen...
vdoc.getViewDocumentId();
} catch (Exception exe) {
if (log.isDebugEnabled()) log.debug("creating ViewDocument: " + vdId);
// vdoc = createViewDocumentHbm(lang, viewType, null, rootViewComponentId);
// vdoc.setViewDocumentId(vdId);
vdoc = getViewDocumentHbmDao().load(getViewDocumentHbmDao().create(lang, viewType, vdId, rootViewComponentId));
}
// only if we are doing a live-deploy, we will create the rootViewComponent as well,
// if it is not existing
Element rootVE = (Element) XercesHelper.findNode(doc, "/edition/viewcomponent");
UnitHbm unit = getUnitHbmDao().load(new Integer(rootVE.getAttribute("unitId")));
vdoc.getViewComponent().setAssignedUnit(unit);
}
boolean isDefaultViewDocumentForThisSite = false;
try {
isDefaultViewDocumentForThisSite = Boolean.valueOf(emlViewDocument.getAttribute("default")).booleanValue();
} catch (Exception exe) {
}
if (log.isDebugEnabled()) log.debug("The ViewDocument " + vdoc.getViewDocumentId() + " (" + vdoc.getViewType() + ", " + vdoc.getLanguage() + ")" + " isDefaultViewDocumentForThisSite " + isDefaultViewDocumentForThisSite);
if (isDefaultViewDocumentForThisSite) {
vdoc.getSite().setDefaultViewDocument(vdoc);
vdoc.getSite().setLastModifiedDate(new Date().getTime());
}
}
} else {
if (log.isDebugEnabled()) log.debug("importViewDocuments reports: There are no /edition/viewDocuments nodes, so nothing to do");
}
} catch (Exception exe) { // here are also only finder exceptions thrown
// context.setRollbackOnly();
log.error("Error occured importViewDocuments: " + exe.getMessage(), exe);
}
}
private ViewDocumentHbm createViewDocumentHbm(String lang, String viewType, Integer vdId, Integer rootViewComponentId) {
ViewDocumentHbm viewDocument = ViewDocumentHbm.Factory.newInstance();
if (lang != null) {
viewDocument.setLanguage(lang);
}
if (viewType != null) {
viewDocument.setViewType(viewType);
}
if (vdId != null) {
viewDocument.setViewDocumentId(vdId);
}
if (rootViewComponentId != null) {
viewDocument.setViewComponent(getViewComponentHbmDao().load(rootViewComponentId));
}
return viewDocument;
}
/**
* This Method imports the database components for the actual unitid given in the edition. <br>
* Will be called from liveserver ONLY. (currently)
*
* @throws UserException
*
* @see de.juwimm.cms.remote.EditionServiceSpring#importDatabaseComponents(org.w3c.dom.Element, de.juwimm.cms.model.UnitHbm, boolean)
*/
protected void importDatabaseComponents(org.w3c.dom.Element unitElm, de.juwimm.cms.model.UnitHbm unit, boolean useNewIds) throws Exception {
if (log.isInfoEnabled()) log.info("begin importDatabaseComponents for unit: " + unit.getName());
// if (!context.getRollbackOnly()) {
try {
if (unitElm != null) {
Integer unitIdFromEdition = new Integer(unitElm.getAttribute("id"));
// old IDs and same unitId
if (!useNewIds && unitIdFromEdition.equals(unit.getUnitId())) {
/*
* If no new IDs, this will be a deploy. In other cases we already have deleted the complete site and setted the unitLogo
*/
try {
unit.setImageId(new Integer(unitElm.getAttribute("imageId")));
} catch (Exception exe) {
if (log.isDebugEnabled()) log.debug("Unit " + unit.getName() + " has no Image: " + exe.getMessage());
}
try {
unit.setLogoId(new Integer(unitElm.getAttribute("logoId")));
} catch (Exception exe) {
if (log.isDebugEnabled()) log.debug("Unit " + unit.getName() + " has no Logo: " + exe.getMessage());
}
if (log.isDebugEnabled()) log.debug("DELETING CURRENT ADDRESSES");
Collection cAddresses = unit.getAddresses();
getAddressHbmDao().remove(cAddresses);
if (log.isDebugEnabled()) log.debug("DELETING CURRENT PERSONS");
Collection<PersonHbm> persons = getPersonHbmDao().findByUnit(unit.getUnitId());
getPersonHbmDao().remove(persons);
if (log.isDebugEnabled()) log.debug("DELETING CURRENT DEPTS");
Collection cDepartments = unit.getDepartments();
getDepartmentHbmDao().remove(cDepartments);
if (log.isDebugEnabled()) log.debug("DELETING CURRENT TTIMES");
Collection<TalktimeHbm> talktimes = getTalktimeHbmDao().findByUnit(unit.getUnitId());
getTalktimeHbmDao().remove(talktimes);
}
// old IDs and same unitID or new IDs and id == oldId from mapping
if ((!useNewIds && unitIdFromEdition.equals(unit.getUnitId())) || (useNewIds && unitIdFromEdition.equals(mappingUnitsReverse.get(unit.getUnitId())))) {
if (log.isDebugEnabled()) log.debug("adding current ADDRESSES");
Iterator itAdr = XercesHelper.findNodes(unitElm, "./address");
while (itAdr.hasNext()) {
Element adrEl = (Element) itAdr.next();
AddressHbm address = createAddressHbm(adrEl, useNewIds, mappingAddresses);
unit.getAddresses().add(address);
}
if (log.isDebugEnabled()) log.debug("adding current PERSONS");
Iterator<Element> itPers = XercesHelper.findNodes(unitElm, "./person");
while (itPers.hasNext()) {
if (log.isDebugEnabled()) log.debug("found person to import");
Element elm = itPers.next();
createPersonHbm(unit, elm, useNewIds, mappingPersons, mappingAddresses, mappingTalktime);
}
if (log.isDebugEnabled()) log.debug("adding current DEPTS");
Iterator itDepts = XercesHelper.findNodes(unitElm, "./department");
while (itDepts.hasNext()) {
Element elm = (Element) itDepts.next();
DepartmentHbm department = createDepartmentHbm(elm, useNewIds, mappingDepartments, mappingPersons, mappingAddresses, mappingTalktime);
department.setUnit(unit);
unit.getDepartments().add(department);
}
if (log.isDebugEnabled()) log.debug("adding current TTIMES");
Iterator<Element> itTTimes = XercesHelper.findNodes(unitElm, "./talktime");
while (itTTimes.hasNext()) {
Element elm = itTTimes.next();
TalktimeHbm talktime = createTalktimeHbm(elm, useNewIds, mappingTalktime);
talktime.setUnit(unit);
}
}
} else {
if (log.isDebugEnabled()) log.debug("importDatabaseComponents reports: There are no /edition/units/unit nodes, so nothing to do");
}
} catch (Exception exe) {
// context.setRollbackOnly();
log.error("Error occured importDatabaseComponents", exe);
}
// }
if (log.isInfoEnabled()) log.info("end importDatabaseComponents for unit: " + unit.getName());
}
private TalktimeHbm createTalktimeHbm(Element ael, boolean useNewIds, Hashtable<Integer, Long> mappingTalktime2) {
TalktimeHbm talktime = TalktimeHbm.Factory.newInstance();
try {
talktime.setTalkTimes(XercesHelper.nodeList2string(XercesHelper.findNode(ael, "./talkTimes").getChildNodes()));
} catch (Exception exe) {
}
talktime.setTalkTimeType(getNVal(ael, "talkTimeType"));
if (!useNewIds) {
talktime.setTalkTimeId(Integer.decode(ael.getAttribute("id")).longValue());
}
talktime = getTalktimeHbmDao().create(talktime);
return talktime;
}
private DepartmentHbm createDepartmentHbm(Element ael, boolean useNewIds, Hashtable<Integer, Long> mappingDepartments2, Hashtable<Integer, Long> mappingPersons2, Hashtable<Integer, Long> mappingAddresses2, Hashtable<Integer, Long> mappingTalktime2) {
DepartmentHbm department = DepartmentHbm.Factory.newInstance();
if (!useNewIds) {
department.setDepartmentId(Integer.decode(getNVal(ael, "id")).longValue());
}
department.setName(ael.getAttribute("name"));
department = getDepartmentHbmDao().create(department);
return department;
}
private PersonHbm createPersonHbm(UnitHbm unit, Element ael, boolean useNewIds, Hashtable<Integer, Long> mappingPersons2, Hashtable<Integer, Long> mappingAddresses2, Hashtable<Integer, Long> mappingTalktime2) throws Exception {
PersonHbm person = PersonHbm.Factory.newInstance();
try {
person.setImageId(Integer.decode(ael.getAttribute("imageid")));
} catch (Exception exe) {
}
try {
person.setBirthDay(getNVal(ael, "birthDay"));
} catch (Exception exe) {
}
try {
person.setCountryJob(getNVal(ael, "countryJob"));
person.setFirstname(getNVal(ael, "firstname"));
person.setJob(getNVal(ael, "job"));
person.setJobTitle(getNVal(ael, "jobTitle"));
person.setLastname(getNVal(ael, "lastname"));
person.setLinkMedicalAssociation(getNVal(ael, "linkMedicalAssociation"));
person.setMedicalAssociation(getNVal(ael, "medicalAssociation"));
person.setPosition(new Byte(getNVal(ael, "position")).byteValue());
person.setSalutation(getNVal(ael, "salutation"));
person.setSex(new Byte(getNVal(ael, "sex")).byteValue());
person.setTitle(getNVal(ael, "title"));
if (!useNewIds) {
person.setPersonId(new Integer(ael.getAttribute("id")).longValue());
}
person.getUnits().add(unit);
person = getPersonHbmDao().create(person);
} catch (Exception exe) {
log.warn("Error setting values: ", exe);
}
try {
if (log.isDebugEnabled()) log.debug("looking for addresses to import for person " + person.getPersonId()); //$NON-NLS-1$
Iterator itAdr = XercesHelper.findNodes(ael, "./address"); //$NON-NLS-1$
while (itAdr.hasNext()) {
Element adrEl = (Element) itAdr.next();
if (log.isDebugEnabled()) log.debug("found address to import"); //$NON-NLS-1$
AddressHbm local = createAddressHbm(adrEl, useNewIds, mappingAddresses);
person.addAddress(local);
}
} catch (Exception exe) {
log.warn("Error importing addresses: ", exe); //$NON-NLS-1$
throw new CreateException(exe.getMessage());
}
try {
if (log.isDebugEnabled()) log.debug("looking for talktimes to import for person " + person.getPersonId()); //$NON-NLS-1$
Iterator itTTimes = XercesHelper.findNodes(ael, "./talktime"); //$NON-NLS-1$
while (itTTimes.hasNext()) {
Element elm = (Element) itTTimes.next();
if (log.isDebugEnabled()) log.debug("found talktime to import"); //$NON-NLS-1$
TalktimeHbm local = createTalktimeHbm(elm, useNewIds, mappingTalktime);
person.addTalktime(local);
}
} catch (Exception exe) {
log.warn("Error importing talktimes: ", exe); //$NON-NLS-1$
throw new Exception(exe.getMessage());
}
return person;
}
private AddressHbm createAddressHbm(Element ael, boolean useNewIds, Hashtable<Integer, Long> mappingAddresses2) {
AddressHbm address = AddressHbm.Factory.newInstance();
address.setAddressType(getNVal(ael, "addressType"));
address.setBuildingLevel(getNVal(ael, "buildingLevel"));
address.setBuildingNr(getNVal(ael, "buildingNr"));
address.setCity(getNVal(ael, "city"));
address.setCountry(getNVal(ael, "country"));
address.setCountryCode(getNVal(ael, "countryCode"));
address.setEmail(getNVal(ael, "email"));
address.setFax(getNVal(ael, "fax"));
address.setHomepage(getNVal(ael, "homepage"));
address.setMisc(getNVal(ael, "misc"));
address.setMobilePhone(getNVal(ael, "mobilePhone"));
address.setPhone1(getNVal(ael, "phone1"));
address.setPhone2(getNVal(ael, "phone2"));
address.setPostOfficeBox(getNVal(ael, "postOfficeBox"));
address.setRoomNr(getNVal(ael, "roomNr"));
address.setStreet(getNVal(ael, "street"));
address.setStreetNr(getNVal(ael, "streetNr"));
address.setZipCode(getNVal(ael, "zipCode"));
if (!useNewIds) {
address.setAddressId(Integer.decode(ael.getAttribute("id")).longValue());
log.info("AddressID: " + address.getAddressId());
}
address = getAddressHbmDao().create(address);
return address;
}
private String getNVal(Element ael, String nodeName) {
String tmp = XercesHelper.getNodeValue(ael, "./" + nodeName);
if (tmp.equals("null") || tmp.equals("")) {
return null;
}
return tmp;
}
private String getNValNotNull(Element ael, String nodeName) {
String tmp = XercesHelper.getNodeValue(ael, "./" + nodeName);
if (tmp.equals("null")) {
return null;
}
return tmp;
}
private Integer getIntegerAttributeValue(Element ael, String attributeName) {
String attribute = ael.getAttribute(attributeName);
Integer retValue = null;
if (attribute != null && !attribute.isEmpty()) {
try {
retValue = Integer.decode(attribute);
} catch (Exception e) {
if (log.isInfoEnabled()) log.info("getIntegerAttributeValue could not find value for key: " + attributeName);
}
}
return retValue;
}
/**
* @see de.juwimm.cms.remote.EditionServiceSpring#importDocumentsAndPictures(org.w3c.dom.Document, de.juwimm.cms.model.UnitHbm, boolean, java.io.File)
*/
protected void importDocumentsAndPictures(org.w3c.dom.Document doc, UnitHbm ul, boolean useNewIds, File directory) throws Exception {
if (log.isInfoEnabled()) log.info("begin importDocumentsAndPictures");
// if (!context.getRollbackOnly()) {
try {
SiteHbm site = getUserHbmDao().load(AuthenticationHelper.getUserName()).getActiveSite();
Iterator itdocs = XercesHelper.findNodes(doc, "/edition/documents/document");
Iterator itpics = XercesHelper.findNodes(doc, "/edition/pictures/picture");
// end of parsing the document
if ((itdocs != null && itdocs.hasNext()) || useNewIds) {
if (log.isDebugEnabled()) log.debug("DELETING DOCS");
Collection docs = null;
if (ul == null) {
docs = getDocumentHbmDao().findAllPerSite(site.getSiteId());
} else {
docs = getDocumentHbmDao().findAll(ul.getUnitId());
}
Iterator it = docs.iterator();
while (it.hasNext()) {
de.juwimm.cms.model.DocumentHbm docl = (de.juwimm.cms.model.DocumentHbm) it.next();
getDocumentHbmDao().remove(docl);
}
if (log.isDebugEnabled()) log.debug("IMPORTING DOCS");
while (itdocs.hasNext()) {
Element el = (Element) itdocs.next();
Integer id = new Integer(el.getAttribute("id"));
String strDocName = XercesHelper.getNodeValue(el, "./name");
String strMimeType = el.getAttribute("mimeType");
int unitId = Integer.decode(el.getAttribute("unitId"));
// byte[] file = Base64.decode(XercesHelper.getNodeValue(el, "./file"));
File fle = new File(directory.getParent() + File.separator + "d" + id);
byte[] file = new byte[(int) fle.length()];
new FileInputStream(fle).read(file);
fle.delete();
if (useNewIds) {
de.juwimm.cms.model.DocumentHbm document = null;
if (ul == null) {
Integer oldUnitId = new Integer(el.getAttribute("unitId"));
Integer newUnitId = mappingUnits.get(oldUnitId);
UnitHbm unitForPic = getUnitHbmDao().load(newUnitId);
document = getDocumentHbmDao().create(createDocumentHbm(file, strDocName, strMimeType, null, unitForPic));
} else {
document = getDocumentHbmDao().create(createDocumentHbm(file, strDocName, strMimeType, null, ul));
}
mappingDocs.put(id, document.getDocumentId());
} else {
if (ul == null) {
ul = getUnitHbmDao().load(unitId);
}
getDocumentHbmDao().create(createDocumentHbm(file, strDocName, strMimeType, id, ul));
}
}
}
System.gc();
if ((itpics != null && itpics.hasNext()) || useNewIds) {
if (log.isDebugEnabled()) log.debug("DELETING PICS");
Collection<PictureHbm> pics = null;
if (ul == null) {
pics = getPictureHbmDao().findAllPerSite(site.getSiteId());
} else {
pics = getPictureHbmDao().findAllPerUnit(ul.getUnitId());
}
getPictureHbmDao().remove(pics);
if (log.isDebugEnabled()) log.debug("IMPORTING PICS");
while (itpics.hasNext()) {
Element el = (Element) itpics.next();
Integer id = new Integer(el.getAttribute("id"));
String strMimeType = el.getAttribute("mimeType");
String strPictureName = XercesHelper.getNodeValue(el, "./pictureName");
String strAltText = XercesHelper.getNodeValue(el, "./altText");
String title = XercesHelper.getNodeValue(el, "./title");
File fle = new File(directory.getParent() + File.separator + "f" + id);
byte[] file = new byte[(int) fle.length()];
new FileInputStream(fle).read(file);
fle.delete();
File fleThumb = new File(directory.getParent() + File.separator + "t" + id);
byte[] thumbnail = new byte[(int) fleThumb.length()];
new FileInputStream(fleThumb).read(thumbnail);
fleThumb.delete();
byte[] preview = null;
File flePreview = new File(directory.getParent() + File.separator + "p" + id);
// not every picture may have a custom preview-image
if (flePreview.exists() && flePreview.canRead()) {
preview = new byte[(int) flePreview.length()];
new FileInputStream(flePreview).read(preview);
flePreview.delete();
}
if (useNewIds) {
PictureHbm pic = null;
if (ul == null) {
Integer oldUnitId = new Integer(el.getAttribute("unitId"));
Integer newUnitId = mappingUnits.get(oldUnitId);
UnitHbm unitForPic = getUnitHbmDao().load(newUnitId);
pic = getPictureHbmDao().create(createPictureHbm(thumbnail, file, preview, strMimeType, strAltText, title, strPictureName, null, unitForPic));
} else {
pic = getPictureHbmDao().create(createPictureHbm(thumbnail, file, preview, strMimeType, strAltText, title, strPictureName, null, ul));
}
if (log.isDebugEnabled()) log.debug("mappingPics OLD " + id + " NEW " + pic.getPictureId());
mappingPics.put(id, pic.getPictureId());
} else {
createPictureHbm(thumbnail, file, preview, strMimeType, strAltText, title, strPictureName, id, ul);
}
}
}
} catch (Exception exe) {
// here are only finder-exceptions thrown. Should not occure, so what to do with it?
// context.setRollbackOnly();
log.error("Error occured importDocumentsAndPictures", exe);
}
// }
if (log.isInfoEnabled()) log.info("end importDocumentsAndPictures");
}
private PictureHbm createPictureHbm(byte[] thumbnail, byte[] file, byte[] preview, String strMimeType, String strAltText, String title, String strPictureName, Integer id, UnitHbm unit) {
PictureHbm picture;
boolean newPicture = (id != null && id == 0) ? true : false;
if (id == null) {
picture = PictureHbm.Factory.newInstance();
} else {
picture = getPictureHbmDao().load(id);
if (picture == null) {
newPicture = true;
picture = PictureHbm.Factory.newInstance();
picture.setPictureId(id);
}
}
picture.setThumbnail(thumbnail);
picture.setPicture(file);
picture.setPreview(preview);
picture.setMimeType(strMimeType);
picture.setAltText(strAltText);
picture.setTitle(title);
picture.setPictureName(strPictureName);
picture.setUnit(unit);
if (newPicture) {
picture = getPictureHbmDao().create(picture);
}
return picture;
}
private DocumentHbm createDocumentHbm(byte[] file, String strDocName, String strMimeType, Integer id, UnitHbm unit) {
DocumentHbm document;
if (id == null) {
document = DocumentHbm.Factory.newInstance();
} else {
document = getDocumentHbmDao().load(id);
if (document == null) {
document = getDocumentHbmDao().load(getDocumentHbmDao().create(file, strDocName, strMimeType, unit, id));
}
}
document.setDocumentName(strDocName);
document.setMimeType(strMimeType);
document.setUnit(unit);
if (id == null) {
document = getDocumentHbmDao().create(document);
}
try {
Blob b = Hibernate.createBlob(file);
document.setDocument(b);
} catch (Exception e) {
log.error("Exception copying document to database", e);
}
return document;
}
/**
* Imports an XML File as Edition for one Unit. <br>
* Important: THIS IS USED FOR IMPORTING EDITIONS AND DEPLOYMENTS AS WELL.
*
* @param doc
* @param ul
* @param viewDocumentId
* @param liveDeploy
* @throws UserException
* @see de.juwimm.cms.remote.EditionServiceSpring#importViewComponentFile(org.w3c.dom.Document, de.juwimm.cms.model.UnitHbm, int, boolean)
*/
protected void importViewComponentFile(org.w3c.dom.Document doc, UnitHbm ul, int viewDocumentId, boolean liveDeploy) throws Exception {
if (log.isDebugEnabled()) log.debug("begin importViewComponentFile");
// if (!context.getRollbackOnly()) {
try {
Node vcompNode = XercesHelper.findNode(doc, "/edition/viewcomponent");
if (vcompNode == null) return;
Element nde = (Element) vcompNode;
ViewDocumentHbm vdl = getViewDocumentHbmDao().load(new Integer(viewDocumentId));
ViewComponentHbm prev = null;
ViewComponentHbm next = null;
ViewComponentHbm parent = null;
ArrayList<ViewComponentHbm> savedUnits = new ArrayList<ViewComponentHbm>();
boolean wasFirstChild = false;
try {
if (log.isInfoEnabled()) log.info("Starting import of ViewComponent File: VDid:" + viewDocumentId + " Unit:" + ul.getUnitId() + " (" + ul.getName().trim() + ")");
ViewComponentHbm view = getViewComponentHbmDao().find4Unit(ul.getUnitId(), new Integer(viewDocumentId));
if (log.isDebugEnabled()) log.debug("Found the VC by UnitId and ViewDocumentId");
boolean isRoot = false;
try {
isRoot = (view.getViewComponentId().intValue() == vdl.getViewComponent().getViewComponentId().intValue());
} catch (Exception e) {
}
if (isRoot) {
try {
if (log.isInfoEnabled()) log.info("Started ROOT-Deploy");
savedUnits = moveContainedUnitsAway(view);
getViewComponentHbmDao().remove(view);
ViewComponentHbm rootview = createViewComponent(ul.getUnitId(), vdl, savedUnits, nde, null, null, liveDeploy, 0, false);
rootview.setAssignedUnit(ul);
vdl.setViewComponent(rootview);
} catch (Exception exe) {
// context.setRollbackOnly();
log.error("Error occured importViewComponentFile ROOT", exe);
}
return;
}
// After removing we need this information to localize the ViewComponent to reimport
prev = view.getPrevNode();
next = view.getNextNode();
parent = view.getParent();
if (log.isDebugEnabled()) if (parent != null) log.debug("parent: " + parent.getViewComponentId());
if (log.isDebugEnabled()) if (parent.getFirstChild() != null) log.debug("parent.getFirstChild(): " + parent.getFirstChild().getViewComponentId());
if (parent != null && parent.getFirstChild().getViewComponentId().equals(view.getViewComponentId())) wasFirstChild = true;
savedUnits = moveContainedUnitsAway(view);
this.startPageBackup = new Hashtable<String, Integer>();
try {
if (log.isDebugEnabled()) log.debug("backing-up hosts with startpage");
Collection hosts = getHostHbmDao().findAllWithStartPage4Site(view.getViewDocument().getSite().getSiteId());
Iterator hostIt = hosts.iterator();
while (hostIt.hasNext()) {
HostHbm currHost = (HostHbm) hostIt.next();
this.startPageBackup.put(currHost.getHostName(), currHost.getStartPage().getViewComponentId());
}
} catch (Exception exe) {
log.error("Error occured backing up host entries!", exe);
}
{
// backup of loginPageIds if pages from other units use a page from this unit for login
this.loginPagesRealm2viewComponentBackup = new Hashtable<Integer, Integer>();
this.loginPagesSimplePwRealmBackup = new Hashtable<Integer, Integer>();
try {
if (log.isDebugEnabled()) log.debug("backing-up loginPages for SimplePwRealms");
Iterator it = getRealmSimplePwHbmDao().findBySiteId(ul.getSite().getSiteId()).iterator();
while (it.hasNext()) {
RealmSimplePwHbm realmSimplePW = (RealmSimplePwHbm) it.next();
if (realmSimplePW.getLoginPageId() != null && realmSimplePW.getLoginPageId().length() > 0) {
try {
ViewComponentHbm loginPage = getViewComponentHbmDao().load(Integer.valueOf(realmSimplePW.getLoginPageId()));
if (loginPage.getUnit4ViewComponent().intValue() == ul.getUnitId().intValue()) this.loginPagesSimplePwRealmBackup.put(realmSimplePW.getSimplePwRealmId(), loginPage.getViewComponentId());
} catch (Exception e) {
// skip faulty loginpage and continue with the rest
}
}
this.backupLoginPages4realm2viewComponents(realmSimplePW.getRealm2viewComponent().iterator(), ul.getUnitId());
}
} catch (Exception e) {
log.error("Error occured backing up loginPages for SimplePwRealms!", e);
}
this.loginPagesJdbcRealmBackup = new Hashtable<Integer, Integer>();
try {
if (log.isDebugEnabled()) log.debug("backing-up loginPages for JdbcRealms");
Iterator it = getRealmJdbcHbmDao().findBySiteId(ul.getSite().getSiteId()).iterator();
while (it.hasNext()) {
RealmJdbcHbm realmJdbc = (RealmJdbcHbm) it.next();
if (realmJdbc.getLoginPageId() != null && realmJdbc.getLoginPageId().length() > 0) {
try {
ViewComponentHbm loginPage = getViewComponentHbmDao().load(Integer.valueOf(realmJdbc.getLoginPageId()));
if (loginPage.getUnit4ViewComponent().intValue() == ul.getUnitId().intValue()) this.loginPagesJdbcRealmBackup.put(realmJdbc.getJdbcRealmId(), view.getViewComponentId());
} catch (Exception e) {
// skip faulty loginpage and continue with the rest
}
}
this.backupLoginPages4realm2viewComponents(realmJdbc.getRealm2viewComponent().iterator(), ul.getUnitId());
}
} catch (Exception e) {
log.error("Error occured backing up loginPages for JdbcRealms!", e);
}
this.loginPagesJaasRealmBackup = new Hashtable<Integer, Integer>();
try {
if (log.isDebugEnabled()) log.debug("backing-up loginPages for JaasRealms");
Iterator it = getRealmJaasHbmDao().findBySiteId(ul.getSite().getSiteId()).iterator();
while (it.hasNext()) {
RealmJaasHbm realmJaas = (RealmJaasHbm) it.next();
if (realmJaas.getLoginPageId() != null && realmJaas.getLoginPageId().length() > 0) {
try {
ViewComponentHbm loginPage = getViewComponentHbmDao().load(Integer.valueOf(realmJaas.getLoginPageId()));
if (loginPage.getUnit4ViewComponent().intValue() == ul.getUnitId().intValue()) this.loginPagesJaasRealmBackup.put(realmJaas.getJaasRealmId(), view.getViewComponentId());
} catch (Exception e) {
// skip faulty loginpage and continue with the rest
}
}
this.backupLoginPages4realm2viewComponents(realmJaas.getRealm2viewComponent().iterator(), ul.getUnitId());
}
} catch (Exception e) {
log.error("Error occured backing up loginPages for JaasRealms!", e);
}
this.loginPagesLdapRealmBackup = new Hashtable<Integer, Integer>();
try {
if (log.isDebugEnabled()) log.debug("backing-up loginPages for LdapRealms");
Iterator it = getRealmLdapHbmDao().findBySiteId(ul.getSite().getSiteId()).iterator();
while (it.hasNext()) {
RealmLdapHbm realmLdap = (RealmLdapHbm) it.next();
if (realmLdap.getLoginPageId() != null && realmLdap.getLoginPageId().length() > 0) {
try {
ViewComponentHbm loginPage = getViewComponentHbmDao().load(Integer.valueOf(realmLdap.getLoginPageId()));
if (loginPage.getUnit4ViewComponent().intValue() == ul.getUnitId().intValue()) this.loginPagesLdapRealmBackup.put(realmLdap.getLdapRealmId(), view.getViewComponentId());
} catch (Exception e) {
log.error("Error occured backing up loginPages for JaasRealms!", e);
// skip faulty loginpage and continue with the rest
}
}
this.backupLoginPages4realm2viewComponents(realmLdap.getRealm2viewComponent().iterator(), ul.getUnitId());
}
} catch (Exception e) {
log.error("Error occured backing up loginPages for LdapRealms!", e);
}
try {
if (log.isDebugEnabled()) log.debug("backing-up loginPages for Realm2viewComponents");
// Iterator it = view.getRealm4login().iterator();
Iterator it = getRealm2viewComponentHbmDao().findByLoginPage(view.getViewComponentId()).iterator();
while (it.hasNext()) {
Realm2viewComponentHbm realm2viewComponent = (Realm2viewComponentHbm) it.next();
this.loginPagesRealm2viewComponentBackup.put(realm2viewComponent.getRealm2viewComponentId(), view.getViewComponentId());
}
} catch (Exception e) {
log.error("Error occured backing up loginPages for Realm2viewComponents!", e);
}
}
// REMOVE
if (log.isDebugEnabled()) log.debug("Removing ViewComponent for clean Import: " + view.getViewComponentId() + " (" + view.getLinkDescription() + ")");
if (view.getPrevNode() == null && view.getNextNode() == null) {
view.getParent().setFirstChild(null);
} else if (view.getPrevNode() == null) {
view.getParent().setFirstChild(view.getNextNode());
view.getNextNode().setPrevNode(null);
} else if (view.getNextNode() != null) {
ViewComponentHbm temp, temp2;
temp2 = view.getNextNode();
temp = view.getPrevNode();
temp2.setPrevNode(temp);
temp.setNextNode(view.getNextNode());
} else {
view.getPrevNode().setNextNode(null);
}
if (log.isDebugEnabled()) log.debug("Trying to remove Unit-ViewComponent " + view.getViewComponentId());
getViewComponentHbmDao().remove(view);
if (log.isDebugEnabled()) log.debug("SUCC remove!");
// REMOVE END
} catch (Exception exe) {
// This is an initial load. Therefor the MOTHER (parent) MUST exist !
// Maybe this is also a dummy-entry. This can't be inserted with UNITID, therefor we have
// to search for the VCID.
if (log.isDebugEnabled()) log.debug("Got Exception");
try {
Integer vcid = new Integer(nde.getAttribute("id"));
ViewComponentHbm view = getViewComponentHbmDao().load(vcid);
if (log.isDebugEnabled()) log.debug("Found VC");
if (view.getReference().equals("DUMMY")) {
if (log.isDebugEnabled()) log.debug("VC is DUMMY");
getViewComponentHbmDao().remove(view);
} else {
if (log.isDebugEnabled()) log.debug("VC is no DUMMY!");
// This can also be an interrupted import! So maybe ignore the stuff and import?
// context.setRollbackOnly();
log.error("ViewComponentFoundButHasNoUnitRelationshipAndIsNotADummy " + vcid + exe);
throw new UserException("ViewComponentFoundButHasNoUnitRelationshipAndIsNotADummy " + vcid);
}
} catch (Exception ex) {
if (log.isDebugEnabled()) log.debug("Got Exception during findByPrimaryKey " + ex.getMessage());
// Occures also, if this VC does not exist. Therefor we do not throw an exception
}
if (nde.getAttribute("parent") != null && !nde.getAttribute("parent").equals("")) {
Integer vcid = new Integer(nde.getAttribute("parent"));
try {
parent = getViewComponentHbmDao().load(vcid);
} catch (Exception ee) {
// context.setRollbackOnly();
log.warn("ParentUnitNeverDeployed " + vcid);
throw new UserException("ParentUnitNeverDeployed " + ee.getMessage() + vcid);
}
if (nde.getAttribute("next") != null && !nde.getAttribute("next").equals("")) {
vcid = new Integer(nde.getAttribute("next"));
try {
next = getViewComponentHbmDao().load(vcid);
} catch (Exception ee) {
ViewComponentHbm viewComponent = createViewComponentHbm(vdl, "DUMMY", "DUMMY", "DUMMY", vcid);
next = getViewComponentHbmDao().create(viewComponent);
next.setViewType(Constants.VIEW_TYPE_CONTENT);
next.setVisible(false);
}
}
if (nde.getAttribute("prev") != null && !nde.getAttribute("prev").equals("")) {
vcid = new Integer(nde.getAttribute("prev"));
try {
prev = getViewComponentHbmDao().load(vcid);
} catch (Exception ee) {
// context.setRollbackOnly();
log.warn("PreviousUnitNeverDeployed");
throw new UserException("PreviousUnitNeverDeployed " + ee.getMessage() + vcid);
}
} else {
wasFirstChild = true;
}
} else {
// For initial load we expect, that there is the parent component.
// So currently we also need the ROOT-VC!
// context.setRollbackOnly();
log.warn("ParentUnitNeverDeployed of vc " + nde.getAttribute("id"));
throw new UserException("ParentUnitNeverDeployed " + exe.getMessage());
}
}
// IMPORT
ViewComponentHbm rootview = createViewComponent(ul.getUnitId(), vdl, savedUnits, nde, parent, prev, liveDeploy, 1, true);
rootview.setNextNode(next);
if (next != null) {
next.setPrevNode(rootview);
}
rootview.setAssignedUnit(ul);
if (wasFirstChild) {
parent.setFirstChild(rootview);
}
// Now we have to catch all childunits, who aren't existent in this Edition. It is possible, that
// an Editor will deploy an old Edition where some of his child-units aren't created.
// Therefor we have to catch them, and put them into another unit (or leave them down under the root unit)
/*
* Iterator it = savedUnits.iterator(); while(it.hasNext()) { ViewComponentLocal savedvc = (ViewComponentLocal) it.next(); }
*/
// We are doing nothing with them. If they are now under another Unit and this Unit will be deployed,
// we will stack them back - so no problem with it.
// If a previous Edition has been deployed, we won't see this unit anymore in the context... So it
// is also needed to deploy the unit who should reference thisone.
// There is currently NO WAY to get this "invisible" unit back, without reimporting the newest edition.
// Maybe we have to find a way for ROOT's, to put them back again.
if (log.isDebugEnabled()) log.debug("Unit-Import, restoring Hosts");
{
Enumeration hosts = this.startPageBackup.keys();
while (hosts.hasMoreElements()) {
try {
String hostName = (String) hosts.nextElement();
Integer startPageId = this.startPageBackup.get(hostName);
HostHbm currHost = getHostHbmDao().load(hostName);
ViewComponentHbm currStartPage = getViewComponentHbmDao().load(startPageId);
currHost.setStartPage(currStartPage);
} catch (Exception e) {
log.warn("Error restoring startpage ", e);
}
}
}
} catch (Exception exe) {
// context.setRollbackOnly();
log.error("Error occured importViewComponentFile", exe);
throw new UserException("UnknownErrorOccuredWhileImportingEdition" + exe.getMessage());
}
// }
if (log.isDebugEnabled()) log.debug("end importViewComponentFile");
}
/**
* This create method takes only mandatory (non-nullable) parameters.
*
* When the client invokes a create method, the EJB container invokes the ejbCreate method. Typically, an ejbCreate method in an entity bean performs the following tasks:
* <UL>
* <LI>Inserts the entity state into the database.</LI>
* <LI>Initializes the instance variables.</LI>
* <LI>Returns the primary key.</LI>
* </UL>
*
* @param viewDocument
* a_ViewDocument
* @param reference
* mandatory CMR field
* @param displayLinkName
* mandatory CMR field
* @param linkDescription
* mandatory CMR field
* @param viewComponentId
* mandatory CMR field
* @return A ViewComponentHbm instance
*
*/
private ViewComponentHbm createViewComponentHbm(ViewDocumentHbm viewDocument, String reference, String displayLinkName, String linkDescription, Integer viewComponentId) {
ViewComponentHbm view = null;
if (viewComponentId == null) {
view = ViewComponentHbm.Factory.newInstance();
} else {
view = getViewComponentHbmDao().load(viewComponentId);
}
view.setDisplayLinkName(displayLinkName);
view.setLinkDescription(linkDescription);
// ?? view.setUrlLinkName(view.getViewComponentId().toString());
if (reference.equals("root")) {
view.setViewType(new Byte("1").byteValue());
} else if (reference.startsWith("content:")) {
view.setReference(reference.substring(8));
view.setViewType(new Byte("1").byteValue());
} else if (reference.startsWith("jump:")) {
view.setReference(reference.substring(5));
view.setViewType(new Byte("2").byteValue());
} else if (reference.equalsIgnoreCase("SEPARATOR")) {
view.setViewType(new Byte("7").byteValue());
} else if (reference.startsWith("link:")) {
view.setReference(reference.substring(5));
view.setViewType(new Byte("3").byteValue());
} else if (reference.startsWith("symlink:")) {
view.setReference(reference.substring(8));
view.setViewType(new Byte("6").byteValue());
} else {
view.setReference(reference);
}
view.setStatus(0);
view.setOnline((byte) 0);
view.setVisible(true);
view.setSearchIndexed(true);
view.setXmlSearchIndexed(true);
return view;
}
private ArrayList<ViewComponentHbm> moveContainedUnitsAway(ViewComponentHbm view) {
if (log.isDebugEnabled()) log.debug("begin moveContainedUnitsAway");
ArrayList<ViewComponentHbm> vec = new ArrayList<ViewComponentHbm>(view.getAllChildrenWithUnits());
for (ViewComponentHbm vcl : vec) {
if (log.isDebugEnabled()) log.debug("MOVING OUT: " + vcl.getViewComponentId() + " " + vcl.getLinkDescription());
ViewComponentHbm prev, next, parent;
prev = vcl.getPrevNode();
next = vcl.getNextNode();
parent = vcl.getParent();
if (prev == null && next == null) {
parent.setFirstChild(null);
} else if (prev == null && next != null) {
parent.setFirstChild(next);
next.setPrevNode(null);
} else if (prev != null && next == null) {
prev.setNextNode(null);
} else {
prev.setNextNode(next);
next.setPrevNode(prev);
}
vcl.setPrevNode(null);
vcl.setNextNode(null);
vcl.setParentViewComponent(null); // ROOTUNITID maybe
}
if (log.isDebugEnabled()) log.debug("end moveContainedUnitsAway");
return vec;
}
/**
* backup Realm2viewComponents and their LoginPages if the LoginPage is located in the given Unit
*/
private void backupLoginPages4realm2viewComponents(Iterator realm2viewComponentIterator, Integer unitId) {
try {
if (log.isDebugEnabled()) log.debug("backing-up loginPages for Realm2viewComponents");
while (realm2viewComponentIterator.hasNext()) {
Realm2viewComponentHbm r = (Realm2viewComponentHbm) realm2viewComponentIterator.next();
if (r.getLoginPage() != null) {
if (r.getLoginPage().getUnit4ViewComponent().intValue() == unitId.intValue()) this.loginPagesRealm2viewComponentBackup.put(r.getRealm2viewComponentId(), r.getLoginPage().getViewComponentId());
}
}
} catch (Exception e) {
log.error("Error occured backing up loginPages for Realm2viewComponents!", e);
}
}
/**
* @see de.juwimm.cms.remote.EditionServiceSpring#importHosts(org.w3c.dom.Document, java.lang.Integer)
*/
@Override
protected void handleImportHosts(org.w3c.dom.Document doc, Integer siteId) throws Exception {
try {
if (log.isInfoEnabled()) log.info("begin importHosts");
Iterator itHosts = XercesHelper.findNodes(doc, "/edition/hosts/host");
if (itHosts.hasNext()) {
HashMap<String, String> redirectHostsMap = new HashMap<String, String>();
if (log.isDebugEnabled()) log.debug("Trying to delete Hosts");
getHostHbmDao().remove(getHostHbmDao().findAll(siteId));
if (log.isDebugEnabled()) log.debug("Trying to add new Hosts");
while (itHosts.hasNext()) {
if (log.isDebugEnabled()) log.debug("Found Host to import...");
Element elHost = (Element) itHosts.next();
String hostName = XercesHelper.getNodeValue(elHost, "./hostName");
String startPageId = XercesHelper.getNodeValue(elHost, "./startPageId");
String unitId = XercesHelper.getNodeValue(elHost, "./unitId");
String redirectUrl = XercesHelper.getNodeValue(elHost, "./redirectUrl");
String redirectHostName = XercesHelper.getNodeValue(elHost, "./redirectHostName");
if (getHostHbmDao().load(hostName) != null) {
if (log.isInfoEnabled()) log.info("wont import host " + hostName + " - it is already assigned to another site");
} else {
if (log.isDebugEnabled()) log.debug("Importing Host-Entry: " + hostName + " startPageId " + startPageId + " for site " + siteId + " and unitId " + unitId);
HostHbm host = new HostHbmImpl();
host.setHostName(hostName.trim());
host = getHostHbmDao().create(host);
// set the site for the current host
if (host != null) {
try {
SiteHbm site = getSiteHbmDao().load(siteId);
if (site != null) host.setSite(site);
} catch (Exception e) {
log.warn("Could not find siteId " + siteId + " or set the site to the current host!");
}
}
if (startPageId != null && !startPageId.equalsIgnoreCase("")) {
try {
ViewComponentHbm viewComponent = getViewComponentHbmDao().load(Integer.valueOf(startPageId));
host.setStartPage(viewComponent);
} catch (Exception exe) {
log.warn("Could not find ViewComponent with Id " + startPageId + " thus no shortlink has been set for host " + hostName);
}
} else {
if (log.isDebugEnabled()) log.debug("haven't found any startPageId for host " + host.getHostName());
}
if (unitId != null && !unitId.equalsIgnoreCase("")) {
try {
UnitHbm unit = getUnitHbmDao().load(Integer.valueOf(unitId));
host.setUnit(unit);
} catch (Exception exe) {
log.warn("Could not find Unit with Id " + unitId + " thus no unit has been set for host " + hostName);
}
} else {
if (log.isDebugEnabled()) log.debug("haven't found any unitId for host " + host.getHostName());
}
if (redirectUrl != null && redirectUrl.length() > 0) {
try {
host.setRedirectUrl(redirectUrl);
} catch (Exception e) {
log.warn("Error setting redirectUrl for host " + host.getHostName());
}
}
// keep in mind the host with redirectHost, these may not be created yet
if (redirectHostName != null && redirectHostName.length() > 0) {
redirectHostsMap.put(hostName, redirectHostName);
}
}
}
// restore redirectHosts
Iterator<String> it = redirectHostsMap.keySet().iterator();
while (it.hasNext()) {
String hostName = it.next();
String redirectHostName = redirectHostsMap.get(hostName);
try {
HostHbm host = getHostHbmDao().load(hostName);
HostHbm redirectHost = getHostHbmDao().load(redirectHostName);
host.setRedirectHostName(redirectHost);
} catch (Exception e) {
log.error("Error restoring redirectHost " + redirectHostName + " for " + hostName + ": " + e.getMessage(), e);
}
}
}
if (log.isInfoEnabled()) log.info("end importHosts");
} catch (Exception exe) {
// context.setRollbackOnly();
throw new UserException("Error recreating the Hosts " + exe.getMessage());
}
}
/**
* Publishs the Edition to the named Liveserver IP Address. <br>
*
* @see de.juwimm.cms.remote.EditionServiceSpring#publishEditionToLiveserver(java.lang.Integer)
*/
@Override
protected void handlePublishEditionToLiveserver(Integer editionId) throws Exception {
String info = "";
editionCronService.logEditionStatusInfo(LiveserverDeployStatus.TransmitDeployFile, editionId);
if (log.isDebugEnabled()) log.debug("start publishing to liveserver process");
try {
String liveServerIP = "";
String liveUserName = "";
String livePassword = "";
SiteHbm site = null;
org.w3c.dom.Document doc = null;
try {
site = getUserHbmDao().load(AuthenticationHelper.getUserName()).getActiveSite();
if (log.isDebugEnabled()) log.debug("siteId: " + site.getSiteId());
doc = XercesHelper.string2Dom(site.getConfigXML());
liveServerIP = XercesHelper.getNodeValue(doc, "/config/default/liveServer/url");
if (log.isDebugEnabled()) log.debug("liveserverIp: " + liveServerIP);
liveUserName = XercesHelper.getNodeValue(doc, "/config/default/liveServer/username");
if (log.isDebugEnabled()) log.debug("liveUserName: " + liveUserName);
livePassword = XercesHelper.getNodeValue(doc, "/config/default/liveServer/password");
if (log.isDebugEnabled()) log.debug("livePassword: " + livePassword);
} catch (Exception exe) {
log.error("Error occured reading siteConfig: ", exe);
} finally {
doc = null;
}
if (liveServerIP == null || liveServerIP.equals("") || "".equalsIgnoreCase(liveUserName)) {
log.error("LiveServerIP is not correct: " + liveServerIP);
throw new UserException("LiveServerIP is not correct: " + liveServerIP);
}
try {
if (log.isInfoEnabled()) log.info("publishEditionToLiveserver - using URL: " + "http://" + liveServerIP);
EditionHbm edition = getEditionHbmDao().load(editionId);
int unitId = edition.getUnitId();
int viewDocumentId = edition.getViewDocumentId();
System.setProperty("tizzit-liveserver.remoteServer", "http://" + liveServerIP);
ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext-deploy.xml");
if (log.isDebugEnabled()) log.debug("ApplicationContext: " + ctx);
try {
SecurityContextHolder.setStrategyName(SecurityContextHolder.MODE_GLOBAL);
RemoteAuthenticationManager remoteAuthenticationService = (RemoteAuthenticationManager) ctx.getBean("remoteRemoteAuthenticationManagerServiceDeploy");
//RemoteAuthenticationManager remoteAuthenticationService = RemoteServiceLocator.instance().getRemoteAuthenticationService();
GrantedAuthority[] authorities = remoteAuthenticationService.attemptAuthentication(liveUserName, String.valueOf(livePassword));
SecurityContextHolder.getContext().setAuthentication(new UsernamePasswordAuthenticationToken(liveUserName, String.valueOf(livePassword), authorities));
log.debug(SecurityContextHolder.getContext().getAuthentication());
} catch (SpringSecurityException e) {
log.info("authentication failed: " + e.getMessage());
throw new UserException(e.getMessage());
}
AuthorizationServiceSpring autoSpring = (AuthorizationServiceSpring) ctx.getBean("authorizationServiceDeploySpring");
if (log.isInfoEnabled()) log.info("Logging in on Liveserver...");
// using remoteLogin in order to not have the site created before the deploy on a site
autoSpring.remoteLoginLive(liveUserName, livePassword);
if (log.isInfoEnabled()) log.info("Successfully logged in!");
if (log.isDebugEnabled()) log.debug("Adding Attachment to Message Call");
InputStream fis = new BufferedInputStream(new FileInputStream(edition.getEditionFileName()));
if (log.isInfoEnabled()) log.info("Try to get bean clientServiceSpring ");
ClientServiceSpring clientServiceSpring = (ClientServiceSpring) ctx.getBean("clientServiceDeploySpring");
if (log.isInfoEnabled()) log.info("Starting transfer to Liveserver - " + info);
clientServiceSpring.importEditionFromImport(fis, edition.getViewComponentId(), false, editionId);
if (log.isInfoEnabled()) log.info("Liveserver has finished deploy - " + info);
if (log.isInfoEnabled()) log.info("Setting the ViewComponents on Work-Server to \"Online\" - " + info);
setViewComponentsOnline(edition);
edition.setNeedsDeploy(false);
getEditionHbmDao().update(edition);
} catch (Exception exe) {
if (log.isDebugEnabled()) log.debug("Rolling back because of error on Liveserver");
throw new UserException(exe.getMessage());
}
if (log.isInfoEnabled()) log.info("Finished Live-Deployment successfully - " + info);
} catch (Exception e) {
editionCronService.logEditionStatusException(editionId, e.getMessage());
throw new UserException(e.getMessage());
}
//editionCronService.logEditionStatusInfo(LiveserverDeployStatus.FileDeployedOnLiveServer, editionId);
}
@SuppressWarnings("unchecked")
private void setViewComponentsOnline(EditionHbm edition) {
// fullDeploy all
// unitDeploy just unit
// pageDeploy just VC
// rootDeploy non
ViewComponentHbm vc = getViewComponentHbmDao().load(edition.getViewComponentId());
if (edition.getDeployType() == Constants.DEPLOY_TYPE_FULL) {
Collection units = getUnitHbmDao().findAll(edition.getSiteId());
Collection vds = getViewDocumentHbmDao().findAll(edition.getSiteId());
for (int unitc = 0; unitc < units.size(); unitc++) {
for (int vdc = 0; vdc < vds.size(); vdc++) {
ViewComponentHbm unitRoot = getViewComponentHbmDao().find4Unit(Integer.valueOf(unitc), Integer.valueOf(vdc));
if (unitRoot != null) {
unitRoot.setUnitOnline();
}
}
}
}
if (edition.getDeployType() == Constants.DEPLOY_TYPE_UNIT) {
vc.setUnitOnline();
}
if (edition.getDeployType() == Constants.DEPLOY_TYPE_PAGE) {
vc.setStatus(Constants.DEPLOY_STATUS_DEPLOYED);
vc.setOnline(Constants.ONLINE_STATUS_ONLINE);
}
}
/**
* @see de.juwimm.cms.remote.EditionServiceSpring#createLiveDeploy(java.lang.String, java.lang.String, java.lang.Integer, boolean, boolean)
*/
@Override
protected void handleCreateLiveDeploy(String userName, String comment, Integer rootViewComponentId, boolean deploy, boolean showMessage) throws Exception {
if (rootViewComponentId != null) {
UserHbm user = null;
EditionHbm edition = null;
String unitName = "";
try {
unitName = getViewComponentHbmDao().load(rootViewComponentId).getAssignedUnit().getName();
if (unitName != null) {
unitName = "(" + unitName.trim() + ")";
} else {
unitName = "";
}
} catch (Exception e) {
log.warn("Unit not found for ViewComponent " + rootViewComponentId + ": " + e.getMessage(), e);
}
try {
if (log.isInfoEnabled()) log.info("Start creating Edition for ViewComponent " + rootViewComponentId + " " + unitName);
EditionHbm editionTemp = this.createEditionHbm(comment, rootViewComponentId, null, !deploy);
edition = getEditionHbmDao().create(editionTemp);
if (log.isInfoEnabled()) log.info("Finished creating Edition for ViewComponent " + rootViewComponentId + " " + unitName);
Collection coll = getEditionHbmDao().findByUnitAndOnline(new Integer(edition.getUnitId()));
if (log.isDebugEnabled()) log.debug("Finished findByUnitAndOnline");
Iterator it = coll.iterator();
while (it.hasNext()) {
if (log.isDebugEnabled()) log.debug("Starting to disable old Edition");
EditionHbm eded = (EditionHbm) it.next();
eded.setStatus((byte) 0);
if (log.isDebugEnabled()) log.debug("setStatus " + eded.getEditionId());
}
if (log.isDebugEnabled()) log.debug("setting status = 1");
edition.setStatus((byte) 1);
if (log.isDebugEnabled()) log.debug("finished setting status = 1");
} catch (Exception exe) {
if (user == null) {
log.error("USER HAS NOT BEEN FOUND WHILE CREATING THE EDITION");
} else if (edition == null) {
log.error("Unknown Error while creating the Edition");
} else {
createUserTask(userName, exe.toString(), rootViewComponentId, Constants.TASK_SYSTEMMESSAGE_ERROR, true);
}
log.error("Error occured in createLiveDeploy: ", exe);
return;
}
if (deploy) {
try {
if (log.isDebugEnabled()) log.debug("Starting calling publishEditionToLiveserver");
this.publishEditionToLiveserver(edition.getEditionId());
if (log.isDebugEnabled()) log.debug("Publish to liveServer sucessfully called!");
createUserTask(userName, "CreateEditionAndDeploy", rootViewComponentId, Constants.TASK_SYSTEMMESSAGE_INFORMATION, showMessage);
} catch (Exception re) {
log.error("Error occured in createLiveDeploy: ", re);
String errMsg = "";
errMsg = re.getMessage();
createUserTask(userName, errMsg, rootViewComponentId, Constants.TASK_SYSTEMMESSAGE_ERROR, true);
// TODO without the rollback the task is stored and delivered...
// context.setRollbackOnly();
}
} else {
createUserTask(userName, "CreateEdition", rootViewComponentId, Constants.TASK_SYSTEMMESSAGE_INFORMATION, showMessage);
}
} else {
log.error("RootViewComponentId must not be Null for creating an Edition!");
}
}
private EditionHbm createEditionHbm(String comment, Integer rootViewComponentId, PrintStream out, boolean includeUnused) {
EditionHbm edition = EditionHbm.Factory.newInstance();
edition.setStatus((byte) 0);
edition.setCreationDate((System.currentTimeMillis()));
edition.setComment(comment);
return edition;
}
/**
* @see de.juwimm.cms.remote.EditionServiceSpring#createUserTask(java.lang.String, java.lang.String, java.lang.Integer, byte, boolean)
*/
@Override
protected void handleCreateUserTask(String user, String why, Integer rootViewComponentId, byte taskType, boolean showMessage) throws Exception {
if (log.isDebugEnabled()) log.debug("createTask: User " + user + " Message " + why + " rootViewComponent " + rootViewComponentId + " taskType " + taskType + " showMessage " + Boolean.toString(showMessage));
if (showMessage) {
if (user != null && !user.equals("")) {
try {
Integer unitId = this.getUnit4ViewComponent(rootViewComponentId);
this.createTask(user, null, unitId, why, taskType);
if (log.isDebugEnabled()) log.debug("Send the information-task to the user " + user);
} catch (Exception exe) {
log.error("Error occured creating task for user " + user, exe);
}
}
}
}
private Integer createTask(String receiverUserId, String receiverRole, Integer unitId, String comment, byte taskType) throws UserException {
TaskHbm task = null;
TaskHbm temp = null;
try {
if (receiverUserId != null) {
UserHbm receiver = getUserHbmDao().load(receiverUserId);
temp = createTaskHbm(receiver, null, unitId, comment, taskType);
task = getTaskHbmDao().create(temp);
} else {
temp = createTaskHbm(null, receiverRole, unitId, comment, taskType);
task = getTaskHbmDao().create(temp);
}
} catch (Exception e) {
throw new UserException(e.getMessage());
}
return task.getTaskId();
}
private TaskHbm createTaskHbm(UserHbm receiver, String receiverRole, Integer unitId, String comment, byte taskType) {
TaskHbm task = new TaskHbmImpl();
task.setReceiver(receiver);
task.setReceiverRole(receiverRole);
task.setUnit(getUnitHbmDao().load(unitId));
task.setComment(comment);
task.setTaskType(taskType);
return task;
}
private Integer getUnit4ViewComponent(Integer viewComponentId) throws UserException {
try {
ViewComponentHbm view = getViewComponentHbmDao().load(viewComponentId);
if (view.getAssignedUnit() != null) {
return view.getAssignedUnit().getUnitId();
}
return view.getUnit4ViewComponent();
} catch (Exception e) {
throw new UserException(e.getMessage());
}
}
@Override
protected void handleRestoreSafeguardLoginPages(boolean useNewIds) throws Exception {
if (log.isDebugEnabled()) log.debug("start restoreSafeguard with useNewIDs=" + useNewIds);
if (log.isInfoEnabled()) log.info("begin restoreSafeguardLoginPages");
try {
if (this.loginPagesRealmsSimplePw != null) {
Iterator it = this.loginPagesRealmsSimplePw.keySet().iterator();
while (it.hasNext()) {
Integer simplePwRealmId = (Integer) it.next();
Integer loginPageId = this.loginPagesRealmsSimplePw.get(simplePwRealmId);
if (useNewIds) {
simplePwRealmId = this.mappingRealmsSimplePw.get(simplePwRealmId);
loginPageId = this.mappingVCs.get(loginPageId);
}
if (simplePwRealmId != null && loginPageId != null) {
RealmSimplePwHbm realm = getRealmSimplePwHbmDao().load(simplePwRealmId);
realm.setLoginPageId(loginPageId.toString());
}
}
}
if (this.loginPagesRealmsJdbc != null) {
Iterator it = this.loginPagesRealmsJdbc.keySet().iterator();
while (it.hasNext()) {
Integer jdbcRealmId = (Integer) it.next();
Integer loginPageId = this.loginPagesRealmsJdbc.get(jdbcRealmId);
if (useNewIds) {
jdbcRealmId = this.mappingRealmsJdbc.get(jdbcRealmId);
loginPageId = this.mappingVCs.get(loginPageId);
}
if (jdbcRealmId != null && loginPageId != null) {
RealmJdbcHbm realm = getRealmJdbcHbmDao().load(jdbcRealmId);
realm.setLoginPageId(loginPageId.toString());
}
}
}
if (this.loginPagesRealmsLdap != null) {
Iterator it = this.loginPagesRealmsLdap.keySet().iterator();
while (it.hasNext()) {
Integer ldapRealmId = (Integer) it.next();
Integer loginPageId = this.loginPagesRealmsLdap.get(ldapRealmId);
if (useNewIds) {
ldapRealmId = this.mappingRealmsLdap.get(ldapRealmId);
loginPageId = this.mappingVCs.get(loginPageId);
}
if (ldapRealmId != null && loginPageId != null) {
RealmLdapHbm realm = getRealmLdapHbmDao().load(ldapRealmId);
realm.setLoginPageId(loginPageId.toString());
}
}
}
if (this.loginPagesRealmsJaas != null) {
Iterator it = this.loginPagesRealmsJaas.keySet().iterator();
while (it.hasNext()) {
Integer jaasRealmId = (Integer) it.next();
Integer loginPageId = this.loginPagesRealmsJaas.get(jaasRealmId);
if (useNewIds) {
jaasRealmId = this.mappingRealmsJaas.get(jaasRealmId);
loginPageId = this.mappingVCs.get(loginPageId);
}
if (jaasRealmId != null && loginPageId != null) {
RealmJaasHbm realm = getRealmJaasHbmDao().load(jaasRealmId);
realm.setLoginPageId(loginPageId.toString());
}
}
}
if (this.loginPagesRealm2vc != null) {
Iterator it = this.loginPagesRealm2vc.keySet().iterator();
while (it.hasNext()) {
Integer viewComponentId = (Integer) it.next();
Integer loginPageId = this.loginPagesRealm2vc.get(viewComponentId);
if (useNewIds) {
viewComponentId = this.mappingVCs.get(viewComponentId);
loginPageId = this.mappingVCs.get(loginPageId);
}
if (viewComponentId != null && loginPageId != null) {
ViewComponentHbm protectedViewComponent = getViewComponentHbmDao().load(viewComponentId);
ViewComponentHbm loginPage = getViewComponentHbmDao().load(loginPageId);
protectedViewComponent.getRealm2vc().setLoginPage(loginPage);
}
}
}
if (!useNewIds) {
// only after deploy restore loginpages for realm used in other units
if (this.loginPagesSimplePwRealmBackup != null) {
Iterator it = this.loginPagesSimplePwRealmBackup.keySet().iterator();
while (it.hasNext()) {
Integer realmId = (Integer) it.next();
Integer loginPageId = this.loginPagesSimplePwRealmBackup.get(realmId);
RealmSimplePwHbm realm = null;
try {
realm = getRealmSimplePwHbmDao().load(realmId);
} catch (Exception e) {
if (log.isDebugEnabled()) log.debug("SimplePwRealm " + realmId + " does not exist any more");
continue;
}
ViewComponentHbm loginPage = null;
try {
loginPage = getViewComponentHbmDao().load(loginPageId);
} catch (Exception e) {
if (log.isDebugEnabled()) log.debug("LoginPage " + loginPageId + " does not exist any more");
continue;
}
if (realm != null && loginPage != null) {
realm.setLoginPageId(loginPageId.toString());
}
}
}
if (this.loginPagesJdbcRealmBackup != null) {
Iterator it = this.loginPagesJdbcRealmBackup.keySet().iterator();
while (it.hasNext()) {
Integer realmId = (Integer) it.next();
Integer loginPageId = this.loginPagesJdbcRealmBackup.get(realmId);
RealmJdbcHbm realm = null;
try {
realm = getRealmJdbcHbmDao().load(realmId);
} catch (Exception e) {
if (log.isDebugEnabled()) log.debug("JdbcRealm " + realmId + " does not exist any more");
continue;
}
ViewComponentHbm loginPage = null;
try {
loginPage = getViewComponentHbmDao().load(loginPageId);
} catch (Exception e) {
if (log.isDebugEnabled()) log.debug("LoginPage " + loginPageId + " does not exist any more");
continue;
}
if (realm != null && loginPage != null) {
realm.setLoginPageId(loginPageId.toString());
}
}
}
if (this.loginPagesJaasRealmBackup != null) {
Iterator it = this.loginPagesJaasRealmBackup.keySet().iterator();
while (it.hasNext()) {
Integer realmId = (Integer) it.next();
Integer loginPageId = this.loginPagesJaasRealmBackup.get(realmId);
RealmJaasHbm realm = null;
try {
realm = getRealmJaasHbmDao().load(realmId);
} catch (Exception e) {
if (log.isDebugEnabled()) log.debug("JaasRealm " + realmId + " does not exist any more");
continue;
}
ViewComponentHbm loginPage = null;
try {
loginPage = getViewComponentHbmDao().load(loginPageId);
} catch (Exception e) {
if (log.isDebugEnabled()) log.debug("LoginPage " + loginPageId + " does not exist any more");
continue;
}
if (realm != null && loginPage != null) {
realm.setLoginPageId(loginPageId.toString());
}
}
}
if (this.loginPagesLdapRealmBackup != null) {
Iterator it = this.loginPagesLdapRealmBackup.keySet().iterator();
while (it.hasNext()) {
Integer realmId = (Integer) it.next();
Integer loginPageId = this.loginPagesLdapRealmBackup.get(realmId);
RealmLdapHbm realm = null;
try {
realm = getRealmLdapHbmDao().load(realmId);
} catch (Exception e) {
if (log.isDebugEnabled()) log.debug("LdapRealm " + realmId + " does not exist any more");
continue;
}
ViewComponentHbm loginPage = null;
try {
loginPage = getViewComponentHbmDao().load(loginPageId);
} catch (Exception e) {
if (log.isDebugEnabled()) log.debug("LoginPage " + loginPageId + " does not exist any more");
continue;
}
if (realm != null && loginPage != null) {
realm.setLoginPageId(loginPageId.toString());
}
}
}
if (this.loginPagesRealm2viewComponentBackup != null) {
Iterator it = this.loginPagesRealm2viewComponentBackup.keySet().iterator();
while (it.hasNext()) {
Integer realmId = (Integer) it.next();
Integer loginPageId = this.loginPagesRealm2viewComponentBackup.get(realmId);
Realm2viewComponentHbm realm = null;
try {
realm = getRealm2viewComponentHbmDao().load(realmId);
} catch (Exception e) {
if (log.isDebugEnabled()) log.debug("Realm2viewComponent " + realmId + " does not exist any more");
continue;
}
ViewComponentHbm loginPage = null;
try {
loginPage = getViewComponentHbmDao().load(loginPageId);
} catch (Exception e) {
if (log.isDebugEnabled()) log.debug("LoginPage " + loginPageId + " does not exist any more");
continue;
}
if (realm != null && loginPage != null) {
realm.setLoginPage(loginPage);
loginPage.getRealm4login().add(realm);
}
}
}
}
} catch (Exception e) {
log.warn("Error occured restoring LoginPages: " + e.getMessage(), e);
}
if (log.isInfoEnabled()) log.info("end restoreSafeguardLoginPages");
}
/**
* #################################################################################### S T E P 6 Reparse ViewComponents / Content for Internal Links, Pics, Docs
* ####################################################################################
*/
private void reparseViewComponent(ViewComponentHbm vcl) throws Exception {
// if (!context.getRollbackOnly()) {
try {
String ref = vcl.getReference();
if (log.isDebugEnabled()) log.debug("Reparsing VC: " + vcl.getDisplayLinkName());
switch (vcl.getViewType()) {
case Constants.VIEW_TYPE_EXTERNAL_LINK: // dont do anythink at the external link
case Constants.VIEW_TYPE_SEPARATOR:
break;
case Constants.VIEW_TYPE_INTERNAL_LINK:
case Constants.VIEW_TYPE_SYMLINK:
String newRefId = ref;
try {
newRefId = mappingVCs.get(new Integer(ref)).toString();
} catch (Exception exe) {
log.warn("Error while changing ref: " + ref + " to " + newRefId + " : " + exe.getMessage());
}
vcl.setReference(newRefId);
break;
case Constants.VIEW_TYPE_CONTENT:
case Constants.VIEW_TYPE_UNIT:
default:
if (log.isDebugEnabled()) log.debug("Reparsing Content of VC to Ref: " + ref);
if (ref != null && !ref.equalsIgnoreCase("") && !ref.equalsIgnoreCase("root")) {
ContentHbm content = null;
try {
content = getContentHbmDao().load(new Integer(ref));
} catch (Exception e) {
log.warn("Cannot find referenced content " + ref + " - continue import");
}
if (content != null) {
Collection cvlColl = content.getContentVersions();
Iterator cvlIt = cvlColl.iterator();
while (cvlIt.hasNext()) {
ContentVersionHbm cvl = (ContentVersionHbm) cvlIt.next();
String text = cvl.getText();
if (text != null && !text.equalsIgnoreCase("")) {
org.w3c.dom.Document doc = null;
try {
InputSource in = new InputSource(new StringReader(text));
doc = XercesHelper.inputSource2Dom(in);
} catch (Exception exe) {
}
if (doc != null) {
if (log.isDebugEnabled()) log.debug("Found ContentVersion: " + cvl.getContentVersionId() + " with DOC");
Iterator itILinks = XercesHelper.findNodes(doc, "//internalLink/internalLink");
while (itILinks.hasNext()) {
Element elm = (Element) itILinks.next();
String oldId = elm.getAttribute("viewid");
try {
System.out.println("oldId " + oldId);
String newId = mappingVCs.get(new Integer(oldId)).toString();
elm.setAttribute("viewid", newId);
} catch (Exception exe) {
}
}
Iterator itPics = XercesHelper.findNodes(doc, "//image[@src]");
while (itPics.hasNext()) {
Element elm = (Element) itPics.next();
String oldId = elm.getAttribute("src");
try {
String newId = mappingPics.get(new Integer(oldId)).toString();
if (log.isDebugEnabled()) log.debug("newId " + newId);
elm.setAttribute("src", newId);
((Element) elm.getParentNode()).setAttribute("description", newId);
} catch (Exception exe) {
}
}
Iterator itDocs = XercesHelper.findNodes(doc, "//documents/document");
while (itDocs.hasNext()) {
Element elm = (Element) itDocs.next();
String oldId = elm.getAttribute("src");
try {
String newId = mappingDocs.get(new Integer(oldId)).toString();
elm.setAttribute("src", newId);
content.setUpdateSearchIndex(true);
} catch (Exception exe) {
}
}
/*
* Here the reparsing of the database components has to be called
*/
Iterator itAggregation = XercesHelper.findNodes(doc, "//aggregation//include");
while (itAggregation.hasNext()) {
try {
Element ndeInclude = (Element) itAggregation.next();
String type = ndeInclude.getAttribute("type");
Long id = new Long(ndeInclude.getAttribute("id"));
if (type.equals("person")) {
if (mappingPersons.containsKey(id)) {
Long newId = mappingPersons.get(id);
ndeInclude.setAttribute("id", newId.toString());
}
} else if (type.equals("address")) {
if (mappingAddresses.containsKey(id)) {
Long newId = mappingAddresses.get(id);
ndeInclude.setAttribute("id", newId.toString());
}
} else if (type.equals("unit")) {
// Unit hat Integer Primary Keys
if (mappingUnits.containsKey(new Integer(id.intValue()))) {
Integer newId = mappingUnits.get(new Integer(id.intValue()));
ndeInclude.setAttribute("id", newId.toString());
}
} else if (type.equals("department")) {
if (mappingDepartments.containsKey(id)) {
Long newId = mappingDepartments.get(id);
ndeInclude.setAttribute("id", newId.toString());
}
} else if (type.equals("talkTime")) {
if (mappingTalktime.containsKey(id)) {
Long newId = mappingTalktime.get(id);
ndeInclude.setAttribute("id", newId.toString());
}
}
} catch (Exception exe) {
log.error("Error during the replacement of database components:", exe);
}
}
// READY
text = XercesHelper.doc2String(doc);
cvl.setText(text);
}
}
}
}
}
// children
if (vcl.getFirstChild() != null) {
reparseViewComponent(vcl.getFirstChild());
}
break;
}
// next
if (vcl.getNextNode() != null) {
reparseViewComponent(vcl.getNextNode());
}
} catch (Exception exe) {
// context.setRollbackOnly();
throw exe;
}
// }
}
private Realm2viewComponentHbm createTempRealm(ViewComponentHbm viewComponent, String neededRole, RealmJdbcHbm jdbcRealm, RealmSimplePwHbm simplePWRealm, RealmLdapHbm ldapRealm, RealmJaasHbm jaasRealm) {
Realm2viewComponentHbm tempRealm = new Realm2viewComponentHbmImpl();
tempRealm.setViewComponent(viewComponent);
tempRealm.setRoleNeeded(neededRole);
if (jdbcRealm != null) {
tempRealm.setJdbcRealm(getRealmJdbcHbmDao().load(jdbcRealm.getJdbcRealmId()));
}
if (simplePWRealm != null) {
tempRealm.setSimplePwRealm(getRealmSimplePwHbmDao().load(simplePWRealm.getSimplePwRealmId()));
}
if (ldapRealm != null) {
tempRealm.setLdapRealm(getRealmLdapHbmDao().load(ldapRealm.getLdapRealmId()));
}
if (jaasRealm != null) {
tempRealm.setJaasRealm(getRealmJaasHbmDao().load(jaasRealm.getJaasRealmId()));
}
return tempRealm;
}
/**
* @param fulldeploy
* means, if this is an import of an Full-Edition, Unit-Edition or Live-Deploy
* <ul>
* <li>0 - means LiveDeploy</li>
* <li>1 - means Fulldeploy of an FullEdition</li>
* <li>2 - means Fulldeploy of an UnitEdition</li>
* </ul>
*/
private ViewComponentHbm createViewComponent(Integer unitId, ViewDocumentHbm viewDocument, ArrayList<ViewComponentHbm> savedUnits, Element nde, ViewComponentHbm parent, ViewComponentHbm prev, boolean livedeploy, int fulldeploy, boolean useNewIds) throws Exception {
boolean reusePrimaryKey = (fulldeploy == 0);
ViewComponentHbm viewComponent = null;
try {
Integer myUnitId = new Integer(nde.getAttribute("unitId"));
Integer vcId = new Integer(nde.getAttribute("id"));
if (fulldeploy == 2 && !myUnitId.equals(unitId)) {
return null;
} else if (fulldeploy > 0 || myUnitId.equals(unitId)) {
String reference = XercesHelper.getNodeValue(nde, "./reference");
String linkName = XercesHelper.getNodeValue(nde, "./linkName");
String approvedLinkName = XercesHelper.getNodeValue(nde, "./approvedLinkName");
String statusInfo = XercesHelper.getNodeValue(nde, "./statusInfo");
String urlLinkName = XercesHelper.getNodeValue(nde, "./urlLinkName");
byte viewType = new Byte(XercesHelper.getNodeValue(nde, "./viewType")).byteValue();
boolean visible = Boolean.valueOf(XercesHelper.getNodeValue(nde, "./visible")).booleanValue();
if (livedeploy && (viewType == Constants.VIEW_TYPE_CONTENT || viewType == Constants.VIEW_TYPE_UNIT)) {
Node publsh = XercesHelper.findNode(nde, "./content/contentVersion/version[string()='PUBLS']");
if (log.isDebugEnabled()) log.debug("viewType " + viewType);
if (publsh == null) {
if (log.isDebugEnabled()) log.debug("Haven't found a Cool-Online-Version (PUBLS), does not create VC " + vcId);
return null;
}
}
if (fulldeploy > 0) {
if (useNewIds) {
viewComponent = getViewComponentHbmDao().create(viewDocument, reference, linkName, statusInfo, urlLinkName, null);
viewComponent.setApprovedLinkName(approvedLinkName);
mappingVCs.put(vcId, viewComponent.getViewComponentId());
} else {
// viewDocs can only be crated with viewComps
if (viewDocument.getViewComponent().getViewComponentId().compareTo(vcId) == 0) {
viewComponent = viewDocument.getViewComponent();
} else {
viewComponent = getViewComponentHbmDao().load(vcId);
}
if (viewComponent == null) {
viewComponent = getViewComponentHbmDao().create(viewDocument, reference, linkName, statusInfo, urlLinkName, vcId);
} else {
viewComponent.setDisplayLinkName(linkName);
viewComponent.setViewDocument(viewDocument);
viewComponent.setReference(reference);
viewComponent.setUrlLinkName(urlLinkName);
viewComponent.setLinkDescription(statusInfo);
}
viewComponent.setApprovedLinkName(approvedLinkName);
mappingVCs.put(vcId, vcId);
}
if (fulldeploy == 1) {
Integer newUnitId = mappingUnits.get(myUnitId);
if (newUnitId == null) {
newUnitId = myUnitId;
}
if (unitId == null || !newUnitId.equals(unitId)) {
if (log.isDebugEnabled()) log.debug("newUnitId " + newUnitId + " myUnitId " + myUnitId);
UnitHbm unit = getUnitHbmDao().load(newUnitId);
viewComponent.setAssignedUnit(unit);
unitId = unit.getUnitId();
}
}
} else {
try {
if (log.isDebugEnabled()) log.debug("searching ViewComponent: " + vcId);
viewComponent = getViewComponentHbmDao().load(vcId);
viewComponent.setViewDocument(viewDocument);
viewComponent.setReference(reference);
viewComponent.setDisplayLinkName(linkName);
viewComponent.setLinkDescription(statusInfo);
viewComponent.setUrlLinkName(urlLinkName);
viewComponent.setApprovedLinkName(approvedLinkName);
} catch (Exception e) {
if (log.isDebugEnabled()) log.debug("error, creating ViewComponent: " + vcId);
ViewComponentHbm tempVC = new ViewComponentHbmImpl();
tempVC.setViewDocument(viewDocument);
tempVC.setReference(reference);
tempVC.setLinkDescription(linkName);
tempVC.setStatus(Integer.parseInt(statusInfo));
tempVC.setUrlLinkName(urlLinkName);
tempVC.setViewComponentId(vcId);
viewComponent = getViewComponentHbmDao().create(tempVC);
viewComponent.setApprovedLinkName(approvedLinkName);
}
viewComponent.setOnline((byte) 1);
}
viewComponent.setPrevNode(prev);
if (prev != null) prev.setNextNode(viewComponent);
viewComponent.setParentViewComponent(parent);
viewComponent.setMetaData(XercesHelper.getNodeValue(nde, "./metaKeywords"));
viewComponent.setMetaDescription(XercesHelper.getNodeValue(nde, "./metaDescription"));
String onlineStart = XercesHelper.getNodeValue(nde, "./onlineStart");
if (!onlineStart.equals("")) {
if (log.isDebugEnabled()) log.debug("OnlineStart: " + onlineStart);
viewComponent.setOnlineStart(Long.parseLong(onlineStart));
}
String onlineStop = XercesHelper.getNodeValue(nde, "./onlineStop");
if (!onlineStop.equals("")) {
if (log.isDebugEnabled()) log.debug("OnlineStop: " + onlineStop);
viewComponent.setOnlineStop(Long.parseLong(onlineStop));
}
viewComponent.setViewLevel(XercesHelper.getNodeValue(nde, "./viewLevel"));
viewComponent.setViewIndex(XercesHelper.getNodeValue(nde, "./viewIndex"));
viewComponent.setDisplaySettings(Byte.parseByte(XercesHelper.getNodeValue(nde, "./displaySettings")));
viewComponent.setShowType(Byte.parseByte(XercesHelper.getNodeValue(nde, "./showType")));
viewComponent.setViewType(viewType);
viewComponent.setVisible(visible);
viewComponent.setSearchIndexed(Boolean.valueOf(XercesHelper.getNodeValue(nde, "./searchIndexed")).booleanValue());
viewComponent.setXmlSearchIndexed(Boolean.valueOf(XercesHelper.getNodeValue(nde, "./xmlSearchIndexed")).booleanValue());
byte status = -1;
try {
status = new Byte(XercesHelper.getNodeValue(nde, "./status")).byteValue();
} catch (Exception e) {
if (log.isDebugEnabled()) log.debug("Status was not set...");
}
// on import set deploy-state to "edited"
if (!livedeploy) status = Constants.DEPLOY_STATUS_EDITED;
viewComponent.setStatus(status);
byte onlineState = -1;
try {
onlineState = new Byte(XercesHelper.getNodeValue(nde, "./online")).byteValue();
} catch (Exception e) {
if (log.isDebugEnabled()) log.debug("OnlineState was not set...");
}
// on import set online-state to offline
if (!livedeploy) onlineState = Constants.ONLINE_STATUS_OFFLINE;
viewComponent.setOnline(onlineState);
if (fulldeploy == 0 && viewComponent.getStatus() == Constants.DEPLOY_STATUS_APPROVED) {
// this only occures on new pages that are deployed for the first time
// (they dont have the state online on workserver because of different transactions)
if (log.isDebugEnabled()) log.debug("setting online: " + viewComponent.getDisplayLinkName());
viewComponent.setOnline((byte) 1);
}
{
// realm2viewComponent
Node nodeRealm = XercesHelper.findNode(nde, "realm2viewComponent");
if (nodeRealm != null) {
// this ViewComponent is protected by a realm
if (fulldeploy > 0) {
// use new ids
String neededrole = XercesHelper.getNodeValue(nodeRealm, "roleNeeded");
String loginPage = XercesHelper.getNodeValue(nodeRealm, "loginPageId");
if (loginPage != null && !"".equalsIgnoreCase(loginPage)) {
Integer loginPageId = null;
try {
loginPageId = Integer.valueOf(loginPage);
} catch (Exception e) {
}
if (loginPageId != null) loginPagesRealm2vc.put(vcId, loginPageId);
}
Node relNode = XercesHelper.findNode(nodeRealm, "jdbcRealmId");
if (relNode != null) {
Integer id = new Integer(XercesHelper.getNodeValue(relNode));
RealmJdbcHbm sqlrealm = null;
if (useNewIds) {
sqlrealm = getRealmJdbcHbmDao().load(mappingRealmsJdbc.get(id));
} else {
sqlrealm = getRealmJdbcHbmDao().load(id);
}
Realm2viewComponentHbm tempRealm = createTempRealm(viewComponent, neededrole, sqlrealm, null, null, null);
Realm2viewComponentHbm r = getRealm2viewComponentHbmDao().create(tempRealm);
viewComponent.setRealm2vc(r);
} else {
relNode = XercesHelper.findNode(nodeRealm, "simplePwRealmId");
if (relNode != null) {
Integer id = new Integer(XercesHelper.getNodeValue(relNode));
RealmSimplePwHbm realm = null;
if (useNewIds) {
realm = getRealmSimplePwHbmDao().load(mappingRealmsSimplePw.get(id));
} else {
realm = getRealmSimplePwHbmDao().load(id);
}
Realm2viewComponentHbm tempRealm = createTempRealm(viewComponent, neededrole, null, realm, null, null);
Realm2viewComponentHbm r = getRealm2viewComponentHbmDao().create(tempRealm);
viewComponent.setRealm2vc(r);
} else {
relNode = XercesHelper.findNode(nodeRealm, "ldapRealmId");
if (relNode != null) {
Integer id = new Integer(XercesHelper.getNodeValue(relNode));
RealmLdapHbm realm = null;
if (useNewIds) {
realm = getRealmLdapHbmDao().load(mappingRealmsLdap.get(id));
} else {
realm = getRealmLdapHbmDao().load(id);
}
Realm2viewComponentHbm tempRealm = createTempRealm(viewComponent, neededrole, null, null, realm, null);
Realm2viewComponentHbm r = getRealm2viewComponentHbmDao().create(tempRealm);
viewComponent.setRealm2vc(r);
} else {
relNode = XercesHelper.findNode(nodeRealm, "jaasRealmId");
if (relNode != null) {
Integer id = new Integer(XercesHelper.getNodeValue(relNode));
RealmJaasHbm realm = null;
if (useNewIds) {
realm = getRealmJaasHbmDao().load(mappingRealmsJaas.get(id));
} else {
realm = getRealmJaasHbmDao().load(id);
}
Realm2viewComponentHbm tempRealm = createTempRealm(viewComponent, neededrole, null, null, null, realm);
Realm2viewComponentHbm r = getRealm2viewComponentHbmDao().create(tempRealm);
viewComponent.setRealm2vc(r);
}
}
}
}
} else {
Realm2viewComponentHbm tempRealm = new Realm2viewComponentHbmImpl();
tempRealm.setViewComponent(viewComponent);
Realm2viewComponentHbm r = getRealm2viewComponentHbmDao().create(tempRealm);
viewComponent.setRealm2vc(r);
String loginPage = XercesHelper.getNodeValue(nodeRealm, "loginPageId");
if (loginPage != null && !"".equalsIgnoreCase(loginPage)) {
Integer loginPageId = null;
try {
loginPageId = Integer.valueOf(loginPage);
} catch (Exception e) {
}
if (loginPageId != null) loginPagesRealm2vc.put(vcId, loginPageId);
}
}
}
}
// CONTENT
Element cnde = (Element) XercesHelper.findNode(nde, "./content");
if (cnde != null) {
ContentHbm content = getContentHbmDao().createFromXml(cnde, reusePrimaryKey, livedeploy, null, null, null, null);
viewComponent.setReference(content.getContentId().toString());
}
// CHILDREN
Iterator it = XercesHelper.findNodes(nde, "./viewcomponent");
ViewComponentHbm childprev = null;
ViewComponentHbm tmp = null;
while (it.hasNext()) {
Element childnode = (Element) it.next();
tmp = createViewComponent(unitId, viewDocument, savedUnits, childnode, viewComponent, childprev, livedeploy, fulldeploy, useNewIds);
if (childprev != null) {
childprev.setNextNode(tmp);
} else {
viewComponent.setFirstChild(tmp);
}
if (tmp != null) childprev = tmp;
}
} else {
// Im a ViewComponent from another Unit. This must be inside the Array... HEY ARRAY !!!
boolean found = false;
Iterator it = savedUnits.iterator();
while (it.hasNext()) {
ViewComponentHbm savedvc = (ViewComponentHbm) it.next();
if (myUnitId.equals(savedvc.getAssignedUnit().getUnitId())) {
viewComponent = savedvc;
viewComponent.setPrevNode(prev);
byte showtype = viewComponent.getShowType();
viewComponent.setParentViewComponent(parent);
viewComponent.setShowType(showtype);
savedUnits.remove(savedvc);
found = true;
if (log.isDebugEnabled()) log.debug("MOVING BACK: " + viewComponent.getDisplayLinkName());
break;
}
}
if (!found) {
// This means: We are importing a Edition, where we suggest, that there is already this
// Unit deployed, what we have as child-Unit.
// It is possible, that we are deploying a unit, where this child-Unis haven't deployed yet -
// f.e. initial-deploy or this child-unit has been new created and never deployed at this special
// moment.
// Therefor we will create a DUMMY entry with a "DUMMY"-Reference, so we can map the child-unit to
// this place, if the child-Unit Editor wants to deploy his unit.
try {
// FIRST we will take a look, if there is already this Unit - but wasn't found here.
// This could be possible, if this unit was been "outtaked" and this is an old Edition,
// we will find this Unit anywhere else.
viewComponent = getViewComponentHbmDao().find4Unit(myUnitId, viewDocument.getViewDocumentId());
} catch (Exception exe) {
try {
UnitHbm unit = getUnitHbmDao().load(myUnitId);
ViewComponentHbm tempVC = new ViewComponentHbmImpl();
tempVC.setViewDocument(viewDocument);
tempVC.setReference("DUMMY");
tempVC.setDisplayLinkName("SUB_ENTRY_NOT_DEPLOYED");
tempVC.setLinkDescription("SUB_ENTRY_NOT_DEPLOYED");
tempVC.setViewComponentId(vcId);
viewComponent = getViewComponentHbmDao().create(tempVC);
viewComponent.setViewType(Constants.VIEW_TYPE_UNIT);
viewComponent.setVisible(false);
viewComponent.setAssignedUnit(unit);
} catch (Exception ex) {
// Jens - ??
// context.setRollbackOnly();
throw new UserException("UnitWasNeverDeployed");
}
}
viewComponent.setPrevNode(prev);
viewComponent.setParentViewComponent(parent);
}
}
} catch (Exception exe) {
// Jens - ??
// context.setRollbackOnly();
log.error("Error occured", exe);
throw exe;
}
// IMPORT END
return viewComponent;
}
private void importRealms(org.w3c.dom.Document doc, Integer siteId, boolean useNewIDs) {
if (log.isDebugEnabled()) log.debug("start importRealms with useNewIDs=" + useNewIDs);
mappingRealmsSimplePw = new Hashtable<Integer, Integer>();
mappingRealmsJdbc = new Hashtable<Integer, Integer>();
mappingRealmsLdap = new Hashtable<Integer, Integer>();
mappingRealmsJaas = new Hashtable<Integer, Integer>();
loginPagesRealmsSimplePw = new Hashtable<Integer, Integer>();
loginPagesRealmsJdbc = new Hashtable<Integer, Integer>();
loginPagesRealmsLdap = new Hashtable<Integer, Integer>();
loginPagesRealmsJaas = new Hashtable<Integer, Integer>();
loginPagesRealm2vc = new Hashtable<Integer, Integer>();
try {
if (XercesHelper.findNode(doc, "/edition/realms") != null) {
SiteHbm site = getSiteHbmDao().load(siteId);
Iterator itRealms = XercesHelper.findNodes(doc, "/edition/realms/realmsSimplePw/realmSimplePw");
while (itRealms.hasNext()) {
if (log.isDebugEnabled()) log.debug("Found RealmSimplePw to import...");
Element elmRealm = (Element) itRealms.next();
Integer id = new Integer(XercesHelper.getNodeValue(elmRealm, "simplePwRealmId"));
RealmSimplePwHbm realm = null;
if (useNewIDs) {
realm = getRealmSimplePwHbmDao().create(elmRealm, true);
realm.setSite(site);
mappingRealmsSimplePw.put(id, realm.getSimplePwRealmId()); // mapping OLD-ID to NEW-ID
} else {
try {
if (log.isDebugEnabled()) log.debug("searching RealmSimplePw: " + id);
realm = getRealmSimplePwHbmDao().load(id);
String realmName = XercesHelper.getNodeValue(elmRealm, "realmName");
if (realmName != null && realmName.length() > 0) {
realm.setRealmName(realmName);
} else {
realm.setRealmName(null);
}
realm.setSite(site);
{
// import users, first delete all existing ones for this realm
Collection toDelete = new ArrayList();
toDelete.addAll(realm.getSimplePwRealmUsers());
Iterator it = toDelete.iterator();
while (it.hasNext()) {
getRealmSimplePwUserHbmDao().remove(((RealmSimplePwUserHbm) it.next()));
}
toDelete.clear();
realm.getSimplePwRealmUsers().clear();
Iterator itUsers = XercesHelper.findNodes(elmRealm, "simplePwRealmUsers/realmSimplePwUser");
while (itUsers.hasNext()) {
Element elmUser = (Element) itUsers.next();
RealmSimplePwUserHbm user = ((RealmSimplePwUserHbmDaoImpl) getRealmSimplePwUserHbmDao()).create(elmUser, false);
user.setSimplePwRealm(realm);
realm.getSimplePwRealmUsers().add(user);
}
}
} catch (Exception exe) {
if (log.isDebugEnabled()) log.debug("creating RealmSimplePw: " + id);
realm = getRealmSimplePwHbmDao().create(elmRealm, false);
realm.setSite(site);
}
}
String loginPageId = XercesHelper.getNodeValue(elmRealm, "loginPageId");
if (loginPageId != null && loginPageId.length() > 0) loginPagesRealmsSimplePw.put(id, new Integer(loginPageId));
}
itRealms = XercesHelper.findNodes(doc, "/edition/realms/realmsLdap/realmLdap");
while (itRealms.hasNext()) {
if (log.isDebugEnabled()) log.debug("Found RealmLdap to import...");
Element elmRealm = (Element) itRealms.next();
Integer id = new Integer(XercesHelper.getNodeValue(elmRealm, "ldapRealmId"));
RealmLdapHbm realm = null;
if (useNewIDs) {
realm = getRealmLdapHbmDao().create(elmRealm, true);
realm.setSite(site);
mappingRealmsLdap.put(id, realm.getLdapRealmId()); // mapping OLD-ID to NEW-ID
} else {
try {
if (log.isDebugEnabled()) log.debug("searching RealmLdap: " + id);
realm = getRealmLdapHbmDao().load(id);
String realmName = XercesHelper.getNodeValue(elmRealm, "realmName");
if (realmName != null && realmName.length() > 0) {
realm.setRealmName(realmName);
} else {
realm.setRealmName(null);
}
String ldapPrefix = XercesHelper.getNodeValue(elmRealm, "ldapPrefix");
realm.setLdapPrefix(ldapPrefix);
String ldapSuffix = XercesHelper.getNodeValue(elmRealm, "ldapSuffix");
realm.setLdapSuffix(ldapSuffix);
String ldapUrl = XercesHelper.getNodeValue(elmRealm, "ldapUrl");
realm.setLdapUrl(ldapUrl);
String ldapAuthenticationType = XercesHelper.getNodeValue(elmRealm, "ldapAuthenticationType");
realm.setLdapAuthenticationType(ldapAuthenticationType);
realm.setSite(site);
} catch (Exception exe) {
if (log.isDebugEnabled()) log.debug("creating RealmLdap: " + id);
realm = getRealmLdapHbmDao().create(elmRealm, false);
realm.setSite(site);
}
}
String loginPageId = XercesHelper.getNodeValue(elmRealm, "loginPageId");
if (loginPageId != null && loginPageId.length() > 0) loginPagesRealmsLdap.put(id, new Integer(loginPageId));
}
itRealms = XercesHelper.findNodes(doc, "/edition/realms/realmsJdbc/realmJdbc");
while (itRealms.hasNext()) {
if (log.isDebugEnabled()) log.debug("Found RealmJdbc to import...");
Element elmRealm = (Element) itRealms.next();
Integer id = new Integer(XercesHelper.getNodeValue(elmRealm, "jdbcRealmId"));
RealmJdbcHbm realm = null;
if (useNewIDs) {
realm = getRealmJdbcHbmDao().create(elmRealm, true);
realm.setSite(site);
mappingRealmsJdbc.put(id, realm.getJdbcRealmId()); // mapping OLD-ID to NEW-ID
} else {
try {
if (log.isDebugEnabled()) log.debug("searching RealmJdbc: " + id);
realm = getRealmJdbcHbmDao().load(id);
String realmName = XercesHelper.getNodeValue(elmRealm, "realmName");
if (realmName != null && realmName.length() > 0) {
realm.setRealmName(realmName);
} else {
realm.setRealmName(null);
}
String jndiName = XercesHelper.getNodeValue(elmRealm, "jndiName");
realm.setJndiName(jndiName);
String statementUser = XercesHelper.getNodeValue(elmRealm, "statementUser");
realm.setStatementUser(statementUser);
String statementRolePerUser = XercesHelper.getNodeValue(elmRealm, "statementRolePerUser");
realm.setStatementRolePerUser(statementRolePerUser);
realm.setSite(site);
} catch (Exception exe) {
if (log.isDebugEnabled()) log.debug("creating RealmJdbc: " + id);
realm = getRealmJdbcHbmDao().create(elmRealm, false);
realm.setSite(site);
}
}
String loginPageId = XercesHelper.getNodeValue(elmRealm, "loginPageId");
if (loginPageId != null && loginPageId.length() > 0) loginPagesRealmsJdbc.put(id, new Integer(loginPageId));
}
itRealms = XercesHelper.findNodes(doc, "/edition/realms/realmsJaas/realmJaas");
while (itRealms.hasNext()) {
if (log.isDebugEnabled()) log.debug("Found RealmJaas to import...");
Element elmRealm = (Element) itRealms.next();
Integer id = new Integer(XercesHelper.getNodeValue(elmRealm, "jaasRealmId"));
RealmJaasHbm realm = null;
if (useNewIDs) {
realm = getRealmJaasHbmDao().create(elmRealm, true);
realm.setSite(site);
mappingRealmsJaas.put(id, realm.getJaasRealmId()); // mapping OLD-ID to NEW-ID
} else {
try {
if (log.isDebugEnabled()) log.debug("searching RealmJaas: " + id);
realm = getRealmJaasHbmDao().load(id);
String realmName = XercesHelper.getNodeValue(elmRealm, "realmName");
if (realmName != null && realmName.length() > 0) {
realm.setRealmName(realmName);
} else {
realm.setRealmName(null);
}
String jaasPolicyName = XercesHelper.getNodeValue(elmRealm, "jaasPolicyName");
realm.setJaasPolicyName(jaasPolicyName);
realm.setSite(site);
} catch (Exception exe) {
if (log.isDebugEnabled()) log.debug("creating RealmJaas: " + id);
realm = getRealmJaasHbmDao().create(elmRealm, false);
realm.setSite(site);
}
}
String loginPageId = XercesHelper.getNodeValue(elmRealm, "loginPageId");
if (loginPageId != null && loginPageId.length() > 0) loginPagesRealmsJaas.put(id, new Integer(loginPageId));
}
} else {
if (log.isDebugEnabled()) log.debug("importRealms reports: There are no /edition/realms nodes, so nothing to do");
}
} catch (Exception exe) {
log.error("Error occured importRealms: " + exe.getMessage(), exe);
}
}
@Override
protected void handleImportShortLinks(org.w3c.dom.Document doc, Integer siteId, boolean useNewIds) throws Exception {
try {
if (log.isInfoEnabled()) log.info("begin importShortLinks");
Iterator itShortLinks = XercesHelper.findNodes(doc, "/edition/shortLinks/shortLink");
if (itShortLinks.hasNext()) {
if (log.isDebugEnabled()) log.debug("Trying to delete ShortLinks");
// delete I
getShortLinkHbmDao().findAll(siteId).clear();
// delete II
Collection<ShortLinkHbm> shortLinks = new ArrayList<ShortLinkHbm>();
shortLinks.addAll(getShortLinkHbmDao().findAll(siteId));
Iterator hi = shortLinks.iterator();
ShortLinkHbm tempLink;
while (hi.hasNext()) {
tempLink = ((ShortLinkHbm) hi.next());
getShortLinkHbmDao().remove(tempLink);
}
if (log.isDebugEnabled()) log.debug("Trying to add new ShortLinks");
while (itShortLinks.hasNext()) {
if (log.isDebugEnabled()) log.debug("Found ShortLink to import...");
Element elShortLink = (Element) itShortLinks.next();
String shortLinkId = XercesHelper.getNodeValue(elShortLink, "./shortLinkId").trim();
String shortLinkName = XercesHelper.getNodeValue(elShortLink, "./shortLinkName").trim();
String redirectUrl = XercesHelper.getNodeValue(elShortLink, "./redirectUrl").trim();
String viewDocumentId = XercesHelper.getNodeValue(elShortLink, "./viewDocumentId").trim();
ShortLinkValue shortLinkValue = new ShortLinkValue();
if (useNewIds) {
shortLinkValue.setShortLinkId(new Integer(-1));
shortLinkValue.setViewDocumentId(mappingVDs.get(Integer.valueOf(viewDocumentId)));
} else {
shortLinkValue.setShortLinkId(Integer.valueOf(shortLinkId));
shortLinkValue.setViewDocumentId(Integer.valueOf(viewDocumentId));
}
shortLinkValue.setRedirectUrl(redirectUrl);
shortLinkValue.setShortLink(shortLinkName);
shortLinkValue.setSiteId(siteId);
if (log.isDebugEnabled()) log.debug("Importing ShortLink: " + shortLinkId + " shortLinkName \"" + shortLinkName + "\" redirectUrl \"" + redirectUrl + "\" for site " + siteId + " and viewDocument " + shortLinkValue.getViewDocumentId());
try {
ShortLinkHbm shortLink = createShortLinkHbm(shortLinkValue);
getShortLinkHbmDao().setShortLinkValue(shortLinkValue, shortLink);
// shortLink.setShortLinkValue(shortLinkValue);
getShortLinkHbmDao().create(shortLink);
} catch (Exception e) {
log.error("Error creating ShortLink: " + e.getMessage(), e);
}
}
}
if (log.isInfoEnabled()) log.info("end importShortLinks");
} catch (Exception exe) {
// context.setRollbackOnly();
throw new UserException("Error recreating the ShortLinks " + exe.getMessage());
}
}
private ShortLinkHbm createShortLinkHbm(ShortLinkValue shortLinkValue) {
ShortLinkHbm shortLink = new ShortLinkHbmImpl();
shortLink.setShortLink(shortLinkValue.getShortLink());
shortLink.setRedirectUrl(shortLinkValue.getRedirectUrl());
try {
if (shortLinkValue.getSiteId() != null) {
SiteHbm site = getSiteHbmDao().load(shortLinkValue.getSiteId());
shortLink.setSite(site);
}
if (shortLinkValue.getViewDocumentId() != null) {
ViewDocumentHbm viewDocument = getViewDocumentHbmDao().load(shortLinkValue.getViewDocumentId());
shortLink.setViewDocument(viewDocument);
}
} catch (Exception e) {
log.error("Error setting relations in setShortLinkValue: " + e.getMessage(), e);
}
return shortLink;
}
/**
* It runs on the workserver only
*/
@Override
protected void handleUpdateDeployStatus(List editions) throws Exception {
if (editions != null && editions.size() > 0) {
//group editions by liveserver
Map<LiveServerCredentials, List<EditionHbm>> editionsByLiveServers = new HashMap<LiveServerCredentials, List<EditionHbm>>();
for (EditionHbm edition : (List<EditionHbm>) editions) {
// edition is deployed - no new status expected
if (edition.getEndActionTimestamp() != null) {
continue;
}
SiteHbm site = getSiteHbmDao().load(edition.getSiteId());
LiveServerCredentials credentials = new LiveServerCredentials();
org.w3c.dom.Document doc = null;
try {
doc = XercesHelper.string2Dom(site.getConfigXML());
credentials.liveServerIP = XercesHelper.getNodeValue(doc, "/config/default/liveServer/url");
credentials.liveServerUserName = XercesHelper.getNodeValue(doc, "/config/default/liveServer/username");
credentials.liveServerPass = XercesHelper.getNodeValue(doc, "/config/default/liveServer/password");
} catch (Exception exe) {
log.error("Error occured reading siteConfig: ", exe);
} finally {
doc = null;
}
if (!editionsByLiveServers.containsKey(credentials)) {
List<EditionHbm> editionsOnLiveServer = new ArrayList<EditionHbm>();
editionsOnLiveServer.add(edition);
editionsByLiveServers.put(credentials, editionsOnLiveServer);
} else {
editionsByLiveServers.get(credentials).add(edition);
}
}
for (Entry<LiveServerCredentials, List<EditionHbm>> editionsByLiveServer : editionsByLiveServers.entrySet()) {
List<EditionHbm> editionStatusesRequest = editionsByLiveServer.getValue();
List<EditionValue> editionStatusesResponse = getDeployStatusFromLiveServer(editionsByLiveServer.getValue(), editionsByLiveServer.getKey());
for (EditionHbm editionRequest : editionStatusesRequest) {
boolean foundEditionInResponse = false;
EditionValue editionValueRequest = editionRequest.getDao();
for (EditionValue editionResponse : editionStatusesResponse) {
if (editionResponse.getWorkServerEditionId().equals(editionValueRequest.getEditionId())) {
//update deploy status
if (editionResponse.getDeployStatus() == null) {
editionRequest.setDeployStatus(new byte[0]);
} else {
editionRequest.setDeployStatus(editionResponse.getDeployStatus().getBytes());
String message = new String(editionResponse.getDeployStatus().getBytes());
if (message.compareToIgnoreCase("ImportSuccessful") == 0 && editionRequest.getEndActionTimestamp() == null) {
createDeployFinishedTask(message, editionRequest);
setViewComponentsOnline(editionRequest);
}
if (message.contains("Exception") && editionRequest.getEndActionTimestamp() == null) {
createDeployFinishedTask(message, editionRequest);
}
}
editionRequest.setStartActionTimestamp(editionResponse.getStartActionTimestamp() == null ? null : editionResponse.getStartActionTimestamp().getTime());
editionRequest.setEndActionTimestamp(editionResponse.getEndActionTimestamp() == null ? null : editionResponse.getEndActionTimestamp().getTime());
getEditionHbmDao().update(editionRequest);
foundEditionInResponse = true;
break;
}
}
if (!foundEditionInResponse) {
//deploy finished
//getEditionHbmDao().remove(editionRequest.getEditionId());
}
}
}
}
}
private void createDeployFinishedTask(String message, EditionHbm edition) {
if (log.isDebugEnabled()) log.debug("start createDeployFinishedTask");
if (log.isDebugEnabled() && message != null) log.debug("parameter message: " + message);
if (log.isDebugEnabled() && edition != null) log.debug("parameter edition(id): " + edition.getEditionId());
TaskHbm finish = TaskHbm.Factory.newInstance();
finish.setComment(message);
finish.setCreationDate(new Date().getTime());
finish.setReceiverRole("deploy");
finish.setSender(edition.getCreator());
finish.setUnit(getUnitHbmDao().load(edition.getUnitId()));
finish.setTaskType(Constants.TASK_SYSTEMMESSAGE_INFORMATION);
if (message.compareToIgnoreCase("ImportSuccessful") == 0) {
message = "Edition " + edition.getComment() + " (" + edition.getEditionId() + ") has been deployed successfully.";
} else {
message = "Edition " + edition.getComment() + " (" + edition.getEditionId() + ") could not be deployed. Please contact your administrator.";
}
getTaskHbmDao().create(finish);
edition.setDeployStatus("Finished".getBytes());
getEditionHbmDao().update(edition);
if (log.isDebugEnabled()) log.debug("end createDeployFinishedTask");
}
private List<EditionValue> getDeployStatusFromLiveServer(List<EditionHbm> editions, LiveServerCredentials credentials) throws UserException {
List<EditionValue> editionsStatus = new ArrayList<EditionValue>();
if (editions != null && editions.size() > 0) {
try {
EditionHbm edition = editions.get(0);
int unitId = edition.getUnitId();
int viewDocumentId = edition.getViewDocumentId();
System.setProperty("tizzit-liveserver.remoteServer", "http://" + credentials.liveServerIP);
ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext-deploy.xml");
try {
SecurityContextHolder.setStrategyName(SecurityContextHolder.MODE_GLOBAL);
RemoteAuthenticationManager remoteAuthenticationService = (RemoteAuthenticationManager) ctx.getBean("remoteRemoteAuthenticationManagerServiceDeploy");
GrantedAuthority[] authorities = remoteAuthenticationService.attemptAuthentication(credentials.liveServerUserName, String.valueOf(credentials.liveServerPass));
SecurityContextHolder.getContext().setAuthentication(new UsernamePasswordAuthenticationToken(credentials.liveServerUserName, String.valueOf(credentials.liveServerPass), authorities));
log.debug(SecurityContextHolder.getContext().getAuthentication());
} catch (SpringSecurityException e) {
log.info("authentication failed: " + e.getMessage());
throw new UserException(e.getMessage());
}
AuthorizationServiceSpring autoSpring = (AuthorizationServiceSpring) ctx.getBean("authorizationServiceDeploySpring");
if (log.isInfoEnabled()) log.info("Logging in on Liveserver...");
autoSpring.remoteLoginLive(credentials.liveServerUserName, credentials.liveServerPass);
if (log.isInfoEnabled()) log.info("Successfully logged in!");
ClientServiceSpring clientServiceSpring = (ClientServiceSpring) ctx.getBean("clientServiceDeploySpring");
editionsStatus = clientServiceSpring.getDeployStatus(editions);
} catch (Exception exe) {
if (log.isDebugEnabled()) log.debug("Rolling back because of error on Liveserver");
//if error connecting to server don't update statuses for requesting edition
for (EditionHbm edition : editions) {
edition.setWorkServerEditionId(edition.getEditionId());
edition.setExceptionMessage(exe.getMessage());
edition.setEndActionTimestamp(System.currentTimeMillis());
editionsStatus.add(edition.getDao());
}
}
}
return editionsStatus;
}
@Override
protected List handleGetDeployStatus(List editions) throws Exception {
List<EditionValue> editionsResult = new ArrayList<EditionValue>();
if (editions != null && editions.size() > 0) {
for (EditionHbm edition : (List<EditionHbm>) editions) {
EditionHbm liveServerEdition = getEditionHbmDao().findByWorkServerEdition(edition.getEditionId());
if (liveServerEdition != null) {
editionsResult.add(liveServerEdition.getDao());
}
}
}
return editionsResult;
}
private class LiveServerCredentials {
private String liveServerIP;
private String liveServerUserName;
private String liveServerPass;
@Override
public int hashCode() {
return (liveServerIP + liveServerUserName + liveServerPass).hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj instanceof LiveServerCredentials) {
LiveServerCredentials credentials = (LiveServerCredentials) obj;
return liveServerIP.equals(credentials.liveServerIP) && liveServerPass.equals(credentials.liveServerPass) && liveServerUserName.equals(credentials.liveServerUserName);
}
return false;
}
}
/* (non-Javadoc)
* @see de.juwimm.cms.remote.EditionServiceSpringBase#handleImportUnit(java.lang.Integer, java.lang.String)
*/
@Override
protected void handleImportUnit(Integer editionId, String editionFileName) throws Exception {
// TODO Auto-generated method stub
}
@Override
protected void handleDeployAll() throws Exception {
// TODO Auto-generated method stub
// Collection<EditionHbm> editionsToDeploy = getEditionHbmDao().findByNeedsDeploy(true);
// if (log.isInfoEnabled()) log.info("Found " + editionsToDeploy.size() + " Deploy-Editions to publish");
// for (EditionHbm edition : editionsToDeploy) {
// this.editionCronService.createEditionFileAndSendToLive(edition);
// }
}
}