org.eclipse.mdm.nucleus/org.eclipse.mdm.businessobjects/src/main/java/org/eclipse/mdm/businessobjects/service/TemplateService.java - mdmbl/org.eclipse.mdm - Git at Google

 /********************************************************************************
  * Copyright (c) 2015-2019 Contributors to the Eclipse Foundation
  *
  * See the NOTICE file(s) distributed with this work for additional
  * information regarding copyright ownership.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
  * http://www.eclipse.org/legal/epl-2.0.
  *
  * SPDX-License-Identifier: EPL-2.0
  *
  ********************************************************************************/

 package org.eclipse.mdm.businessobjects.service;

 import java.util.Arrays;
 import java.util.Comparator;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;

 import javax.ejb.Stateless;

 import org.eclipse.mdm.api.base.model.ContextType;
 import org.eclipse.mdm.api.base.model.Entity;
 import org.eclipse.mdm.api.base.model.Environment;
 import org.eclipse.mdm.api.dflt.ApplicationContext;
 import org.eclipse.mdm.api.dflt.EntityManager;
 import org.eclipse.mdm.api.dflt.model.EntityFactory;
 import org.eclipse.mdm.api.dflt.model.TemplateAttribute;
 import org.eclipse.mdm.api.dflt.model.TemplateComponent;
 import org.eclipse.mdm.api.dflt.model.TemplateRoot;
 import org.eclipse.mdm.api.dflt.model.TemplateSensor;
 import org.eclipse.mdm.api.dflt.model.TemplateTest;
 import org.eclipse.mdm.api.dflt.model.TemplateTestStep;
 import org.eclipse.mdm.api.dflt.model.TemplateTestStepUsage;
 import org.eclipse.mdm.businessobjects.utils.EntityNotFoundException;
 import org.eclipse.mdm.businessobjects.utils.EntityNotFoundException.Type;

 import io.vavr.Tuple;
 import io.vavr.Value;
 import io.vavr.control.Try;

 /**
  * {@link TemplateRoot} service handling corresponding operations
  *
  * @author Philipp Schweinbenz, science+computing AG Tuebingen (Atos SE)
  * @author Alexander Nehmer, science+computing AG Tuebingen (Atos SE)
  *
  */
 @Stateless
 public class TemplateService extends EntityService {

 	/**
 	 * Create new version of {@link TemplateTest} with given name. The link linked
 	 * {@link TemplateTestStep}s are copied.
 	 *
 	 * @param sourceNameSupplier a {@link Value} with the source name (MDM
 	 *                           {@link Environment} name)
 	 * @param name               name of entity to create new version of
 	 * @return new version of the {@link TemplateTestStep} with the given name
 	 */
 	@SuppressWarnings("unchecked")
 	public <T extends Entity> Try<T> createTplTestVersion(String sourceName, String name) {
 		return Try.of(() -> {
 			List<TemplateTest> tplTests = getEntityManager(sourceName)
 					.mapTry(em -> em.loadAll(TemplateTest.class, name)).get();
 			if (tplTests.isEmpty()) {
 				throw new EntityNotFoundException(TemplateTestStep.class, name, Type.NAME);
 			}

 			ApplicationContext appContext = connectorService.getContextByName(sourceName);
 			EntityFactory entityFactory = appContext.getEntityFactory().get();
 			EntityManager entityManager = appContext.getEntityManager().get();

 			// get latest version
 			Comparator<TemplateTest> versionComparator = Comparator.comparing(TemplateTest::getVersion);
 			TemplateTest latestTplTest = tplTests.stream().max(versionComparator).get();

 			TemplateTest newTplTest = entityFactory.createTemplateTest(latestTplTest.getName());
 			newTplTest.setVersion(latestTplTest.getVersion() + 1);

 			Set<Entity> entities = (Set<Entity>) DataAccessHelper.execute(entityManager,
 					Tuple.of(newTplTest, DataAccessHelper.CREATE));

 			// set TplTestSteps as in latestVersion
 			for (TemplateTestStepUsage tplTestStepUsage : latestTplTest.getTemplateTestStepUsages()) {
 				TemplateTestStepUsage newUsage = entityFactory.createTemplateTestStepUsage(tplTestStepUsage.getName(),
 						newTplTest, tplTestStepUsage.getTemplateTestStep());
 				DataAccessHelper.execute(entityManager, Tuple.of(newUsage, DataAccessHelper.CREATE));
 			}

 			return (T) entities.toArray()[0];
 		});
 	}

 	/**
 	 * Create new version of {@link TemplateTestStep} with given name. The linked
 	 * TplRoots are copied from the given {@link TemplateTestStep}
 	 *
 	 * @param sourceNameSupplier a {@link Value} with the source name (MDM
 	 *                           {@link Environment} name)
 	 * @param name               name of entity to create new version of
 	 * @return new version of the {@link TemplateTestStep} with the given name
 	 */
 	@SuppressWarnings("unchecked")
 	public <T extends Entity> Try<T> createTplTestStepVersion(String sourceName, String name) {
 		return Try.of(() -> {
 			List<TemplateTestStep> tplTestSteps = getEntityManager(sourceName)
 					.mapTry(em -> em.loadAll(TemplateTestStep.class, name)).get();
 			if (tplTestSteps.isEmpty()) {
 				throw new EntityNotFoundException(TemplateTestStep.class, name, Type.NAME);
 			}
 			TemplateTestStep givenTplTestStep = tplTestSteps.get(0);
 			ApplicationContext appContext = connectorService.getContextByName(sourceName);
 			TemplateTestStep newTplTestStep = copyTplTestStep(appContext.getEntityFactory().get(),
 					appContext.getEntityManager().get(), givenTplTestStep);
 			Set<Entity> entities = (Set<Entity>) DataAccessHelper.execute(getEntityManager(sourceName).get(),
 					Tuple.of(newTplTestStep, DataAccessHelper.CREATE));

 			return (T) entities.toArray()[0];
 		});
 	}

 	/**
 	 * Create a copy of a given {@link TemplateTestStep} and set version to latest +
 	 * 1
 	 *
 	 * @param entityFactory    {@link EntityFactory} to create new
 	 *                         {@link TemplateTestStep}
 	 * @param entityManager    {@link EntityManager} to get last version of given
 	 *                         {@link TemplateTestStep}
 	 * @param givenTplTestStep {@link TemplateTestStep} to create new version of
 	 * @return copy of the given {@link TemplateTestStep}
 	 */
 	private TemplateTestStep copyTplTestStep(EntityFactory entityFactory, EntityManager entityManager,
 			TemplateTestStep givenTplTestStep) {

 		TemplateTestStep newTemplateTestStep = entityFactory.createTemplateTestStep(givenTplTestStep.getName());
 		Comparator<TemplateTestStep> versionComparator = Comparator.comparing(TemplateTestStep::getVersion);
 		Optional<Integer> latestVersion = entityManager.loadAll(TemplateTestStep.class, newTemplateTestStep.getName())
 				.stream().max(versionComparator).map(TemplateTestStep::getVersion);
 		if (latestVersion.isPresent()) {
 			newTemplateTestStep.setVersion(latestVersion.get() + 1);
 		}

 		for (TemplateRoot tplRoot : givenTplTestStep.getTemplateRoots()) {
 			newTemplateTestStep.setTemplateRoot(tplRoot);
 		}

 		return newTemplateTestStep;
 	}

 	/**
 	 * * Create new version of {@link TemplateRoot} with given id
 	 *
 	 * @param sourceNameSupplier  a {@link Value} with the source name (MDM
 	 *                            {@link Environment} name)
 	 * @param contextTypeSupplier a {@link Value} with the contextType of entity to
 	 *                            create new version of.
 	 * @param id                  id of entity to create new version of
 	 * @return new version of the {@link TemplateRoot} with the given id
 	 */
 	@SuppressWarnings("unchecked")
 	public <T extends Entity> Try<T> createTplRootVersion(String sourceName, Value<ContextType> contextTypeSupplier,
 			String id) {
 		return Try.of(() -> {
 			TemplateRoot givenTplRoot = find(sourceName, TemplateRoot.class, id, contextTypeSupplier).get();
 			ApplicationContext appContext = connectorService.getContextByName(sourceName);
 			TemplateRoot newTplRoot = copyTplRoot(appContext.getEntityFactory().get(),
 					appContext.getEntityManager().get(), givenTplRoot);
 			Set<Entity> entities = (Set<Entity>) DataAccessHelper.execute(getEntityManager(sourceName).get(),
 					Tuple.of(newTplRoot, DataAccessHelper.CREATE));

 			return (T) entities.toArray()[0];
 		});
 	}

 	/**
 	 * Create a copy of a given {@link TemplateRoot} and set version to latest + 1
 	 *
 	 * @param entityFactory {@link EntityFactory} to create new {@link TemplateRoot}
 	 * @param entityManager {@link EntityManager} to get last version of given
 	 *                      {@link TemplateRoot}
 	 * @param givenTplRoot  {@link TemplateRoot} to create new version of
 	 * @return
 	 */
 	private TemplateRoot copyTplRoot(EntityFactory entityFactory, EntityManager entityManager,
 			TemplateRoot givenTplRoot) {
 		TemplateRoot newTemplateRoot = entityFactory.createTemplateRoot(givenTplRoot.getContextType(),
 				givenTplRoot.getName());
 		mergeEntities(givenTplRoot, newTemplateRoot, Entity.ATTR_NAME, Entity.ATTR_MIMETYPE,
 				TemplateRoot.ATTR_DATE_CREATED, TemplateRoot.ATTR_VERSION_STATE, TemplateRoot.ATTR_VERSION);
 		// TODO pschweinbenzidf on 2019-03-21: Why is this not working correctly with
 		// Versionable.COMPARATOR?
 		Comparator<TemplateRoot> versionComparator = Comparator.comparing(TemplateRoot::getVersion);
 		Optional<Integer> latestVersion = entityManager
 				.loadAll(TemplateRoot.class, givenTplRoot.getContextType(), newTemplateRoot.getName()).stream()
 				.max(versionComparator).map(TemplateRoot::getVersion);
 		if (latestVersion.isPresent()) {
 			newTemplateRoot.setVersion(latestVersion.get() + 1);
 		}

 		for (TemplateComponent tplComp : givenTplRoot.getTemplateComponents()) {
 			TemplateComponent newTplComp = entityFactory.createTemplateComponent(tplComp.getName(), newTemplateRoot,
 					tplComp.getCatalogComponent());
 			mergeEntities(tplComp, newTplComp, Entity.ATTR_NAME, Entity.ATTR_MIMETYPE);

 			copyTplAttrs(entityFactory, newTplComp, tplComp.getTemplateAttributes());
 			copyChildComps(entityFactory, newTplComp, tplComp.getTemplateComponents());
 			copyTplSensors(entityFactory, newTplComp, tplComp.getTemplateSensors());
 		}

 		return newTemplateRoot;
 	}

 	/**
 	 * Copy given child {@link TemplateComponent}s into given
 	 * {@link TemplateComponent}
 	 *
 	 * @param entityFactory   {@link EntityFactory} to create new entities
 	 * @param tplComp         {@link TemplateComponent} into given child
 	 *                        {@link TemplateComponent}s shall be copied
 	 * @param givenChildComps {@link TemplateComponent}s which shall be copied
 	 */
 	private void copyChildComps(EntityFactory entityFactory, TemplateComponent tplComp,
 			List<TemplateComponent> givenChildComps) {
 		for (TemplateComponent childComp : givenChildComps) {
 			TemplateComponent newTplComp = tplComp.getTemplateComponents().stream()
 					.filter(tc -> tc.getName().equals(childComp.getName())).findFirst().orElseGet(() -> entityFactory
 							.createTemplateComponent(childComp.getName(), tplComp, childComp.getCatalogComponent()));
 			mergeEntities(childComp, newTplComp, Entity.ATTR_NAME, Entity.ATTR_MIMETYPE);

 			copyTplAttrs(entityFactory, newTplComp, childComp.getTemplateAttributes());
 			copyChildComps(entityFactory, newTplComp, childComp.getTemplateComponents());
 			copyTplSensors(entityFactory, newTplComp, childComp.getTemplateSensors());
 		}
 	}

 	/**
 	 * Copy given {@link TemplateAttribute}s into given {@link TemplateComponent}
 	 *
 	 * @param entityFactory {@link EntityFactory} to create new entities
 	 * @param tplComp       {@link TemplateComponent} into given
 	 *                      {@link TemplateAttribute}s shall be copied
 	 * @param givenTplAttrs {@link TemplateAttribute}s which shall be copied
 	 */
 	private void copyTplAttrs(EntityFactory entityFactory, TemplateComponent tplComp,
 			List<TemplateAttribute> givenTplAttrs) {
 		for (TemplateAttribute tplAttr : givenTplAttrs) {
 			TemplateAttribute newTplAttr = tplComp.getTemplateAttributes().stream()
 					.filter(ta -> ta.getName().equals(tplAttr.getName())).findFirst()
 					.orElseGet(() -> entityFactory.createTemplateAttribute(tplAttr.getName(), tplComp));
 			mergeEntities(tplAttr, newTplAttr, Entity.ATTR_NAME, Entity.ATTR_MIMETYPE);
 		}
 	}

 	/**
 	 * Copy given {@link TemplateSeonsor}s into given {@link TemplateComponent}
 	 *
 	 * @param entityFactory   {@link EntityFactory} to create new entities
 	 * @param tplComp         {@link TemplateComponent} into given
 	 *                        {@link TemplateSensor}s shall be copied
 	 * @param givenTplSensors {@link TemplateSensor}s which shall be copied
 	 */
 	private void copyTplSensors(EntityFactory entityFactory, TemplateComponent tplComp,
 			List<TemplateSensor> givenTplSensors) {
 		for (TemplateSensor tplSensor : givenTplSensors) {
 			TemplateSensor newTplSensor = tplComp.getTemplateSensors().stream()
 					.filter(ts -> ts.getName().equals(tplSensor.getName())).findFirst()
 					.orElseGet(() -> entityFactory.createTemplateSensor(tplSensor.getName(), tplComp,
 							tplSensor.getCatalogSensor(), tplSensor.getQuantity()));
 			mergeEntities(tplSensor, newTplSensor, Entity.ATTR_NAME, Entity.ATTR_MIMETYPE);

 			for (TemplateAttribute tplSensorAttr : tplSensor.getTemplateAttributes()) {
 				Optional<TemplateAttribute> newTplSensorAttr = newTplSensor.getTemplateAttributes().stream()
 						.filter(ta -> ta.getName().equals(tplSensorAttr.getName())).findFirst();
 				if (newTplSensorAttr.isPresent()) {
 					mergeEntities(tplSensorAttr, newTplSensorAttr.get(), Entity.ATTR_NAME, Entity.ATTR_MIMETYPE);
 				}
 			}
 		}
 	}

 	/**
 	 * Merge given {@link Entity}s
 	 *
 	 * @param entity       original {@link Entity} which shall be merged into given
 	 *                     updEntity
 	 * @param updEntity    {@link Entity} which shall be updated by given entity
 	 * @param ignoredAttrs optional attributes which are not merged
 	 */
 	private void mergeEntities(Entity entity, Entity updEntity, String... ignoredAttrs) {
 		if (!entity.getClass().isAssignableFrom(updEntity.getClass())) {
 			return;
 		}
 		Set<String> ingoredAttrs = new HashSet<>(Arrays.asList(ignoredAttrs));

 		Map<String, org.eclipse.mdm.api.base.model.Value> entityValues = entity.getValues();
 		Set<String> updEntityKeys = updEntity.getValues().keySet();

 		for (Map.Entry<String, org.eclipse.mdm.api.base.model.Value> entry : entityValues.entrySet()) {
 			String key = entry.getKey();
 			if (!ingoredAttrs.contains(key) && updEntityKeys.contains(key)) {
 				updEntity.getValue(entry.getKey()).set(entry.getValue().extract());
 			}
 		}
 	}

 }
	/********************************************************************************
	* Copyright (c) 2015-2019 Contributors to the Eclipse Foundation
	*
	* See the NOTICE file(s) distributed with this work for additional
	* information regarding copyright ownership.
	*
	* This program and the accompanying materials are made available under the
	* terms of the Eclipse Public License v. 2.0 which is available at
	* http://www.eclipse.org/legal/epl-2.0.
	*
	* SPDX-License-Identifier: EPL-2.0
	*
	********************************************************************************/

	package org.eclipse.mdm.businessobjects.service;

	import java.util.Arrays;
	import java.util.Comparator;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Map;
	import java.util.Optional;
	import java.util.Set;

	import javax.ejb.Stateless;

	import org.eclipse.mdm.api.base.model.ContextType;
	import org.eclipse.mdm.api.base.model.Entity;
	import org.eclipse.mdm.api.base.model.Environment;
	import org.eclipse.mdm.api.dflt.ApplicationContext;
	import org.eclipse.mdm.api.dflt.EntityManager;
	import org.eclipse.mdm.api.dflt.model.EntityFactory;
	import org.eclipse.mdm.api.dflt.model.TemplateAttribute;
	import org.eclipse.mdm.api.dflt.model.TemplateComponent;
	import org.eclipse.mdm.api.dflt.model.TemplateRoot;
	import org.eclipse.mdm.api.dflt.model.TemplateSensor;
	import org.eclipse.mdm.api.dflt.model.TemplateTest;
	import org.eclipse.mdm.api.dflt.model.TemplateTestStep;
	import org.eclipse.mdm.api.dflt.model.TemplateTestStepUsage;
	import org.eclipse.mdm.businessobjects.utils.EntityNotFoundException;
	import org.eclipse.mdm.businessobjects.utils.EntityNotFoundException.Type;

	import io.vavr.Tuple;
	import io.vavr.Value;
	import io.vavr.control.Try;

	/**
	* {@link TemplateRoot} service handling corresponding operations
	*
	* @author Philipp Schweinbenz, science+computing AG Tuebingen (Atos SE)
	* @author Alexander Nehmer, science+computing AG Tuebingen (Atos SE)
	*
	*/
	@Stateless
	public class TemplateService extends EntityService {

	/**
	* Create new version of {@link TemplateTest} with given name. The link linked
	* {@link TemplateTestStep}s are copied.
	*
	* @param sourceNameSupplier a {@link Value} with the source name (MDM
	* {@link Environment} name)
	* @param name name of entity to create new version of
	* @return new version of the {@link TemplateTestStep} with the given name
	*/
	@SuppressWarnings("unchecked")
	public <T extends Entity> Try<T> createTplTestVersion(String sourceName, String name) {
	return Try.of(() -> {
	List<TemplateTest> tplTests = getEntityManager(sourceName)
	.mapTry(em -> em.loadAll(TemplateTest.class, name)).get();
	if (tplTests.isEmpty()) {
	throw new EntityNotFoundException(TemplateTestStep.class, name, Type.NAME);
	}

	ApplicationContext appContext = connectorService.getContextByName(sourceName);
	EntityFactory entityFactory = appContext.getEntityFactory().get();
	EntityManager entityManager = appContext.getEntityManager().get();

	// get latest version
	Comparator<TemplateTest> versionComparator = Comparator.comparing(TemplateTest::getVersion);
	TemplateTest latestTplTest = tplTests.stream().max(versionComparator).get();

	TemplateTest newTplTest = entityFactory.createTemplateTest(latestTplTest.getName());
	newTplTest.setVersion(latestTplTest.getVersion() + 1);

	Set<Entity> entities = (Set<Entity>) DataAccessHelper.execute(entityManager,
	Tuple.of(newTplTest, DataAccessHelper.CREATE));

	// set TplTestSteps as in latestVersion
	for (TemplateTestStepUsage tplTestStepUsage : latestTplTest.getTemplateTestStepUsages()) {
	TemplateTestStepUsage newUsage = entityFactory.createTemplateTestStepUsage(tplTestStepUsage.getName(),
	newTplTest, tplTestStepUsage.getTemplateTestStep());
	DataAccessHelper.execute(entityManager, Tuple.of(newUsage, DataAccessHelper.CREATE));
	}

	return (T) entities.toArray()[0];
	});
	}

	/**
	* Create new version of {@link TemplateTestStep} with given name. The linked
	* TplRoots are copied from the given {@link TemplateTestStep}
	*
	* @param sourceNameSupplier a {@link Value} with the source name (MDM
	* {@link Environment} name)
	* @param name name of entity to create new version of
	* @return new version of the {@link TemplateTestStep} with the given name
	*/
	@SuppressWarnings("unchecked")
	public <T extends Entity> Try<T> createTplTestStepVersion(String sourceName, String name) {
	return Try.of(() -> {
	List<TemplateTestStep> tplTestSteps = getEntityManager(sourceName)
	.mapTry(em -> em.loadAll(TemplateTestStep.class, name)).get();
	if (tplTestSteps.isEmpty()) {
	throw new EntityNotFoundException(TemplateTestStep.class, name, Type.NAME);
	}
	TemplateTestStep givenTplTestStep = tplTestSteps.get(0);
	ApplicationContext appContext = connectorService.getContextByName(sourceName);
	TemplateTestStep newTplTestStep = copyTplTestStep(appContext.getEntityFactory().get(),
	appContext.getEntityManager().get(), givenTplTestStep);
	Set<Entity> entities = (Set<Entity>) DataAccessHelper.execute(getEntityManager(sourceName).get(),
	Tuple.of(newTplTestStep, DataAccessHelper.CREATE));

	return (T) entities.toArray()[0];
	});
	}

	/**
	* Create a copy of a given {@link TemplateTestStep} and set version to latest +
	* 1
	*
	* @param entityFactory {@link EntityFactory} to create new
	* {@link TemplateTestStep}
	* @param entityManager {@link EntityManager} to get last version of given
	* {@link TemplateTestStep}
	* @param givenTplTestStep {@link TemplateTestStep} to create new version of
	* @return copy of the given {@link TemplateTestStep}
	*/
	private TemplateTestStep copyTplTestStep(EntityFactory entityFactory, EntityManager entityManager,
	TemplateTestStep givenTplTestStep) {

	TemplateTestStep newTemplateTestStep = entityFactory.createTemplateTestStep(givenTplTestStep.getName());
	Comparator<TemplateTestStep> versionComparator = Comparator.comparing(TemplateTestStep::getVersion);
	Optional<Integer> latestVersion = entityManager.loadAll(TemplateTestStep.class, newTemplateTestStep.getName())
	.stream().max(versionComparator).map(TemplateTestStep::getVersion);
	if (latestVersion.isPresent()) {
	newTemplateTestStep.setVersion(latestVersion.get() + 1);
	}

	for (TemplateRoot tplRoot : givenTplTestStep.getTemplateRoots()) {
	newTemplateTestStep.setTemplateRoot(tplRoot);
	}

	return newTemplateTestStep;
	}

	/**
	* * Create new version of {@link TemplateRoot} with given id
	*
	* @param sourceNameSupplier a {@link Value} with the source name (MDM
	* {@link Environment} name)
	* @param contextTypeSupplier a {@link Value} with the contextType of entity to
	* create new version of.
	* @param id id of entity to create new version of
	* @return new version of the {@link TemplateRoot} with the given id
	*/
	@SuppressWarnings("unchecked")
	public <T extends Entity> Try<T> createTplRootVersion(String sourceName, Value<ContextType> contextTypeSupplier,
	String id) {
	return Try.of(() -> {
	TemplateRoot givenTplRoot = find(sourceName, TemplateRoot.class, id, contextTypeSupplier).get();
	ApplicationContext appContext = connectorService.getContextByName(sourceName);
	TemplateRoot newTplRoot = copyTplRoot(appContext.getEntityFactory().get(),
	appContext.getEntityManager().get(), givenTplRoot);
	Set<Entity> entities = (Set<Entity>) DataAccessHelper.execute(getEntityManager(sourceName).get(),
	Tuple.of(newTplRoot, DataAccessHelper.CREATE));

	return (T) entities.toArray()[0];
	});
	}

	/**
	* Create a copy of a given {@link TemplateRoot} and set version to latest + 1
	*
	* @param entityFactory {@link EntityFactory} to create new {@link TemplateRoot}
	* @param entityManager {@link EntityManager} to get last version of given
	* {@link TemplateRoot}
	* @param givenTplRoot {@link TemplateRoot} to create new version of
	* @return
	*/
	private TemplateRoot copyTplRoot(EntityFactory entityFactory, EntityManager entityManager,
	TemplateRoot givenTplRoot) {
	TemplateRoot newTemplateRoot = entityFactory.createTemplateRoot(givenTplRoot.getContextType(),
	givenTplRoot.getName());
	mergeEntities(givenTplRoot, newTemplateRoot, Entity.ATTR_NAME, Entity.ATTR_MIMETYPE,
	TemplateRoot.ATTR_DATE_CREATED, TemplateRoot.ATTR_VERSION_STATE, TemplateRoot.ATTR_VERSION);
	// TODO pschweinbenzidf on 2019-03-21: Why is this not working correctly with
	// Versionable.COMPARATOR?
	Comparator<TemplateRoot> versionComparator = Comparator.comparing(TemplateRoot::getVersion);
	Optional<Integer> latestVersion = entityManager
	.loadAll(TemplateRoot.class, givenTplRoot.getContextType(), newTemplateRoot.getName()).stream()
	.max(versionComparator).map(TemplateRoot::getVersion);
	if (latestVersion.isPresent()) {
	newTemplateRoot.setVersion(latestVersion.get() + 1);
	}

	for (TemplateComponent tplComp : givenTplRoot.getTemplateComponents()) {
	TemplateComponent newTplComp = entityFactory.createTemplateComponent(tplComp.getName(), newTemplateRoot,
	tplComp.getCatalogComponent());
	mergeEntities(tplComp, newTplComp, Entity.ATTR_NAME, Entity.ATTR_MIMETYPE);

	copyTplAttrs(entityFactory, newTplComp, tplComp.getTemplateAttributes());
	copyChildComps(entityFactory, newTplComp, tplComp.getTemplateComponents());
	copyTplSensors(entityFactory, newTplComp, tplComp.getTemplateSensors());
	}

	return newTemplateRoot;
	}

	/**
	* Copy given child {@link TemplateComponent}s into given
	* {@link TemplateComponent}
	*
	* @param entityFactory {@link EntityFactory} to create new entities
	* @param tplComp {@link TemplateComponent} into given child
	* {@link TemplateComponent}s shall be copied
	* @param givenChildComps {@link TemplateComponent}s which shall be copied
	*/
	private void copyChildComps(EntityFactory entityFactory, TemplateComponent tplComp,
	List<TemplateComponent> givenChildComps) {
	for (TemplateComponent childComp : givenChildComps) {
	TemplateComponent newTplComp = tplComp.getTemplateComponents().stream()
	.filter(tc -> tc.getName().equals(childComp.getName())).findFirst().orElseGet(() -> entityFactory
	.createTemplateComponent(childComp.getName(), tplComp, childComp.getCatalogComponent()));
	mergeEntities(childComp, newTplComp, Entity.ATTR_NAME, Entity.ATTR_MIMETYPE);

	copyTplAttrs(entityFactory, newTplComp, childComp.getTemplateAttributes());
	copyChildComps(entityFactory, newTplComp, childComp.getTemplateComponents());
	copyTplSensors(entityFactory, newTplComp, childComp.getTemplateSensors());
	}
	}

	/**
	* Copy given {@link TemplateAttribute}s into given {@link TemplateComponent}
	*
	* @param entityFactory {@link EntityFactory} to create new entities
	* @param tplComp {@link TemplateComponent} into given
	* {@link TemplateAttribute}s shall be copied
	* @param givenTplAttrs {@link TemplateAttribute}s which shall be copied
	*/
	private void copyTplAttrs(EntityFactory entityFactory, TemplateComponent tplComp,
	List<TemplateAttribute> givenTplAttrs) {
	for (TemplateAttribute tplAttr : givenTplAttrs) {
	TemplateAttribute newTplAttr = tplComp.getTemplateAttributes().stream()
	.filter(ta -> ta.getName().equals(tplAttr.getName())).findFirst()
	.orElseGet(() -> entityFactory.createTemplateAttribute(tplAttr.getName(), tplComp));
	mergeEntities(tplAttr, newTplAttr, Entity.ATTR_NAME, Entity.ATTR_MIMETYPE);
	}
	}

	/**
	* Copy given {@link TemplateSeonsor}s into given {@link TemplateComponent}
	*
	* @param entityFactory {@link EntityFactory} to create new entities
	* @param tplComp {@link TemplateComponent} into given
	* {@link TemplateSensor}s shall be copied
	* @param givenTplSensors {@link TemplateSensor}s which shall be copied
	*/
	private void copyTplSensors(EntityFactory entityFactory, TemplateComponent tplComp,
	List<TemplateSensor> givenTplSensors) {
	for (TemplateSensor tplSensor : givenTplSensors) {
	TemplateSensor newTplSensor = tplComp.getTemplateSensors().stream()
	.filter(ts -> ts.getName().equals(tplSensor.getName())).findFirst()
	.orElseGet(() -> entityFactory.createTemplateSensor(tplSensor.getName(), tplComp,
	tplSensor.getCatalogSensor(), tplSensor.getQuantity()));
	mergeEntities(tplSensor, newTplSensor, Entity.ATTR_NAME, Entity.ATTR_MIMETYPE);

	for (TemplateAttribute tplSensorAttr : tplSensor.getTemplateAttributes()) {
	Optional<TemplateAttribute> newTplSensorAttr = newTplSensor.getTemplateAttributes().stream()
	.filter(ta -> ta.getName().equals(tplSensorAttr.getName())).findFirst();
	if (newTplSensorAttr.isPresent()) {
	mergeEntities(tplSensorAttr, newTplSensorAttr.get(), Entity.ATTR_NAME, Entity.ATTR_MIMETYPE);
	}
	}
	}
	}

	/**
	* Merge given {@link Entity}s
	*
	* @param entity original {@link Entity} which shall be merged into given
	* updEntity
	* @param updEntity {@link Entity} which shall be updated by given entity
	* @param ignoredAttrs optional attributes which are not merged
	*/
	private void mergeEntities(Entity entity, Entity updEntity, String... ignoredAttrs) {
	if (!entity.getClass().isAssignableFrom(updEntity.getClass())) {
	return;
	}
	Set<String> ingoredAttrs = new HashSet<>(Arrays.asList(ignoredAttrs));

	Map<String, org.eclipse.mdm.api.base.model.Value> entityValues = entity.getValues();
	Set<String> updEntityKeys = updEntity.getValues().keySet();

	for (Map.Entry<String, org.eclipse.mdm.api.base.model.Value> entry : entityValues.entrySet()) {
	String key = entry.getKey();
	if (!ingoredAttrs.contains(key) && updEntityKeys.contains(key)) {
	updEntity.getValue(entry.getKey()).set(entry.getValue().extract());
	}
	}
	}

	}