CVE-2021-39181 (Java, published 2021-09-01T20:15Z)
Description: value: OpenOlat is a web-based learning management system (LMS). Prior to version 15.3.18, 15.5.3, and 16.0.0, using a prepared import XML file (e.g. a course) any class on the Java classpath can be instantiated, including spring AOP bean factories. This can be used to execute code arbitrary code by the attacker. The attack requires an OpenOlat user account with the authoring role. It can not be exploited by unregistered users. The problem is fixed in versions 15.3.18, 15.5.3, and 16.0.0. There are no known workarounds aside from upgrading.
Severity: MEDIUM (CVSS v3 base score: 8.8)
Weakness: CWE-91 \u2014 XML Injection (aka Blind XPath Injection)
The product does not properly neutralize special elements that are used in XML, allowing attackers to modify the syntax, content, or commands of the XML before it is processed by an end system.
Repository: https://github.com/OpenOLAT/OpenOLAT
Files changed:
src/main/java/de/bps/course/nodes/ChecklistCourseNode.java
src/main/java/de/bps/olat/portal/links/LinksPortlet.java
src/main/java/de/bps/olat/user/ChangeEMailExecuteController.java
src/main/java/org/olat/admin/landingpages/LandingPagesModule.java
src/main/java/org/olat/core/commons/modules/glossary/GlossaryItemManager.java
src/main/java/org/olat/core/commons/services/doceditor/discovery/manager/DiscoveryXStream.java
src/main/java/org/olat/core/commons/services/license/manager/LicenseXStreamHelper.java
src/main/java/org/olat/core/commons/services/taskexecutor/manager/PersistentTaskDAO.java
src/main/java/org/olat/core/commons/services/vfs/manager/VFSXStream.java
src/main/java/org/olat/core/dispatcher/mapper/manager/MapperDAO.java
src/main/java/org/olat/core/gui/control/navigation/SiteDefinitions.java
src/main/java/org/olat/core/id/context/HistoryManager.java
src/main/java/org/olat/core/util/prefs/db/DbStorage.java
src/main/java/org/olat/core/util/xml/EnhancedXStream.java
src/main/java/org/olat/core/util/xml/XStreamHelper.java
src/main/java/org/olat/course/CourseXStreamAliases.java
src/main/java/org/olat/course/archiver/FormatConfigHelper.java
src/main/java/org/olat/course/assessment/manager/EfficiencyStatementManager.java
src/main/java/org/olat/course/assessment/portfolio/EfficiencyStatementMediaHandler.java
src/main/java/org/olat/course/config/manager/CourseConfigManagerImpl.java
src/main/java/org/olat/course/config/ui/courselayout/CustomConfigManager.java
src/main/java/org/olat/course/nodes/ProjectBrokerCourseNode.java
src/main/java/org/olat/course/nodes/gta/manager/GTAManagerImpl.java
src/main/java/org/olat/group/manager/GroupXStream.java
src/main/java/org/olat/ims/cp/CPManagerImpl.java
src/main/java/org/olat/ims/qti21/manager/QTI21ServiceImpl.java
src/main/java/org/olat/instantMessaging/manager/ChatLogHelper.java
src/main/java/org/olat/modules/ceditor/ContentEditorXStream.java
src/main/java/org/olat/modules/curriculum/manager/CurriculumXStream.java
src/main/java/org/olat/modules/dcompensation/manager/DisadvantageCompensationAuditLogDAO.java
src/main/java/org/olat/modules/forms/model/xml/FormXStream.java
src/main/java/org/olat/modules/lecture/manager/LectureBlockAuditLogDAO.java
src/main/java/org/olat/modules/openmeetings/manager/OpenMeetingsDAO.java
src/main/java/org/olat/modules/portfolio/handler/BinderXStream.java
src/main/java/org/olat/modules/portfolio/manager/MetadataXStream.java
src/main/java/org/olat/modules/portfolio/manager/PortfolioServiceImpl.java
src/main/java/org/olat/modules/qpool/manager/MetadataConverterHelper.java
src/main/java/org/olat/modules/qpool/manager/QuestionItemAuditLogDAO.java
src/main/java/org/olat/modules/quality/analysis/manager/AnalysisPresentationXStream.java
src/main/java/org/olat/modules/reminder/manager/ReminderRulesXStream.java
src/main/java/org/olat/modules/scorm/ScormMainManager.java
src/main/java/org/olat/modules/taxonomy/manager/TaxonomyCompetenceAuditLogDAO.java
src/main/java/org/olat/modules/video/VideoManager.java
src/main/java/org/olat/modules/video/manager/VideoManagerImpl.java
src/main/java/org/olat/modules/video/manager/VideoMetaXStream.java
src/main/java/org/olat/modules/video/manager/VideoXStream.java
src/main/java/org/olat/modules/video/ui/VideoQualityTableFormController.java
src/main/java/org/olat/modules/vitero/manager/ViteroManager.java
src/main/java/org/olat/modules/webFeed/manager/FeedFileStorge.java
src/main/java/org/olat/modules/webFeed/portfolio/BlogEntryMediaController.java
src/main/java/org/olat/registration/RegistrationManager.java
src/main/java/org/olat/repository/RepositoryEntryImportExport.java
src/main/java/org/olat/restapi/repository/course/CourseWebService.java
src/main/java/org/olat/upgrade/OLATUpgrade_11_3_0.java
src/main/java/org/olat/upgrade/OLATUpgrade_12_3_0.java
src/main/java/org/olat/upgrade/OLATUpgrade_15_3_18.java
src/main/java/org/olat/upgrade/UpgradeManager.java
src/main/java/org/olat/upgrade/_spring/upgradeContext.xml
src/main/java/org/olat/user/manager/HomePageConfigManagerImpl.java
src/main/java/org/olat/user/propertyhandlers/UserInterestsPropertyHandler.java
src/test/java/org/olat/core/commons/modules/glossary/GlossaryItemManagerTest.java
src/test/java/org/olat/core/commons/modules/glossary/glossary.xml
src/test/java/org/olat/core/commons/services/taskexecutor/manager/PersistentTaskDAOTest.java
src/test/java/org/olat/core/dispatcher/mapper/MapperDAOTest.java
src/test/java/org/olat/core/util/xml/XMLDigitalSignatureUtilTest.java
src/test/java/org/olat/core/util/xml/XStreamHelperTest.java
src/test/java/org/olat/core/util/xml/xstream_map_alien.xml
src/test/java/org/olat/core/util/xml/xstream_map_strings.xml
src/test/java/org/olat/test/AllTestsJunit4.java
src/test/java/org/olat/test/VFSJavaIOFile.java
src/test/java/org/olat/upgrade/UpgradeManagerTest.java
src/test/java/org/olat/upgrade/installed_database_upgrades.xml
src/test/java/org/olat/upgrade/installed_upgrades.xml
Commit message: OO-5548: setup security of XStream by default

Vulnerable code:
	
		String exportContent = XStreamHelper.createXStreamInstance().toXML(checklist);
			XStream xstream = XStreamHelper.createXStreamInstance();
			xstream.alias("LinksPortlet", Map.class);
			xstream.alias(ELEM_LINK, PortletLink.class);
			xstream.alias(ELEM_INSTITUTION, PortletInstitution.class);
			xstream.aliasAttribute(PortletInstitution.class, ATTR_INSTITUTION_NAME, ATTR_INSTITUTION_NAME);
	public static boolean saveLinkList(HashMap<String, PortletInstitution> portletMap){
		XStream xstream = XStreamHelper.createXStreamInstance();
		xstream.alias("LinksPortlet", Map.class);
		xstream.alias(ELEM_LINK, PortletLink.class);
		xstream.alias(ELEM_INSTITUTION, PortletInstitution.class);
		xstream.aliasAttribute(PortletInstitution.class, ATTR_INSTITUTION_NAME, ATTR_INSTITUTION_NAME);
		String output = xstream.toXML(portletMap);
		return (output.length() != 0);		
	private void saveToFile(VFSLeaf glossaryFile, List<GlossaryItem> glossaryItemArr) {
	private List<GlossaryItem> loadGlossaryItemListFromFile(VFSLeaf glossaryFile) {
		XStream.setupDefaultSecurity(xstream);
		ptask.setTask(xstream.toXML(task));
		ptask.setTask(xstream.toXML(task));
			ptask.setTask(xstream.toXML(runnableTask));
		XStream.setupDefaultSecurity(mystream);
		String configuration = XStreamHelper.createXStreamInstance().toXML(mapper);
		String configuration = XStreamHelper.createXStreamInstance().toXML(mapper);
			Object obj = XStreamHelper.createXStreamInstance().fromXML(configuration);
public class EnhancedXStream extends XStream {
	public EnhancedXStream(boolean export) {
	private static final String ENCODING = "UTF-8";
	private static XStream unconfiguredXStream = new XStream();
		return new EnhancedXStream(false);
		return new EnhancedXStream(true);
		try(InputStreamReader isr = new InputStreamReader(is, ENCODING);) {
		try(InputStream is = new ByteArrayInputStream(xml.getBytes(ENCODING))) {
		try(OutputStreamWriter osw = new OutputStreamWriter(os, ENCODING)) {
			data = "<?xml version=\"1.0\" encoding=\"" + ENCODING + "\"?>\n"
		XStream.setupDefaultSecurity(configXstream);
	private final XStream xstream = XStreamHelper.createXStreamInstance();
		efficiencyProperty.setStatementXml(xstream.toXML(efficiencyStatement));
		return (EfficiencyStatement)xstream.fromXML(s.getStatementXml());
		return (EfficiencyStatement)xstream.fromXML(statement.get(0).getStatementXml());
		return (EfficiencyStatement)xstream.fromXML(statement.get(0).getStatementXml());
				EfficiencyStatement s = (EfficiencyStatement)xstream.fromXML(statement.getStatementXml());
import org.olat.core.util.xml.XStreamHelper;
import com.thoughtworks.xstream.XStream;

	private static final XStream myXStream = XStreamHelper.createXStreamInstance();
	
			String xml = myXStream.toXML(statement); 
				statement = (EfficiencyStatement)myXStream.fromXML(statementXml);
				statement = (EfficiencyStatement)myXStream.fromXML(media.getContent());
		XStream.setupDefaultSecurity(xstream);
		XStream xStream = XStreamHelper.createXStreamInstance();
		xStream.toXML(customConfig, configTarget.getOutputStream(false));
		XStream xStream = XStreamHelper.createXStreamInstance();
			return (Map<String, Map<String, Object>>) xStream.fromXML(in);
		
		XStream.setupDefaultSecurity(xstream);
		XStream.setupDefaultSecurity(configXstream);
		XStream.setupDefaultSecurity(configXstream);
import org.apache.pdfbox.io.IOUtils;
		ObjectOutputStream out = null;
		try {
			File file = new File(exportDirectory, "chat.xml");
			Writer writer = new FileWriter(file);
			out = logXStream.createObjectOutputStream(writer);
			
		} finally {
			IOUtils.closeQuietly(out);
		XStream.setupDefaultSecurity(xstream);
		XStream.setupDefaultSecurity(xstream);
		XStream.setupDefaultSecurity(xstream);
			log.error("Cannot import this map: " + path, e);
			log.error("Cannot export this map: " + binder, e);
		XStream.setupDefaultSecurity(configXstream);
		
		XStream.setupDefaultSecurity(xstream);
		XStream.setupDefaultSecurity(configXstream);
	/**
	 * Read the the metdatadata-xml in the videoresource folder
	 * @param videoResource
	 * @return
	 */
	public VideoMetadata readVideoMetadataFile(OLATResource videoResource);

	/**
	 * Checks if is metadata file valid.
	 *
	 * @param videoResource
	 * @return true, if is metadata file valid
	 */
	public boolean isMetadataFileValid(OLATResource videoResource);

import org.olat.core.util.xml.XStreamHelper;
import org.olat.modules.video.VideoMetadata;
import org.olat.modules.video.model.VideoMetadataImpl;
	@Override
	public boolean isMetadataFileValid(OLATResource videoResource) {
		VFSContainer baseContainer = FileResourceManager.getInstance().getFileResourceRootImpl(videoResource);
		VFSLeaf metaDataFile = (VFSLeaf) baseContainer.resolve(FILENAME_VIDEO_METADATA_XML);
		try {
			VideoMetadata meta = (VideoMetadata) XStreamHelper.readObject(XStreamHelper.createXStreamInstance(), metaDataFile);
			return meta != null;
		} catch (Exception e) {
			return false;
		}
	}

	@Override
	public VideoMetadata readVideoMetadataFile(OLATResource videoResource){
		VFSContainer baseContainer= FileResourceManager.getInstance().getFileResourceRootImpl(videoResource);
		VFSLeaf metaDataFile = (VFSLeaf) baseContainer.resolve(FILENAME_VIDEO_METADATA_XML);
		try {
			return (VideoMetadata) XStreamHelper.readObject(XStreamHelper.createXStreamInstance(), metaDataFile);
		} catch (Exception e) {
			log.error("Error while parsing XStream file for videoResource::{}", videoResource, e);
			// return an empty, so at least it displays something and not an error
			VideoMetadata meta =  new VideoMetadataImpl();
			meta.setWidth(800);
			meta.setHeight(600);
			return meta;
		}
	}

		XStream.setupDefaultSecurity(xstream);
				VideoMeta.class, VideoMetaImpl.class
		XStream.setupDefaultSecurity(xstream);
//				VideoMetadata videoMetadata = videoManager.readVideoMetadataFile(videoResource);
		XStream.setupDefaultSecurity(xmlXStream);

			if (videoManager.isMetadataFileValid(videoResource)) {
				VideoMetadata metafromXML = videoManager.readVideoMetadataFile(videoResource);
			log.warn("Cannot read files from dir: " + item.getDirectory());
import org.apache.logging.log4j.Logger;
	protected final XStream upgradesXStream = XStreamHelper.createXStreamInstance();
	@SuppressWarnings("unchecked")
			upgradesHistories = (Map<String, UpgradeHistoryData>)upgradesXStream.fromXML(upgradesHistoriesFile);
		XStream.setupDefaultSecurity(homeConfigXStream);
				log.error("Error while loading homepage config from path::" + configFile.getAbsolutePath() + ", fallback to default configuration",
						e);
import org.olat.core.util.xml.XStreamHelper;
		ptask.setTask(XStreamHelper.createXStreamInstance().toXML(new DummyTask()));
		alienTask.setTask(XStreamHelper.createXStreamInstance().toXML(new DummyTask()));
import org.olat.core.util.xml.XStreamHelper;
		Object objReloaded = XStreamHelper.createXStreamInstance().fromXML(pMapper.getXmlConfiguration());
		Object objReloaded = XStreamHelper.createXStreamInstance().fromXML(pMapper.getXmlConfiguration());
		Object objReloaded2 = XStreamHelper.createXStreamInstance().fromXML(loadedMapper2.getXmlConfiguration());
		Object objReloaded = XStreamHelper.createXStreamInstance().fromXML(pMapper.getXmlConfiguration());
		Object objReloaded2 = XStreamHelper.createXStreamInstance().fromXML(loadedMapper2.getXmlConfiguration());
			//
	org.olat.upgrade.UpgradeDefinitionTest.class
		return null;

Fixed code:
		XStreamHelper.allowDefaultPackage(xstream);
		XStreamHelper.allowDefaultPackage(xstream);

		XStream xstream = XStreamHelper.createXStreamInstance();
		XStreamHelper.allowDefaultPackage(xstream);
		String exportContent = xstream.toXML(checklist);
	private static final XStream xstream = XStreamHelper.createXStreamInstance();
	static {
		XStreamHelper.allowDefaultPackage(xstream);
		xstream.alias("LinksPortlet", Map.class);
		xstream.alias(ELEM_LINK, PortletLink.class);
		xstream.alias(ELEM_INSTITUTION, PortletInstitution.class);
		xstream.aliasAttribute(PortletInstitution.class, ATTR_INSTITUTION_NAME, ATTR_INSTITUTION_NAME);
	}
	
	public static boolean saveLinkList(Map<String, PortletInstitution> portletMap){
		return true;		
		XStreamHelper.allowDefaultPackage(xml);
		XStreamHelper.allowDefaultPackage(rulesXStream);
		XStreamHelper.allowDefaultPackage(xstreamReader);
		XStreamHelper.allowDefaultPackage(xstreamReader);
	protected final void saveToFile(VFSLeaf glossaryFile, List<GlossaryItem> glossaryItemArr) {
	protected final List<GlossaryItem> loadGlossaryItemListFromFile(VFSLeaf glossaryFile) {
		XStreamHelper.allowDefaultPackage(licenseXStream);
	static {
		XStreamHelper.allowDefaultPackage(xstream);
	}
		ptask.setTask(toXML(task));
		ptask.setTask(toXML(task));
			ptask.setTask(toXML(runnableTask));
	
	protected static String toXML(Serializable task) {
		return xstream.toXML(task);
	}
	
import com.thoughtworks.xstream.XStream;

	private static final XStream xstream = XStreamHelper.createXStreamInstance();
	static {
		XStreamHelper.allowDefaultPackage(xstream);
	}
	
		String configuration = xstream.toXML(mapper);
	protected static String toXml(Object mapper) {
		return xstream.toXML(mapper);
	}
	
	public static Object fromXML(String configuration) {
		return xstream.fromXML(configuration);
	}
	
		String configuration = xstream.toXML(mapper);
			Object obj = xstream.fromXML(configuration);
		XStreamHelper.allowDefaultPackage(xStream);
		XStreamHelper.allowDefaultPackage(historyReadStream);
		XStreamHelper.allowDefaultPackage(historyWriteStream);
		
		XStreamHelper.allowDefaultPackage(xstream);
class EnhancedXStream extends XStream {
	EnhancedXStream(boolean export) {
import java.nio.charset.StandardCharsets;
	private static final String[] DEFAULT_PACKAGES = new String[] {
			"org.olat.**",
			"de.bps.**",
			"at.ac.uibk.**",
			"org.hibernate.**"
		};
	private static final XStream unconfiguredXStream = new XStream();
	static {
		XStream.setupDefaultSecurity(unconfiguredXStream);
		allowDefaultPackage(unconfiguredXStream);
	}
	public static final void allowDefaultPackage(XStream xstream) {
		xstream.allowTypesByWildcard(DEFAULT_PACKAGES);
	}
		XStream xstream = new EnhancedXStream(false);
		XStream.setupDefaultSecurity(xstream);
		return xstream;
		XStream xstream = new EnhancedXStream(true);
		XStream.setupDefaultSecurity(xstream);
		return xstream;
		try(InputStreamReader isr = new InputStreamReader(is, StandardCharsets.UTF_8);) {
		try(InputStream is = new ByteArrayInputStream(xml.getBytes(StandardCharsets.UTF_8))) {
		try(OutputStreamWriter osw = new OutputStreamWriter(os, StandardCharsets.UTF_8)) {
			data = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
		XStreamHelper.allowDefaultPackage(readXstream);
		XStreamHelper.allowDefaultPackage(writeXstream);
		
	private static final XStream xstream = XStreamHelper.createXStreamInstance();
	static {
		XStreamHelper.allowDefaultPackage(xstream);
	}
	
	public static EfficiencyStatement fromXML(String xml) {
		return (EfficiencyStatement)xstream.fromXML(xml);
	}
	
	public static String toXML(EfficiencyStatement statement) {
		return xstream.toXML(statement);
	}
		efficiencyProperty.setStatementXml(toXML(efficiencyStatement));
		return fromXML(s.getStatementXml());
		return fromXML(statement.get(0).getStatementXml());
		return fromXML(statement.get(0).getStatementXml());
				EfficiencyStatement s = fromXML(statement.getStatementXml());
import org.olat.course.assessment.manager.EfficiencyStatementManager;

			String xml = EfficiencyStatementManager.toXML(statement); 
				statement = EfficiencyStatementManager.fromXML(statementXml);
				statement = EfficiencyStatementManager.fromXML(media.getContent());
	private static final XStream xstream = XStreamHelper.createXStreamInstance();
	static {
		XStreamHelper.allowDefaultPackage(xstream);
	}
		xstream.toXML(customConfig, configTarget.getOutputStream(false));
			return (Map<String, Map<String, Object>>) xstream.fromXML(in);
				XStreamHelper.allowDefaultPackage(xstream);
		XStreamHelper.allowDefaultPackage(xstream);
		XStreamHelper.allowDefaultPackage(xstream);
	static {
		XStreamHelper.allowDefaultPackage(taskDefinitionsXstream);
	}
		XStreamHelper.allowDefaultPackage(logXStream);
		File file = new File(exportDirectory, "chat.xml");
		try(Writer writer = new FileWriter(file);
			ObjectOutputStream out = logXStream.createObjectOutputStream(writer)) {		
		XStreamHelper.allowDefaultPackage(disadvantageCompensationXStream);
		XStreamHelper.allowDefaultPackage(lectureBlockXStream);
		XStreamHelper.allowDefaultPackage(rollCallXStream);
		XStreamHelper.allowDefaultPackage(summaryXStream);
		XStreamHelper.allowDefaultPackage(absenceNoticeXStream);
		XStreamHelper.allowDefaultPackage(absenceNoticeRelationsXStream);
		XStreamHelper.allowDefaultPackage(xStream);
	static {
		XStreamHelper.allowDefaultPackage(myStream);
	}
			log.error("Cannot import this map: {}", path, e);
			log.error("Cannot export this map: {}", binder, e);
		XStreamHelper.allowDefaultPackage(xstream);
		XStreamHelper.allowDefaultPackage(metadatXstream);
		XStreamHelper.allowDefaultPackage(qitemXStream);
		XStreamHelper.allowDefaultPackage(ruleXStream);
		XStreamHelper.allowDefaultPackage(competenceXStream);
import org.olat.modules.video.VideoMetadata;
import org.olat.modules.video.model.VideoMetadataImpl;
				VideoMeta.class, VideoMetaImpl.class,
				VideoMetadata.class, VideoMetadataImpl.class
		XStreamHelper.allowDefaultPackage(xStream);
		XStreamHelper.allowDefaultPackage(xstream);
		XStreamHelper.allowDefaultPackage(xstream);
import java.util.HashMap;
import com.thoughtworks.xstream.security.ExplicitTypePermission;
		Class<?>[] types = new Class[] {
				HashMap.class
			};
		xmlXStream.addPermission(new ExplicitTypePermission(types));
		XStreamHelper.allowDefaultPackage(xstream);
	static {
		XStreamHelper.allowDefaultPackage(myXStream);
	}
			//TODO xstream
import org.olat.core.util.xml.XStreamHelper;
import org.olat.fileresource.FileResourceManager;
import org.olat.modules.video.model.VideoMetadataImpl;

	private static final String FILENAME_VIDEO_METADATA_XML = "video_metadata.xml";
			if (isMetadataFileValid(videoResource)) {
				VideoMetadata metafromXML = readVideoMetadataFile(videoResource);
	
	private boolean isMetadataFileValid(OLATResource videoResource) {
		VFSContainer baseContainer = FileResourceManager.getInstance().getFileResourceRootImpl(videoResource);
		VFSLeaf metaDataFile = (VFSLeaf) baseContainer.resolve(FILENAME_VIDEO_METADATA_XML);
		try {
			VideoMetadata meta = (VideoMetadata) XStreamHelper.readObject(XStreamHelper.createXStreamInstance(), metaDataFile);
			return meta != null;
		} catch (Exception e) {
			return false;
		}
	}
	
	private VideoMetadata readVideoMetadataFile(OLATResource videoResource){
		VFSContainer baseContainer= FileResourceManager.getInstance().getFileResourceRootImpl(videoResource);
		VFSLeaf metaDataFile = (VFSLeaf) baseContainer.resolve(FILENAME_VIDEO_METADATA_XML);
		try {
			return (VideoMetadata) XStreamHelper.readObject(XStreamHelper.createXStreamInstance(), metaDataFile);
		} catch (Exception e) {
			log.error("Error while parsing XStream file for videoResource::{}", videoResource, e);
			// return an empty, so at least it displays something and not an error
			VideoMetadata meta =  new VideoMetadataImpl();
			meta.setWidth(800);
			meta.setHeight(600);
			return meta;
		}
	}
			log.warn("Cannot read files from dir: {}", item.getDirectory());
				XStreamHelper.allowDefaultPackage(xstream);
/**
 * <a href="http://www.openolat.org">
 * OpenOLAT - Online Learning and Training</a><br>
 * <p>
 * Licensed under the Apache License, Version 2.0 (the "License"); <br>
 * you may not use this file except in compliance with the License.<br>
 * You may obtain a copy of the License at the
 * <a href="http://www.apache.org/licenses/LICENSE-2.0">Apache homepage</a>
 * <p>
 * Unless required by applicable law or agreed to in writing,<br>
 * software distributed under the License is distributed on an "AS IS" BASIS, <br>
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
 * See the License for the specific language governing permissions and <br>
 * limitations under the License.
 * <p>
 * Initial code contributed and copyrighted by<br>
 * frentix GmbH, http://www.frentix.com
 * <p>
 */
package org.olat.upgrade;

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;

import org.apache.logging.log4j.Logger;
import org.olat.core.commons.modules.bc.FolderConfig;
import org.olat.core.commons.persistence.DB;
import org.olat.core.commons.persistence.QueryBuilder;
import org.olat.core.logging.Tracing;
import org.olat.core.util.xml.XStreamHelper;
import org.olat.course.CourseXStreamAliases;
import org.olat.course.PersistingCourseImpl;
import org.springframework.beans.factory.annotation.Autowired;

import com.thoughtworks.xstream.XStream;

/**
 * 
 * Initial date: 18 juin 2021<br>
 * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
 *
 */
public class OLATUpgrade_15_3_18 extends OLATUpgrade {

	private static final Logger log = Tracing.createLoggerFor(OLATUpgrade_15_3_18.class);

	private static final String VERSION = "OLAT_15.3.18";
	private static final String OPEN_COURSES = "OPEN COURSES";

	@Autowired
	private DB dbInstance;

	public OLATUpgrade_15_3_18() {
		super();
	}
	
	@Override
	public String getVersion() {
		return VERSION;
	}
	
	@Override
	public boolean doPostSystemInitUpgrade(UpgradeManager upgradeManager) {
		UpgradeHistoryData uhd = upgradeManager.getUpgradesHistory(VERSION);
		if (uhd == null) {
			// has never been called, initialize
			uhd = new UpgradeHistoryData();
		} else if (uhd.isInstallationComplete()) {
			return false;
		}
		
		boolean allOk = true;
		allOk &= openCourse(upgradeManager, uhd);

		uhd.setInstallationComplete(allOk);
		upgradeManager.setUpgradesHistory(uhd, VERSION);
		if(allOk) {
			log.info(Tracing.M_AUDIT, "Finished OLATUpgrade_15_3_18 successfully!");
		} else {
			log.info(Tracing.M_AUDIT, "OLATUpgrade_15_3_18 not finished, try to restart OpenOlat!");
		}
		return allOk;
	}
	
	private boolean openCourse(UpgradeManager upgradeManager, UpgradeHistoryData uhd) {
		boolean allOk = true;
		if (!uhd.getBooleanDataValue(OPEN_COURSES)) {
			try {
				Path coursesPath = Paths.get(FolderConfig.getCanonicalRoot(), PersistingCourseImpl.COURSE_ROOT_DIR_NAME);
				List<Long> resourceIds = getCourseKeys();
				for(Long resourceId:resourceIds)  {
					checkCourse(coursesPath, resourceId);
				}
			} catch (Exception e) {
				log.error("", e);
				allOk = false;
			}
			
			uhd.setBooleanDataValue(OPEN_COURSES, allOk);
			upgradeManager.setUpgradesHistory(uhd, VERSION);
		}
		return allOk;
	}
	
	private void checkCourse(Path coursesPath, Long resourceId) {
		try {
			Path coursePath =  coursesPath.resolve(resourceId.toString());
			Path runStructure = coursePath.resolve(PersistingCourseImpl.RUNSTRUCTURE_XML);
			Path editorTree = coursePath.resolve(PersistingCourseImpl.EDITORTREEMODEL_XML);

			XStream xstream = CourseXStreamAliases.getReadCourseXStream();
			if(Files.exists(runStructure)) {
				XStreamHelper.readObject(xstream, runStructure.toFile());
			}
			if(Files.exists(editorTree)) {
				XStreamHelper.readObject(xstream, editorTree.toFile());
			}
		} catch (Exception e) {
			log.error("Error with course: {}", resourceId, e);
		}
	}
	
	private List<Long> getCourseKeys() {
		QueryBuilder sb = new QueryBuilder();
		sb.append("select ores.resId from repositoryentry v")
		  .append(" inner join v.olatResource as ores")
		  .and().append(" ores.resName = 'CourseModule'");
		
		List<Long> courseKeys = dbInstance.getCurrentEntityManager()
				.createQuery(sb.toString(), Long.class)
				.getResultList();
		dbInstance.commitAndCloseSession();
		return courseKeys;
	}
}
import org.apache.logging.log4j.Logger;
import com.thoughtworks.xstream.security.ExplicitTypePermission;
	protected static final XStream upgradesXStream = XStreamHelper.createXStreamInstance();
	static {
		Class<?>[] types = new Class[] {
				UpgradeHistoryData.class
			};
		upgradesXStream.addPermission(new ExplicitTypePermission(types));
	}
			upgradesHistories = read(upgradesHistoriesFile);

	@SuppressWarnings("unchecked")
	protected static Map<String, UpgradeHistoryData> read(File file) {
		return (Map<String, UpgradeHistoryData>)upgradesXStream.fromXML(file);
	}
				<bean id="upgrade_15_3_18" class="org.olat.upgrade.OLATUpgrade_15_3_18"/>
				log.error("Error while loading homepage config from path::{}, fallback to default configuration",
						configFile.getAbsolutePath(), e);
		XStreamHelper.allowDefaultPackage(interestsXStream);
/**
 * <a href="http://www.openolat.org">
 * OpenOLAT - Online Learning and Training</a><br>
 * <p>
 * Licensed under the Apache License, Version 2.0 (the "License"); <br>
 * you may not use this file except in compliance with the License.<br>
 * You may obtain a copy of the License at the
 * <a href="http://www.apache.org/licenses/LICENSE-2.0">Apache homepage</a>
 * <p>
 * Unless required by applicable law or agreed to in writing,<br>
 * software distributed under the License is distributed on an "AS IS" BASIS, <br>
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
 * See the License for the specific language governing permissions and <br>
 * limitations under the License.
 * <p>
 * Initial code contributed and copyrighted by<br>
 * frentix GmbH, http://www.frentix.com
 * <p>
 */
package org.olat.core.commons.modules.glossary;

import java.io.File;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

import org.apache.logging.log4j.Logger;
import org.junit.Assert;
import org.junit.Test;
import org.olat.core.logging.Tracing;
import org.olat.core.util.WebappHelper;
import org.olat.core.util.vfs.VFSLeaf;
import org.olat.test.OlatTestCase;
import org.olat.test.VFSJavaIOFile;
import org.springframework.beans.factory.annotation.Autowired;

/**
 * 
 * Initial date: 21 juin 2021<br>
 * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
 *
 */
public class GlossaryItemManagerTest extends OlatTestCase {
	
	private static final Logger log = Tracing.createLoggerFor(GlossaryItemManagerTest.class);
	
	@Autowired
	private GlossaryItemManager glossaryItemManager;
	
	@Test
	public void loadGlossaryItemListFromFile() throws URISyntaxException {
		URL glossaryUrl = GlossaryItemManagerTest.class.getResource("glossary.xml");
		VFSLeaf glossaryLeaf = new VFSJavaIOFile(glossaryUrl.toURI());
		List<GlossaryItem> items = glossaryItemManager.loadGlossaryItemListFromFile(glossaryLeaf);
		Assert.assertNotNull(items);
	}
	
	@Test
	public void saveToFile() throws URISyntaxException, MalformedURLException{
		GlossaryItem item = new GlossaryItem("Definition", "This is a definition.");
		List<String> flexions = new ArrayList<>();
		flexions.add("Add");
		flexions.add("Flex");
		item.setGlossFlexions(flexions);
		List<URI> uris = new ArrayList<>();
		uris.add(new URL("https://www.frentix.com").toURI());
		item.setGlossLinks(uris);
		List<String> synonyms = new ArrayList<>();
		synonyms.add("Synonym");
		item.setGlossSynonyms(synonyms);
		
		List<GlossaryItem> items = new ArrayList<>();
		items.add(item);
		
		File glossaryFile = new File(WebappHelper.getTmpDir(), "glossary" + UUID.randomUUID() + ".xml");
		glossaryFile.getParentFile().mkdirs();
		VFSLeaf glossaryLeaf = new VFSJavaIOFile(glossaryFile);
		glossaryItemManager.saveToFile(glossaryLeaf, items);
		
		// read the files
		List<GlossaryItem> savedItems = glossaryItemManager.loadGlossaryItemListFromFile(glossaryLeaf);
		Assert.assertNotNull(items);
		Assert.assertEquals(1, savedItems.size());
		Assert.assertEquals("Definition", savedItems.get(0).getGlossTerm());
		
		if(!glossaryFile.delete()) {
			log.error("Cannot delete: {}", glossaryFile);
		}
	}
}
<?xml version="1.0" encoding="UTF-8"?>
<list>
  <glossentry>
    <glossTerm>Forsythie</glossTerm>
    <glossDef><![CDATA[<p>Die Forsythie, auch Garten-Forsythie, Goldflieder oder Goldglöckchen genannt, ist ein häufig gepflanzter Zierstrauch. Es handelt sich um eine Hybride zweier Arten aus der Gattung der Forsythien. Diese gehört zur Familie der Ölbaumgewächse.</p>]]></glossDef>
    <glossSynonyms/>
    <revHistory>
      <revision>
        <author>
          <firstname>Jeremery</firstname>
          <surname>Johns</surname>
          <link>[Identity:66027520]</link>
        </author>
        <revisionflag>added</revisionflag>
        <date>22 Mar 2021</date>
      </revision>
      <revision>
        <author>
          <firstname>Jeremery</firstname>
          <surname>Johns</surname>
          <link>[Identity:66027520]</link>
        </author>
        <revisionflag>added</revisionflag>
        <date>22 Mar 2021</date>
      </revision>
      <revision>
        <author>
          <firstname>Jeremery</firstname>
          <surname>Johns</surname>
          <link>[Identity:66027520]</link>
        </author>
        <revisionflag>changed</revisionflag>
        <date>22 Mar 2021</date>
      </revision>
    </revHistory>
  </glossentry>
  <glossentry>
    <glossTerm>Kraut- und Braunfäule</glossTerm>
    <glossDef><![CDATA[<p><img src="https://www.gesal.ch/.imaging/focus/dam/global/pests-diseases/Kraut-Braunfaeule_Tomate.jpg0/jcr:content.jpeg?x&#61;53&amp;y&#61;41&amp;lastModified&#61;Mon&#43;Dec&#43;02&#43;13%3A31%3A13&#43;CET&#43;2019&amp;width&#61;472&amp;height&#61;354" alt=" herb and brown rot - Kraut- und Braunfaeule" width="117" height="88" /></p>
<p>Kraut- und Braunfäule ist eine Pilzerkrankung, die vor allem im Sommer bei feuchten Witterungsbedingungen auftritt. Bei Tomatenpflanzen erscheinen auf den Blättern graugrüne später braune Flecken, die sich schnell ausbreiten. Die Früchte zeigen schmutzig braune Flecken. Das Fruchtfleisch ist unter den Flecken verhärtet und fault. Die Dauerformen dieses Schadpilzes überdauern im Boden und befallen bei geeigneten Bedingungen (feuchtwarm über 15°C) ab Ende Juni zunächst die bodennahen Blätter.</p>]]></glossDef>
    <glossSynonyms/>
    <revHistory>
      <revision>
        <author>
          <firstname>Jeremery</firstname>
          <surname>Johns</surname>
          <link>[Identity:66027520]</link>
        </author>
        <revisionflag>added</revisionflag>
        <date>23 Mar 2021</date>
      </revision>
    </revHistory>
  </glossentry>
  <glossentry>
    <glossTerm>Test</glossTerm>
    <glossDef></glossDef>
    <glossSynonyms/>
    <revHistory>
      <revision>
        <author>
          <firstname>Jeremery</firstname>
          <surname>Johns</surname>
          <link>[Identity:66027520]</link>
        </author>
        <revisionflag>added</revisionflag>
        <date>23 Mar 2021</date>
      </revision>
    </revHistory>
  </glossentry>
  <glossentry>
    <glossTerm>Tomatenhaus</glossTerm>
    <glossDef><![CDATA[<p>Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet.</p>]]></glossDef>
    <glossSynonyms/>
    <revHistory>
      <revision>
        <author>
          <firstname>Jeremery</firstname>
          <surname>Johns</surname>
          <link>[Identity:66027520]</link>
        </author>
        <revisionflag>added</revisionflag>
        <date>24 Mar 2021</date>
      </revision>
    </revHistory>
  </glossentry>
</list>
		ptask.setTask(PersistentTaskDAO.toXML(new DummyTask()));
		alienTask.setTask(PersistentTaskDAO.toXML(new DummyTask()));
	
		Object objReloaded = MapperDAO.fromXML(pMapper.getXmlConfiguration());
		Object objReloaded = MapperDAO.fromXML(pMapper.getXmlConfiguration());
		Object objReloaded2 = MapperDAO.fromXML(loadedMapper2.getXmlConfiguration());
		Object objReloaded = MapperDAO.fromXML(pMapper.getXmlConfiguration());
		Object objReloaded2 = MapperDAO.fromXML(loadedMapper2.getXmlConfiguration());
			// do nothing
/**
 * <a href="http://www.openolat.org">
 * OpenOLAT - Online Learning and Training</a><br>
 * <p>
 * Licensed under the Apache License, Version 2.0 (the "License"); <br>
 * you may not use this file except in compliance with the License.<br>
 * You may obtain a copy of the License at the
 * <a href="http://www.apache.org/licenses/LICENSE-2.0">Apache homepage</a>
 * <p>
 * Unless required by applicable law or agreed to in writing,<br>
 * software distributed under the License is distributed on an "AS IS" BASIS, <br>
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
 * See the License for the specific language governing permissions and <br>
 * limitations under the License.
 * <p>
 * Initial code contributed and copyrighted by<br>
 * frentix GmbH, http://www.frentix.com
 * <p>
 */
package org.olat.core.util.xml;

import java.io.File;
import java.net.URISyntaxException;
import java.net.URL;

import org.junit.Assert;
import org.junit.Test;
import org.olat.core.logging.OLATRuntimeException;

import com.thoughtworks.xstream.converters.ConversionException;

/**
 * 
 * Initial date: 18 juin 2021<br>
 * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
 *
 */
public class XStreamHelperTest {
	
	@Test
	public void readXmlMapAllowed() throws URISyntaxException {
		URL url = XStreamHelperTest.class.getResource("xstream_map_strings.xml");
		File file = new File(url.toURI());
		Object obj = XStreamHelper.createXStreamInstance().fromXML(file);
		Assert.assertNotNull(obj);
	}
	
	@Test
	public void readXmlMapDbObjectsAllowed() throws URISyntaxException {
		URL url = XStreamHelperTest.class.getResource("xstream_map_strings.xml");
		File file = new File(url.toURI());
		Object obj = XStreamHelper.createXStreamInstanceForDBObjects().fromXML(file);
		Assert.assertNotNull(obj);
	}
	
	@Test
	public void readXmlMapUnconfiguredAllowed() throws URISyntaxException {
		URL url = XStreamHelperTest.class.getResource("xstream_map_strings.xml");
		File file = new File(url.toURI());
		Object obj = XStreamHelper.readObject(file);
		Assert.assertNotNull(obj);
	}

	@Test(expected = ConversionException.class)
	public void readXmlMapNotAllowed() throws URISyntaxException {
		URL url = XStreamHelperTest.class.getResource("xstream_map_alien.xml");
		File file = new File(url.toURI());
		XStreamHelper.createXStreamInstance().fromXML(file);
	}
	
	@Test(expected = ConversionException.class)
	public void readXmlMapDbObjectsNotAllowed() throws URISyntaxException {
		URL url = XStreamHelperTest.class.getResource("xstream_map_alien.xml");
		File file = new File(url.toURI());
		XStreamHelper.createXStreamInstanceForDBObjects().fromXML(file);
	}
	
	@Test(expected = OLATRuntimeException.class)
	public void readXmlMapUnconfiguredNotAllowed() throws URISyntaxException {
		URL url = XStreamHelperTest.class.getResource("xstream_map_alien.xml");
		File file = new File(url.toURI());
		XStreamHelper.readObject(file);
	}
}
<java.util.HashMap>
  <entry>
    <string>Hello</string>
    <org.springframework.scheduling.quartz.JobDetailFactoryBean>
    	<name>World</name>
    </org.springframework.scheduling.quartz.JobDetailFactoryBean>
  </entry>
</java.util.HashMap>
<java.util.HashMap>
  <entry>
    <string>Hello</string>
    <string>World</string>
  </entry>
</java.util.HashMap>
	org.olat.core.util.xml.XStreamHelperTest.class,
	org.olat.core.commons.modules.glossary.GlossaryItemManagerTest.class,
	org.olat.upgrade.UpgradeDefinitionTest.class,
	org.olat.upgrade.UpgradeManagerTest.class
import java.io.FileOutputStream;
import java.net.URI;
import org.apache.logging.log4j.Logger;
import org.olat.core.logging.Tracing;
	
	private static final Logger log = Tracing.createLoggerFor(VFSJavaIOFile.class);
	public VFSJavaIOFile(URI uri) {
		this(new File(uri));
	}
	
		try {
			return new FileOutputStream(file);
		} catch (FileNotFoundException e) {
			log.error("", e);
			return null;
		}
/**
 * <a href="http://www.openolat.org">
 * OpenOLAT - Online Learning and Training</a><br>
 * <p>
 * Licensed under the Apache License, Version 2.0 (the "License"); <br>
 * you may not use this file except in compliance with the License.<br>
 * You may obtain a copy of the License at the
 * <a href="http://www.apache.org/licenses/LICENSE-2.0">Apache homepage</a>
 * <p>
 * Unless required by applicable law or agreed to in writing,<br>
 * software distributed under the License is distributed on an "AS IS" BASIS, <br>
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. <br>
 * See the License for the specific language governing permissions and <br>
 * limitations under the License.
 * <p>
 * Initial code contributed and copyrighted by<br>
 * frentix GmbH, http://www.frentix.com
 * <p>
 */
package org.olat.upgrade;

import java.io.File;
import java.net.URL;
import java.util.Map;
import java.util.UUID;

import org.apache.logging.log4j.Logger;
import org.junit.Assert;
import org.junit.Test;
import org.olat.core.logging.Tracing;
import org.olat.core.util.WebappHelper;
import org.olat.core.util.xml.XStreamHelper;

/**
 * 
 * Initial date: 18 juin 2021<br>
 * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
 *
 */
public class UpgradeManagerTest {
	
	private static final Logger log = Tracing.createLoggerFor(UpgradeManagerTest.class);
	
	@Test
	public void readUpgradesXml() throws Exception {
		URL upgradeUrl = UpgradeManagerTest.class.getResource("installed_upgrades.xml");
		File upgradeFile = new File(upgradeUrl.toURI());
		Map<String, UpgradeHistoryData> upgrades = UpgradeManager.read(upgradeFile);
		Assert.assertNotNull(upgrades);
		Assert.assertFalse(upgrades.isEmpty());
	}
	
	@Test
	public void readDatabaseUpgradesXml() throws Exception {
		URL upgradeUrl = UpgradeManagerTest.class.getResource("installed_database_upgrades.xml");
		File upgradeFile = new File(upgradeUrl.toURI());
		Map<String, UpgradeHistoryData> upgrades = UpgradeManager.read(upgradeFile);
		Assert.assertNotNull(upgrades);
		Assert.assertFalse(upgrades.isEmpty());
	}
	
	@Test
	public void writeDatabaseUpgradesXml() throws Exception {
		URL upgradeUrl = UpgradeManagerTest.class.getResource("installed_database_upgrades.xml");
		File upgradeFile = new File(upgradeUrl.toURI());
		Map<String, UpgradeHistoryData> upgrades = UpgradeManager.read(upgradeFile);
		Assert.assertNotNull(upgrades);
		Assert.assertFalse(upgrades.isEmpty());

		File savedFile = new File(WebappHelper.getTmpDir(), "upgradeDB-" + UUID.randomUUID() + ".xml");
		XStreamHelper.writeObject(UpgradeManager.upgradesXStream, savedFile, upgrades);
		if(!savedFile.delete()) {
			log.error("Cannot delete: {}", savedFile);
		}
	}
}
<?xml version="1.0" encoding="UTF-8"?>
<map>
  <entry>
    <string>OLAT_11.0.6</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_11.0.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.3.1</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.3.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.3.2</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_14.2.16</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_14.2.17</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_14.1.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_9.2.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_14.2.13</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_14.1.3</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_14.1.2</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_14.1.6</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_10.2.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_13.3.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_12.1.1</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_12.1.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_8.1.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_12.5.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_11.5.1</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_11.5.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_9.1.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.2.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.2.2</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.2.1</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_11.1.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.2.3</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.2.6</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_11.1.2</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.2.5</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_10.3.3</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_14.0.1</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_14.0.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_11.0.0-user</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLATfx_8.2.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_10.3.1</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_10.3.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_13.2.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_13.2.3</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_12.0.1</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_12.0.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.3.8</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_8.2.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_12.4.1</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_12.4.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_9.0.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.1.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_11.2.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.5.1</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.5.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_10.0.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_9.4.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLATfx_8.1.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_10.4.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_13.1.1</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_13.1.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_7.1.2</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_7.1.1</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_7.1.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_8.3.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_13.0.0.beta1</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_13.0.0.beta10</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_13.0.0.beta4</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_13.0.0.beta6</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.pre.8</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_13.0.0.beta8</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.pre.6</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_13.0.0.beta7</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.pre.7</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_12.3.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.pre.4</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_13.0.0.beta9</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.pre.5</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.2.7</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.pre.3</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.pre.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_12.5.24</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.0.2</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.4.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.0.3</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.4.2</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.4.1</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_11.3.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_10.5.8</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_10.5.7</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_10.5.5</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_10.1.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_14.2.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_10.5.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_14.2.7</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_14.2.6</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_14.2.5</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_12.5.14</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_13.0.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_8.4.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_12.2.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_8.0.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_8.0.2</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
</map>
<?xml version="1.0" encoding="UTF-8"?>
<map>
  <entry>
    <string>OLAT_11.0.6</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>RECERTIFICATION DATE</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_9.0.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.1.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>ADD BIG BLUE BUTTON URL TO CALENDAR</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>MIGRATE USER LIFECYCLE</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_11.0.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>ASSESSMENT PROPERTY TABLE</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>EFFICIENCY STATEMENT TABLE</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>PORTFOLIO SETTINGS</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.3.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>RESET FAILED THUMBNAILS</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>MIGRATE ONLYOFFICE CONFIGS</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_11.0.2</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>PORTFOLIO v2 USER TOOL</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.5.1</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>ADD MISSING ENTRY TECHNICAL TYPE</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>COPY PORTFOLIO PAGE EDITABLE FLAG</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_11.4.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>GROUP INFO MESSAGE</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_11.2.1</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>STATUS OLD TASK ELEMENT</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_14.1.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>SET MS ORES TYPE NAME</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.2.8.fx</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>RESET FAILED PDF THUMBNAILS</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_10.0.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_9.4.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_14.2.10</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>VIDEO VFS METADATA</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_10.4.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Calendar user configurations</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>Imported calendars</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>Calendar tokens</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>Imported calendars url</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_10.0.3</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_13.1.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>CLEAN META PATH ERRORS</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>CLEAN META FORUM</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>CLEAN META HOMEPAGES</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>CLEAN META TMP</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>CLEAN META RESOURCES</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>CLEAN META CTS</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>CLEAN META COURSES</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>CLEAN META HOMES</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_7.1.1</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_7.1.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_8.3.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_13.0.0.beta1</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>MIGRATE TEMP KEY VALID UNTIL</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>MIGRATE QUALITY DATA COLLECTION TO ORGANISATION</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_13.0.0.beta10</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>MIGRATE BOOKABLE</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.pre.8</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>DELETE PORTFOLIO V1</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_13.3.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>MIGRATE FILE METADATA</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>MIGRATE LIBRARY CONFIGURATION</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>MOVE REPO IMAGES</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>MIGRATE CURRICULUM ROLES</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.pre.6</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>CATALOG ORDER INDEX</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_13.0.0.beta7</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>MIGRATE SURVEY SERIES</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_12.3.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>MIGRATE QPOOL TITLE</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>MIGRATE DIALOG ELEMENTS</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>MOVE DOC POOL INFOS PAGE</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.pre.4</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>CATALOG ORDER INDEX</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_13.0.0.beta9</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>MIGRATE BOOKABLE</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.pre.5</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>CATALOG ORDER INDEX</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.pre.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>INIT ASESSMENT ENTRY ROOT</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_8.1.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_12.5.3</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>MIGRATE WEB FEED</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.hammed</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>CLEANUP CERTIFICATES</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.2.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>MIGRATE USER PROPERTY</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>MIGRATE USER NAME</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.2.2</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>MIGRATE CATALOG SORTING</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.4.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>INIT VFS MODIFIED BY</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>INIT ENTRY TECHNICAL TYPE</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.0.3</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>ASSESSMENT LAST ATTEMPTS</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.2.3</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>CLEAN UP REPOSITORY ENTRY TO GROUP RELATION</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.2.6</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>CLEAN UP APPOINTMENT ORGANIZERS</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_11.3.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>VIDEO XML</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.pre.6.ae</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>CONDITION COURSES COMPLETION</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.3.12</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>DELETE APPOINTMENT USER RESTRICTIONS</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_14.0.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>MIGRATE FILE METADATA</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>MIGRATE LIBRARY CONFIGURATION</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>MOVE REPO IMAGES</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>MIGRATE CURRICULUM ROLES</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_10.1.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_12.5.17</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>UPDATE COURSE STATS</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_14.0.5</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>UPDATE UNKOWN VIDEO FORMAT</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_14.0.3</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>PASSWORD SYNTAX CHECK TYPO</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_14.2.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>TRANSFER INFOS NOTIFICATIONS NOT DESIRED</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>DATA COLLECTION ORGANISATIONS</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>LIVE STREAM LAUNCHES</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_14.2.7</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>BIGBLUEBUTTON SERVER TO DB</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_14.2.6</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>DELETE COURSE EXPORT DIRECTORY</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>DELETE DOWNLOAD ZIP</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_10.3.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Clean export folder</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_13.0.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>PORTFOLIO EVALUATION FORM</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>MIGRATE ROLE</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>LECTURES SEND APPEAL DATES</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>MIGRATE ADMIN SITE SECURITY CALLBACK</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>MIGRATE REPO ENTRY TO DEF ORG</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>MIGRATE LUCENE 7.5</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>MIGRATE INVITEE</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>MIGRATE REPO ENTRY ACCESS</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_13.2.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>UPDATE CURRICULUM CHILDREN</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_7.0.2</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData/>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_7.0.1</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_8.4.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_13.2.8</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>GUEST COURSE NODES PASSWORDS</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_13.2.4</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>ORPHAN IDENTITIES</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_8.4.5</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_12.2.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>MIGRATE QPOOL TAXONOMY</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>MAIL CONFIG SPLITTING</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>KEEP INTERNAL MAIL DISABLED</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_15.3.6</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>MIGRATE BIGBLUEBUTTON JOIN FLAG</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_12.0.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>LAST USER MODIFICATION</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>USER PROPERTY CONTEXT RENAME</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>FEED XML TO DB</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_8.2.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>Database update</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_12.4.1</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>MIGRATE PASSWORD HISTORY</string>
          <boolean>true</boolean>
        </entry>
        <entry>
          <string>MIGRATE CHANGE PASSWORD</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
  <entry>
    <string>OLAT_12.4.0</string>
    <org.olat.upgrade.UpgradeHistoryData>
      <upgradeData>
        <entry>
          <string>MIGRATE QPOOL LICENSE</string>
          <boolean>true</boolean>
        </entry>
      </upgradeData>
      <installationComplete>true</installationComplete>
    </org.olat.upgrade.UpgradeHistoryData>
  </entry>
</map>