File size: 19,135 Bytes
4fb7874 |
1 |
/*** OLAT - Online Learning and Training<br>* http://www.olat.org* <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* <p>* http://www.apache.org/licenses/LICENSE-2.0* <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>* Copyright (c) since 2004 at Multimedia- & E-Learning Services (MELS),<br>* University of Zurich, Switzerland.* <hr>* <a href="http://www.openolat.org">* OpenOLAT - Online Learning and Training</a><br>* This file has been modified by the OpenOLAT community. Changes are licensed* under the Apache 2.0 license as the original file.*/package org.olat.repository;import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import java.nio.file.FileSystem;import java.nio.file.FileSystems;import java.nio.file.Files;import java.nio.file.Path;import java.util.zip.ZipEntry;import java.util.zip.ZipOutputStream;import javax.servlet.http.HttpServletResponse;import org.apache.commons.io.IOUtils;import org.apache.logging.log4j.Logger;import org.olat.core.CoreSpringFactory;import org.olat.core.commons.services.license.LicenseService;import org.olat.core.commons.services.license.LicenseType;import org.olat.core.commons.services.license.ResourceLicense;import org.olat.core.commons.services.license.ui.LicenseUIFactory;import org.olat.core.gui.media.MediaResource;import org.olat.core.logging.OLATRuntimeException;import org.olat.core.logging.Tracing;import org.olat.core.util.FileUtils;import org.olat.core.util.StringHelper;import org.olat.core.util.ZipUtil;import org.olat.core.util.io.HttpServletResponseOutputStream;import org.olat.core.util.io.ShieldOutputStream;import org.olat.core.util.vfs.LocalFileImpl;import org.olat.core.util.vfs.VFSContainer;import org.olat.core.util.vfs.VFSLeaf;import org.olat.core.util.vfs.VFSManager;import org.olat.core.util.xml.XStreamHelper;import org.olat.repository.handlers.RepositoryHandler;import org.olat.repository.handlers.RepositoryHandlerFactory;import com.thoughtworks.xstream.XStream;/** * Initial Date: 19.05.2005 * * @author Mike Stock * * Comment: * */public class RepositoryEntryImportExport { private static final Logger log = Tracing.createLoggerFor(RepositoryEntryImportExport.class); private static final String CONTENT_FILE = "repo.zip"; public static final String PROPERTIES_FILE = "repo.xml"; private static final String PROP_ROOT = "RepositoryEntryProperties"; private static final String PROP_SOFTKEY = "Softkey"; private static final String PROP_RESOURCENAME = "ResourceName"; private static final String PROP_DISPLAYNAME = "DisplayName"; private static final String PROP_DECRIPTION = "Description"; private static final String PROP_INITIALAUTHOR = "InitialAuthor"; private static final XStream xstream = XStreamHelper.createXStreamInstance(); static { XStreamHelper.allowDefaultPackage(xstream); xstream.alias(PROP_ROOT, RepositoryEntryImport.class); xstream.aliasField(PROP_SOFTKEY, RepositoryEntryImport.class, "softkey"); xstream.aliasField(PROP_RESOURCENAME, RepositoryEntryImport.class, "resourcename"); xstream.aliasField(PROP_DISPLAYNAME, RepositoryEntryImport.class, "displayname"); xstream.aliasField(PROP_DECRIPTION, RepositoryEntryImport.class, "description"); xstream.aliasField(PROP_INITIALAUTHOR, RepositoryEntryImport.class, "initialAuthor"); xstream.omitField(RepositoryEntryImport.class, "outer-class"); xstream.ignoreUnknownElements(); } private boolean propertiesLoaded = false; private RepositoryEntry re; private File baseDirectory; private RepositoryEntryImport repositoryProperties; /** * Create a RepositoryEntryImportExport instance to do an export. * * @param re * @param baseDirecotry */ public RepositoryEntryImportExport(RepositoryEntry re, File baseDirecotry) { this.re = re; this.baseDirectory = baseDirecotry; } /** * Create a RepositoryEntryImportExport instance to do an import. * * @param baseDirecotry */ public RepositoryEntryImportExport(File baseDirectory) { this.baseDirectory = baseDirectory; } public RepositoryEntryImportExport(File baseDirectory, String subDir) { this.baseDirectory = new File(baseDirectory, subDir); } public boolean anyExportedPropertiesAvailable() { return new File(baseDirectory, PROPERTIES_FILE).exists(); } /** * Export repository entry (contents and metadata. * * @return True upon success, false otherwise. */ public boolean exportDoExport() { exportDoExportProperties(); return exportDoExportContent(); } public boolean exportDoExport(String zipPath, ZipOutputStream zout) { exportDoExportProperties(zipPath, zout); return exportDoExportContent(zipPath, zout); } public void exportDoExportProperties(String zipPath, ZipOutputStream zout) { // save repository entry properties RepositoryEntryImport imp = new RepositoryEntryImport(re); RepositoryManager rm = RepositoryManager.getInstance(); VFSLeaf image = rm.getImage(re); if(image instanceof LocalFileImpl) { imp.setImageName(image.getName()); ZipUtil.addFileToZip(ZipUtil.concat(zipPath, image.getName()) , ((LocalFileImpl)image).getBasefile(), zout); } RepositoryService repositoryService = CoreSpringFactory.getImpl(RepositoryService.class); VFSLeaf movie = repositoryService.getIntroductionMovie(re); if(movie instanceof LocalFileImpl) { imp.setMovieName(movie.getName()); ZipUtil.addFileToZip(ZipUtil.concat(zipPath, movie.getName()), ((LocalFileImpl)movie).getBasefile(), zout); } try(ShieldOutputStream fOut = new ShieldOutputStream(zout)) { addLicenseInformations(imp, re); zout.putNextEntry(new ZipEntry(ZipUtil.concat(zipPath, PROPERTIES_FILE))); xstream.toXML(imp, fOut); zout.closeEntry(); } catch (IOException ioe) { throw new OLATRuntimeException("Error writing repo properties.", ioe); } } /** * Export metadata of a repository entry to a file. * Only one repository entry's metadata may be exported into a directory. The * file name of the properties file will be the same for all repository entries! */ public void exportDoExportProperties() { // save repository entry properties try(FileOutputStream fOut = new FileOutputStream(new File(baseDirectory, PROPERTIES_FILE))) { RepositoryEntryImport imp = new RepositoryEntryImport(re); RepositoryManager rm = RepositoryManager.getInstance(); VFSLeaf image = rm.getImage(re); if(image instanceof LocalFileImpl) { imp.setImageName(image.getName()); FileUtils.copyFileToDir(((LocalFileImpl)image).getBasefile(), baseDirectory, ""); } RepositoryService repositoryService = CoreSpringFactory.getImpl(RepositoryService.class); VFSLeaf movie = repositoryService.getIntroductionMovie(re); if(movie instanceof LocalFileImpl) { imp.setMovieName(movie.getName()); FileUtils.copyFileToDir(((LocalFileImpl)movie).getBasefile(), baseDirectory, ""); } addLicenseInformations(imp, re); xstream.toXML(imp, fOut); } catch (IOException ioe) { throw new OLATRuntimeException("Error writing repo properties.", ioe); } } private void addLicenseInformations(RepositoryEntryImport imp, RepositoryEntry entry) { LicenseService licenseService = CoreSpringFactory.getImpl(LicenseService.class); ResourceLicense license = licenseService.loadLicense(entry.getOlatResource()); if (license != null) { imp.setLicenseTypeKey(String.valueOf(license.getLicenseType().getKey())); imp.setLicenseTypeName(license.getLicenseType().getName()); imp.setLicensor(license.getLicensor()); imp.setLicenseText(LicenseUIFactory.getLicenseText(license)); } } /** * Export a repository entry referenced by a course node to the given export directory. * User importReferencedRepositoryEntry to import again. * @return True upon success, false otherwise. * */ public boolean exportDoExportContent() { // export resource RepositoryHandler rh = RepositoryHandlerFactory.getInstance().getRepositoryHandler(re); MediaResource mr = rh.getAsMediaResource(re.getOlatResource()); try(FileOutputStream fOut = new FileOutputStream(new File(baseDirectory, CONTENT_FILE)); InputStream in = mr.getInputStream()) { if(in == null) { HttpServletResponse hres = new HttpServletResponseOutputStream(fOut); mr.prepare(hres); } else { IOUtils.copy(in, fOut); } fOut.flush(); } catch (IOException fnfe) { return false; } finally { mr.release(); } return true; } public boolean exportDoExportContent(String zipPath, ZipOutputStream zout) { // export resource RepositoryHandler rh = RepositoryHandlerFactory.getInstance().getRepositoryHandler(re); MediaResource mr = rh.getAsMediaResource(re.getOlatResource()); try(OutputStream fOut = new ShieldOutputStream(zout); InputStream in = mr.getInputStream()) { zout.putNextEntry(new ZipEntry(ZipUtil.concat(zipPath, CONTENT_FILE))); if(in == null) { HttpServletResponse hres = new HttpServletResponseOutputStream(fOut); mr.prepare(hres); } else { IOUtils.copy(in, fOut); } fOut.flush(); zout.closeEntry(); } catch (IOException fnfe) { return false; } finally { mr.release(); } return true; } public RepositoryEntry importContent(RepositoryEntry newEntry, VFSContainer mediaContainer) { if(!anyExportedPropertiesAvailable()) return newEntry; RepositoryManager repositoryManager = CoreSpringFactory.getImpl(RepositoryManager.class); if(StringHelper.containsNonWhitespace(getImageName())) { File newFile = new File(baseDirectory, getImageName()); VFSLeaf newImage = new LocalFileImpl(newFile); repositoryManager.setImage(newImage, newEntry); } if(StringHelper.containsNonWhitespace(getMovieName())) { String movieName = getMovieName(); String extension = FileUtils.getFileSuffix(movieName); File newFile = new File(baseDirectory, movieName); try(InputStream inStream = new FileInputStream(newFile)) { VFSLeaf movieLeaf = mediaContainer.createChildLeaf(newEntry.getKey() + "." + extension); VFSManager.copyContent(inStream, movieLeaf); } catch(IOException e) { log.error("", e); } } return setRepoEntryPropertiesFromImport(newEntry); } /** * Update the repo entry property from the current import information in the database * * @param newEntry * @return */ public RepositoryEntry setRepoEntryPropertiesFromImport(RepositoryEntry newEntry) { if(!propertiesLoaded) { loadConfiguration(); } importLicense(newEntry); RepositoryManager repositoryManager = CoreSpringFactory.getImpl(RepositoryManager.class); return repositoryManager.setDescriptionAndName(newEntry, newEntry.getDisplayname(), null, repositoryProperties.getAuthors(), repositoryProperties.getDescription(), repositoryProperties.getObjectives(), repositoryProperties.getRequirements(), repositoryProperties.getCredits(), repositoryProperties.getMainLanguage(), repositoryProperties.getLocation(), repositoryProperties.getExpenditureOfWork(), null, null, null); } private void importLicense(RepositoryEntry newEntry) { if(!propertiesLoaded) { loadConfiguration(); } LicenseService licenseService = CoreSpringFactory.getImpl(LicenseService.class); boolean hasLicense = StringHelper.containsNonWhitespace(repositoryProperties.getLicenseTypeName()); if (hasLicense) { String licenseTypeName = repositoryProperties.getLicenseTypeName(); LicenseType licenseType = licenseService.loadLicenseTypeByName(licenseTypeName); if (licenseType == null) { licenseType = licenseService.createLicenseType(licenseTypeName); licenseType.setText(repositoryProperties.getLicenseText()); licenseService.saveLicenseType(licenseType); } ResourceLicense license = licenseService.loadOrCreateLicense(newEntry.getOlatResource()); license.setLicenseType(licenseType); license.setLicensor(repositoryProperties.getLicensor()); if (licenseService.isFreetext(licenseType)) { license.setFreetext(repositoryProperties.getLicenseText()); } licenseService.update(license); } } /** * Returns the exported repository file. * * @return exported repository file */ public File importGetExportedFile() { return new File(baseDirectory, CONTENT_FILE); } /** * Read previousely exported Propertiesproperties */ private void loadConfiguration() { if(baseDirectory != null && baseDirectory.exists()) { if(baseDirectory.getName().endsWith(".zip")) { try(FileSystem fs = FileSystems.newFileSystem(baseDirectory.toPath(), null)) { Path fPath = fs.getPath("/"); Path manifestPath = fPath.resolve("export").resolve(PROPERTIES_FILE); repositoryProperties = (RepositoryEntryImport)XStreamHelper.readObject(xstream, manifestPath); } catch(Exception e) { log.error("", e); } } else { File inputFile = new File(baseDirectory, PROPERTIES_FILE); if(inputFile.exists()) { repositoryProperties = (RepositoryEntryImport)XStreamHelper.readObject(xstream, inputFile); } else { repositoryProperties = new RepositoryEntryImport(); } } } else { repositoryProperties = new RepositoryEntryImport(); } propertiesLoaded = true; } /** * Get the repo entry import metadata from the given path. E.g. usefull * when reading from an unzipped archive. * * @param repoXmlPath * @return The RepositoryEntryImport or NULL */ public static RepositoryEntryImport getConfiguration(Path repoXmlPath) { try (InputStream in=Files.newInputStream(repoXmlPath)) { return (RepositoryEntryImport)xstream.fromXML(in); } catch(IOException e) { log.error("", e); return null; } } /** * Get the repo entry import metadata from the given stream. E.g. usefull * when reading from an ZIP file without inflating it. * * @param repoMetaFileInputStream * @return The RepositoryEntryImport or NULL */ public static RepositoryEntryImport getConfiguration(InputStream repoMetaFileInputStream) { return (RepositoryEntryImport)xstream.fromXML(repoMetaFileInputStream); } /** * @return The softkey */ public String getSoftkey() { if(!propertiesLoaded) { loadConfiguration(); } return repositoryProperties.getSoftkey(); } /** * @return The display name */ public String getDisplayName() { if(!propertiesLoaded) { loadConfiguration(); } return repositoryProperties.getDisplayname(); } /** * @return the resource name */ public String getResourceName() { if(!propertiesLoaded) { loadConfiguration(); } return repositoryProperties.getResourcename(); } /** * @return the descritpion */ public String getDescription() { if(!propertiesLoaded) { loadConfiguration(); } return repositoryProperties.getDescription(); } /** * @return the initial author */ public String getInitialAuthor() { if(!propertiesLoaded) { loadConfiguration(); } return repositoryProperties.getInitialAuthor(); } public String getMovieName() { if(!propertiesLoaded) { loadConfiguration(); } return repositoryProperties.getMovieName(); } public String getImageName() { if(!propertiesLoaded) { loadConfiguration(); } return repositoryProperties.getImageName(); } public class RepositoryEntryImport { private Long key; private String softkey; private String resourcename; private String displayname; private String description; private String initialAuthor; private String authors; private String mainLanguage; private String objectives; private String requirements; private String credits; private String expenditureOfWork; private String location; private String movieName; private String imageName; private String licenseTypeKey; private String licenseTypeName; private String licensor; private String licenseText; public RepositoryEntryImport() { // } public RepositoryEntryImport(RepositoryEntry re) { key = re.getKey(); softkey = re.getSoftkey(); resourcename = re.getResourcename(); displayname = re.getDisplayname(); description = re.getDescription(); initialAuthor = re.getInitialAuthor(); authors = re.getAuthors(); mainLanguage = re.getMainLanguage(); objectives = re.getObjectives(); requirements = re.getRequirements(); credits = re.getCredits(); expenditureOfWork = re.getExpenditureOfWork(); } public Long getKey() { return key; } public void setKey(Long key) { this.key = key; } public String getMovieName() { return movieName; } public void setMovieName(String movieName) { this.movieName = movieName; } public String getImageName() { return imageName; } public void setImageName(String imageName) { this.imageName = imageName; } public String getSoftkey() { return softkey; } public void setSoftkey(String softkey) { this.softkey = softkey; } public String getResourcename() { return resourcename; } public void setResourcename(String resourcename) { this.resourcename = resourcename; } public String getDisplayname() { return displayname; } public void setDisplayname(String displayname) { this.displayname = displayname; } public String getDescription() { return description; } public void setDescription(String description) { this.description = description; } public String getInitialAuthor() { return initialAuthor; } public void setInitialAuthor(String initialAuthor) { this.initialAuthor = initialAuthor; } public String getAuthors() { return authors; } public void setAuthors(String authors) { this.authors = authors; } public String getMainLanguage() { return mainLanguage; } public void setMainLanguage(String mainLanguage) { this.mainLanguage = mainLanguage; } public String getLocation() { return location; } public void setLocation(String location) { this.location = location; } public String getObjectives() { return objectives; } public void setObjectives(String objectives) { this.objectives = objectives; } public String getRequirements() { return requirements; } public void setRequirements(String requirements) { this.requirements = requirements; } public String getCredits() { return credits; } public void setCredits(String credits) { this.credits = credits; } public String getExpenditureOfWork() { return expenditureOfWork; } public void setExpenditureOfWork(String expenditureOfWork) { this.expenditureOfWork = expenditureOfWork; } public String getLicenseTypeKey() { return licenseTypeKey; } public void setLicenseTypeKey(String licenseTypeKey) { this.licenseTypeKey = licenseTypeKey; } public String getLicenseTypeName() { return licenseTypeName; } public void setLicenseTypeName(String licenseTypeName) { this.licenseTypeName = licenseTypeName; } public String getLicensor() { return licensor; } public void setLicensor(String licensor) { this.licensor = licensor; } public String getLicenseText() { return licenseText; } public void setLicenseText(String licenseText) { this.licenseText = licenseText; } }} |