diff --git a/src/main/java/org/olat/core/commons/modules/glossary/GlossaryItemManager.java b/src/main/java/org/olat/core/commons/modules/glossary/GlossaryItemManager.java
index b6cc6b8a909686bff0f3567548f61f509a5af0a4..56015ee749f9c056959dc896104398d653d22f06 100644
--- a/src/main/java/org/olat/core/commons/modules/glossary/GlossaryItemManager.java
+++ b/src/main/java/org/olat/core/commons/modules/glossary/GlossaryItemManager.java
@@ -278,7 +278,7 @@ public class GlossaryItemManager {
List<GlossaryItem> glossaryItemList = new ArrayList<>();
if (glossaryFile == null) { return new ArrayList<>(); }
- Object glossObj = XStreamHelper.readObject(xstreamReader, glossaryFile.getInputStream());
+ Object glossObj = XStreamHelper.readObject(xstreamReader, glossaryFile);
if (glossObj instanceof ArrayList) {
ArrayList<GlossaryItem> glossItemsFromFile = (ArrayList<GlossaryItem>) glossObj;
glossaryItemList.addAll(glossItemsFromFile);
diff --git a/src/main/java/org/olat/core/util/xml/XStreamHelper.java b/src/main/java/org/olat/core/util/xml/XStreamHelper.java
index 6d2914f3eb89cc4694e69bb5eb56e4ff4b19bfbc..0c011ca9eb39b736048e5fe126d09b4cfcacbdc0 100644
--- a/src/main/java/org/olat/core/util/xml/XStreamHelper.java
+++ b/src/main/java/org/olat/core/util/xml/XStreamHelper.java
@@ -251,25 +251,11 @@ public class XStreamHelper {
* @return
*/
public static Object readObject(XStream xStream, File file) {
- FileInputStream fis = null;
- BufferedInputStream bis = null;
- try {
- fis = new FileInputStream(file);
- bis = new BufferedInputStream(fis);
+ try(FileInputStream fis = new FileInputStream(file);
+ BufferedInputStream bis = new BufferedInputStream(fis)) {
return readObject(xStream, bis);
} catch (IOException e) {
- throw new OLATRuntimeException(XStreamHelper.class,
- "could not read Object from file: "
- + file.getAbsolutePath(), e);
- } finally {
- try {
- if (fis != null)
- fis.close();
- if (bis != null)
- bis.close();
- } catch (Exception e) {
- // we did our best to close the inputStream
- }
+ throw new OLATRuntimeException(XStreamHelper.class, "could not read Object from file: " + file.getAbsolutePath(), e);
}
}
@@ -284,9 +270,7 @@ public class XStreamHelper {
InputStream bis = new BufferedInputStream(in)) {
return readObject(xStream, bis);
} catch (Exception e) {
- throw new OLATRuntimeException(XStreamHelper.class,
- "could not read Object from file: "
- + path, e);
+ throw new OLATRuntimeException(XStreamHelper.class, "could not read Object from file: " + path, e);
}
}
@@ -300,25 +284,11 @@ public class XStreamHelper {
* @return
*/
public static Object readObject(XStream xStream, VFSLeaf file) {
- InputStream fis = null;
- BufferedInputStream bis = null;
- try {
- fis = file.getInputStream();
- bis = new BufferedInputStream(fis);
+ try(InputStream fis = file.getInputStream();
+ BufferedInputStream bis = new BufferedInputStream(fis)) {
return readObject(xStream, bis);
} catch (Exception e) {
- throw new OLATRuntimeException(XStreamHelper.class,
- "could not read Object from file: "
- + file.getName(), e);
- } finally {
- try {
- if (fis != null)
- fis.close();
- if (bis != null)
- bis.close();
- } catch (Exception e) {
- // we did our best to close the inputStream
- }
+ throw new OLATRuntimeException(XStreamHelper.class, "could not read Object from file: " + file.getName(), e);
}
}
@@ -332,12 +302,8 @@ public class XStreamHelper {
* @return
*/
public static Object readObject(XStream xStream, InputStream is) {
- try {
- InputStreamReader isr = new InputStreamReader(is, ENCODING);
- Object obj = xStream.fromXML(isr);
- isr.close();
- is.close();
- return obj;
+ try(InputStreamReader isr = new InputStreamReader(is, ENCODING);) {
+ return xStream.fromXML(isr);
} catch (Exception e) {
throw new OLATRuntimeException(XStreamHelper.class,
"could not read Object from inputstream: " + is, e);
diff --git a/src/main/java/org/olat/course/PersistingCourseImpl.java b/src/main/java/org/olat/course/PersistingCourseImpl.java
index 054643858387a8aafd3d558e5e49016900b79611..ac151b4f0df80327533e4e6a8cdab7b281d46f12 100644
--- a/src/main/java/org/olat/course/PersistingCourseImpl.java
+++ b/src/main/java/org/olat/course/PersistingCourseImpl.java
@@ -476,12 +476,12 @@ public class PersistingCourseImpl implements ICourse, OLATResourceable, Serializ
*/
private Object readObject(String fileName) {
VFSItem vfsItem = getCourseBaseContainer().resolve(fileName);
- if (vfsItem == null || !(vfsItem instanceof VFSLeaf)) {
+ if (!(vfsItem instanceof VFSLeaf)) {
throw new CorruptedCourseException("Cannot resolve file: " + fileName + " course=" + toString());
}
try {
XStream xstream = CourseXStreamAliases.getReadCourseXStream();
- return XStreamHelper.readObject(xstream, ((VFSLeaf)vfsItem).getInputStream());
+ return XStreamHelper.readObject(xstream, (VFSLeaf)vfsItem);
} catch (Exception e) {
log.error("Cannot read course tree file: " + fileName, e);
throw new CorruptedCourseException("Cannot resolve file: " + fileName + " course=" + toString(), e);
diff --git a/src/main/java/org/olat/course/config/manager/CourseConfigManagerImpl.java b/src/main/java/org/olat/course/config/manager/CourseConfigManagerImpl.java
index abc67450c699c474415e883c72917fcb2e2150b8..40e7d43e8cc6282daff3e68a10a448b01df752a2 100644
--- a/src/main/java/org/olat/course/config/manager/CourseConfigManagerImpl.java
+++ b/src/main/java/org/olat/course/config/manager/CourseConfigManagerImpl.java
@@ -89,7 +89,7 @@ public class CourseConfigManagerImpl implements CourseConfigManager {
saveConfigTo(course, retVal);
} else {
//file exists, load it with XStream, resolve version
- Object tmp = XStreamHelper.readObject(xstream, configFile.getInputStream());
+ Object tmp = XStreamHelper.readObject(xstream, configFile);
if (tmp instanceof CourseConfig) {
retVal = (CourseConfig) tmp;
if (retVal.resolveVersionIssues()) {
diff --git a/src/main/java/org/olat/modules/video/VideoManager.java b/src/main/java/org/olat/modules/video/VideoManager.java
index f9e1a2dd0db1568e89cf1232bbf3592d3c1f934f..6f37936e14625edb74a0837d193b19809699e4bf 100644
--- a/src/main/java/org/olat/modules/video/VideoManager.java
+++ b/src/main/java/org/olat/modules/video/VideoManager.java
@@ -274,7 +274,7 @@ public interface VideoManager {
* @param sourceResource the existing video resource
* @param targetResource the empty new resource
*/
- public void copyVideo(OLATResource sourceResource, OLATResource targetResource);
+ public void copyVideo(RepositoryEntry sourceEntry, RepositoryEntry targetEntry);
/**
* Delete the video transcodings on disk an in database
diff --git a/src/main/java/org/olat/modules/video/manager/VideoManagerImpl.java b/src/main/java/org/olat/modules/video/manager/VideoManagerImpl.java
index 0389dc79155cdbd98136cf9e5383de6baca00d23..4f7f770cb03efd97c455d2caa0ee3dbe40edb270 100644
--- a/src/main/java/org/olat/modules/video/manager/VideoManagerImpl.java
+++ b/src/main/java/org/olat/modules/video/manager/VideoManagerImpl.java
@@ -60,6 +60,7 @@ import org.olat.core.logging.OLog;
import org.olat.core.logging.Tracing;
import org.olat.core.util.FileUtils;
import org.olat.core.util.Formatter;
+import org.olat.core.util.StringHelper;
import org.olat.core.util.ZipUtil;
import org.olat.core.util.httpclient.HttpClientFactory;
import org.olat.core.util.vfs.LocalFileImpl;
@@ -614,7 +615,13 @@ public class VideoManagerImpl implements VideoManager {
LocalFolderImpl repoentryContainer = (LocalFolderImpl)VFSManager.resolveOrCreateContainerFromPath(baseContainer, DIRNAME_REPOENTRY);
RepositoryEntryImportExport importExport = new RepositoryEntryImportExport(repoEntry, repoentryContainer.getBasefile());
importExport.exportDoExportProperties();
- // 2) package everything in resource folder to streaming zip resource
+ // 2) dump video metadata to resource folder
+ VideoMeta videoMeta = getVideoMetadata(videoResource);
+ if(videoMeta != null) {
+ VFSLeaf videoMetaFile = VFSManager.resolveOrCreateLeafFromPath(repoentryContainer, FILENAME_VIDEO_METADATA_XML);
+ VideoMetaXStream.toXml(videoMetaFile, videoMeta);
+ }
+ // 3) package everything in resource folder to streaming zip resource
return new VideoExportMediaResource(baseContainer, repoEntry.getDisplayname());
}
@@ -808,8 +815,15 @@ public class VideoManagerImpl implements VideoManager {
// 2) update metadata from the repo entry export
LocalFolderImpl repoentryContainer = (LocalFolderImpl) baseContainer.resolve(DIRNAME_REPOENTRY);
if (repoentryContainer != null) {
+ // repo metadata
RepositoryEntryImportExport importExport = new RepositoryEntryImportExport(repoentryContainer.getBasefile());
importExport.setRepoEntryPropertiesFromImport(repoEntry);
+ // video metadata
+ VFSItem videoMetaFile = repoentryContainer.resolve(FILENAME_VIDEO_METADATA_XML);
+ if(videoMetaFile instanceof VFSLeaf) {
+ VideoMeta videoMeta = VideoMetaXStream.fromXml((VFSLeaf)videoMetaFile);
+ videoMetadataDao.copyVideoMetadata(repoEntry, videoMeta);
+ }
// now delete the import folder, not used anymore
repoentryContainer.delete();
}
@@ -830,13 +844,20 @@ public class VideoManagerImpl implements VideoManager {
}
@Override
- public void copyVideo(OLATResource sourceResource, OLATResource targetResource) {
+ public void copyVideo(RepositoryEntry sourceEntry, RepositoryEntry targetEntry) {
+ OLATResource sourceResource = sourceEntry.getOlatResource();
+ OLATResource targetResource = targetEntry.getOlatResource();
// 1) Copy files on disk
File sourceFileroot = FileResourceManager.getInstance().getFileResourceRootImpl(sourceResource).getBasefile();
File targetFileroot = FileResourceManager.getInstance().getFileResourceRootImpl(targetResource).getBasefile();
FileUtils.copyDirContentsToDir(sourceFileroot, targetFileroot, false, "copyVideoResource");
- // 2) Trigger transcoding in background
- if (videoModule.isTranscodingEnabled()) {
+ // 2) Copy metadata
+ VideoMetaImpl sourceMeta = getVideoMetadata(sourceResource);
+ if(sourceMeta != null) {
+ sourceMeta = videoMetadataDao.copyVideoMetadata(targetEntry, sourceMeta);
+ }
+ // 3) Trigger transcoding in background
+ if (videoModule.isTranscodingEnabled() && !StringHelper.containsNonWhitespace(sourceMeta.getUrl())) {
startTranscodingProcess(targetResource);
}
}
diff --git a/src/main/java/org/olat/modules/video/manager/VideoMetaXStream.java b/src/main/java/org/olat/modules/video/manager/VideoMetaXStream.java
new file mode 100644
index 0000000000000000000000000000000000000000..38b08563e78d7af5fbacb1136116bf639411e474
--- /dev/null
+++ b/src/main/java/org/olat/modules/video/manager/VideoMetaXStream.java
@@ -0,0 +1,76 @@
+/**
+ * <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.modules.video.manager;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+
+import org.olat.core.util.vfs.VFSLeaf;
+import org.olat.core.util.xml.XStreamHelper;
+import org.olat.modules.video.VideoMeta;
+import org.olat.modules.video.model.VideoMetaImpl;
+
+import com.thoughtworks.xstream.XStream;
+import com.thoughtworks.xstream.security.ExplicitTypePermission;
+
+/**
+ *
+ * Initial date: 13 févr. 2019<br>
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ *
+ */
+public class VideoMetaXStream {
+
+ private static final XStream xstream = XStreamHelper.createXStreamInstance();
+ static {
+ XStream.setupDefaultSecurity(xstream);
+ Class<?>[] types = new Class[] {
+ VideoMeta.class, VideoMetaImpl.class
+ };
+ xstream.addPermission(new ExplicitTypePermission(types));
+ xstream.ignoreUnknownElements();
+
+ xstream.alias("videoMeta", VideoMetaImpl.class);
+ xstream.omitField(VideoMetaImpl.class, "videoResource");
+ }
+
+ public static void toXml(VFSLeaf file, VideoMeta obj) {
+ XStreamHelper.writeObject(xstream, file, obj);
+ }
+
+ public static void toXml(OutputStream out, VideoMeta obj) {
+ XStreamHelper.writeObject(xstream, out, obj);
+ }
+
+ /**
+ * Your responsible to close the input stream.
+ *
+ * @param in The input stream
+ * @return The video metadata
+ */
+ public static VideoMeta fromXml(InputStream in) {
+ return (VideoMeta)xstream.fromXML(in);
+ }
+
+ public static VideoMeta fromXml(VFSLeaf file) {
+ return (VideoMeta)XStreamHelper.readObject(xstream, file);
+ }
+
+}
diff --git a/src/main/java/org/olat/modules/video/manager/VideoMetadataDAO.java b/src/main/java/org/olat/modules/video/manager/VideoMetadataDAO.java
index 2c6b544eebdc1472c4fb52ed5b162212ee67f64a..9841903006e156c619feceab115bf0d4d40cfaa8 100644
--- a/src/main/java/org/olat/modules/video/manager/VideoMetadataDAO.java
+++ b/src/main/java/org/olat/modules/video/manager/VideoMetadataDAO.java
@@ -139,5 +139,20 @@ public class VideoMetadataDAO {
dbInstance.getCurrentEntityManager().persist(videometa);
return videometa;
}
+
+ VideoMetaImpl copyVideoMetadata(RepositoryEntry repoEntry, VideoMeta sourceMeta) {
+ VideoMetaImpl videometa = new VideoMetaImpl();
+ videometa.setVideoResource(repoEntry.getOlatResource());
+ videometa.setVideoFormat(sourceMeta.getVideoFormat());
+ videometa.setUrl(sourceMeta.getUrl());
+ videometa.setCreationDate(new Date());
+ videometa.setLastModified(videometa.getCreationDate());
+ videometa.setHeight(sourceMeta.getHeight());
+ videometa.setWidth(sourceMeta.getWidth());
+ videometa.setSize(sourceMeta.getSize());
+ videometa.setLength(sourceMeta.getLength());
+ dbInstance.getCurrentEntityManager().persist(videometa);
+ return videometa;
+ }
}
diff --git a/src/main/java/org/olat/modules/video/model/VideoMetadataImpl.java b/src/main/java/org/olat/modules/video/model/VideoMetadataImpl.java
index 986b7be9d4f27cfe90a861e5cb8a6eb3043b4b86..07de0f760c9d47f52c42ce724717679e955b9eef 100644
--- a/src/main/java/org/olat/modules/video/model/VideoMetadataImpl.java
+++ b/src/main/java/org/olat/modules/video/model/VideoMetadataImpl.java
@@ -33,7 +33,6 @@ import org.olat.modules.video.VideoMetadata;
* @author Dirk Furrer
*
*/
-
public class VideoMetadataImpl implements Serializable, VideoMetadata {
private static final long serialVersionUID = 1L;
private int width;
@@ -41,7 +40,7 @@ public class VideoMetadataImpl implements Serializable, VideoMetadata {
private HashMap<String, String> tracks;
public VideoMetadataImpl() {
- tracks = new HashMap<String, String>();
+ tracks = new HashMap<>();
}
@Override
diff --git a/src/main/java/org/olat/modules/webFeed/manager/FeedFileStorge.java b/src/main/java/org/olat/modules/webFeed/manager/FeedFileStorge.java
index dd50003e47539e8b7f00087657de86a9aa6290f7..25d07e706aa42c594c44ef79a94256e6f86dbde3 100644
--- a/src/main/java/org/olat/modules/webFeed/manager/FeedFileStorge.java
+++ b/src/main/java/org/olat/modules/webFeed/manager/FeedFileStorge.java
@@ -291,7 +291,7 @@ public class FeedFileStorge {
if (feedContainer != null) {
VFSLeaf leaf = (VFSLeaf) feedContainer.resolve(FEED_FILE_NAME);
if (leaf != null) {
- feed = (FeedImpl) XStreamHelper.readObject(xstream, leaf.getInputStream());
+ feed = (FeedImpl) XStreamHelper.readObject(xstream, leaf);
shorteningFeedToLengthOfDbAttribues(feed);
}
} else {
@@ -390,7 +390,7 @@ public class FeedFileStorge {
VFSLeaf leaf = (VFSLeaf) itemContainer.resolve(ITEM_FILE_NAME);
if (leaf != null) {
try {
- item = (ItemImpl) XStreamHelper.readObject(xstream, leaf.getInputStream());
+ item = (ItemImpl) XStreamHelper.readObject(xstream, leaf);
} catch (Exception e) {
log.warn("Item XML-File could not be read. Item container: " + leaf);
}
diff --git a/src/main/java/org/olat/repository/RepositoryEntryImportExport.java b/src/main/java/org/olat/repository/RepositoryEntryImportExport.java
index 3883867ed2db7b5dccc556cde658eb2098d456ed..21eba90248778d24ebb6edebc1dd2b5717cc9c13 100644
--- a/src/main/java/org/olat/repository/RepositoryEntryImportExport.java
+++ b/src/main/java/org/olat/repository/RepositoryEntryImportExport.java
@@ -30,11 +30,11 @@ 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.nio.file.StandardOpenOption;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
@@ -165,9 +165,9 @@ public class RepositoryEntryImportExport {
}
}
- private void addLicenseInformations(RepositoryEntryImport imp, RepositoryEntry re) {
+ private void addLicenseInformations(RepositoryEntryImport imp, RepositoryEntry entry) {
LicenseService licenseService = CoreSpringFactory.getImpl(LicenseService.class);
- ResourceLicense license = licenseService.loadLicense(re.getOlatResource());
+ ResourceLicense license = licenseService.loadLicense(entry.getOlatResource());
if (license != null) {
imp.setLicenseTypeKey(String.valueOf(license.getLicenseType().getKey()));
imp.setLicenseTypeName(license.getLicenseType().getName());
@@ -183,8 +183,9 @@ public class RepositoryEntryImportExport {
if(image != null) {
imp.setImageName(image.getName());
zout.putNextEntry(new ZipEntry(image.getName()));
- try(InputStream inImage=image.getInputStream()) {
- FileUtils.copy(inImage, new ShieldOutputStream(zout));
+ try(InputStream inImage=image.getInputStream();
+ OutputStream out = new ShieldOutputStream(zout)) {
+ FileUtils.copy(inImage, out);
} catch(Exception e) {
log.error("", e);
}
@@ -196,8 +197,9 @@ public class RepositoryEntryImportExport {
if(movie != null) {
imp.setMovieName(movie.getName());
zout.putNextEntry(new ZipEntry(movie.getName()));
- try(InputStream inMovie=movie.getInputStream()) {
- FileUtils.copy(inMovie, new ShieldOutputStream(zout));
+ try(InputStream inMovie=movie.getInputStream();
+ OutputStream out=new ShieldOutputStream(zout)) {
+ FileUtils.copy(inMovie, out);
} catch(Exception e) {
log.error("", e);
}
@@ -205,7 +207,11 @@ public class RepositoryEntryImportExport {
}
zout.putNextEntry(new ZipEntry(PROPERTIES_FILE));
- getXStream().toXML(imp, new ShieldOutputStream(zout));
+ try(OutputStream out=new ShieldOutputStream(zout)) {
+ getXStream().toXML(imp, out);
+ } catch(IOException e) {
+ log.error("", e);
+ }
zout.closeEntry();
}
@@ -318,37 +324,27 @@ public class RepositoryEntryImportExport {
* Read previousely exported Propertiesproperties
*/
private void loadConfiguration() {
- FileSystem fs = null;
- try {
- if(baseDirectory.exists()) {
- if(baseDirectory.getName().endsWith(".zip")) {
- fs = FileSystems.newFileSystem(baseDirectory.toPath(), null);
+ 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);
- try(InputStream inputFile = Files.newInputStream(manifestPath, StandardOpenOption.READ)) {
- XStream xstream = getXStream();
- repositoryProperties = (RepositoryEntryImport)xstream.fromXML(inputFile);
- } catch(Exception e) {
- log.error("Cannot read repo.xml im zip", e);
- }
- } else {
- File inputFile = new File(baseDirectory, PROPERTIES_FILE);
- if(inputFile.exists()) {
- XStream xstream = getXStream();
- repositoryProperties = (RepositoryEntryImport)xstream.fromXML(inputFile);
- } else {
- repositoryProperties = new RepositoryEntryImport();
- }
+ repositoryProperties = (RepositoryEntryImport)XStreamHelper.readObject(getXStream(), manifestPath);
+ } catch(Exception e) {
+ log.error("", e);
}
} else {
- repositoryProperties = new RepositoryEntryImport();
+ File inputFile = new File(baseDirectory, PROPERTIES_FILE);
+ if(inputFile.exists()) {
+ repositoryProperties = (RepositoryEntryImport)XStreamHelper.readObject(getXStream(), inputFile);
+ } else {
+ repositoryProperties = new RepositoryEntryImport();
+ }
}
- propertiesLoaded = true;
- } catch (Exception ce) {
- throw new OLATRuntimeException("Error importing repository entry properties.", ce);
- } finally {
- IOUtils.closeQuietly(fs);
+ } else {
+ repositoryProperties = new RepositoryEntryImport();
}
+ propertiesLoaded = true;
}
/**
diff --git a/src/main/java/org/olat/repository/handlers/VideoHandler.java b/src/main/java/org/olat/repository/handlers/VideoHandler.java
index 5de80098b20cf2f009033204f9343dcc7e5119dd..932dd4fb53fc07d6fabec6281971229dec160e94 100644
--- a/src/main/java/org/olat/repository/handlers/VideoHandler.java
+++ b/src/main/java/org/olat/repository/handlers/VideoHandler.java
@@ -51,6 +51,7 @@ import org.olat.fileresource.types.ResourceEvaluation;
import org.olat.fileresource.types.VideoFileResource;
import org.olat.modules.video.VideoFormat;
import org.olat.modules.video.VideoManager;
+import org.olat.modules.video.VideoMeta;
import org.olat.modules.video.ui.VideoDisplayController;
import org.olat.modules.video.ui.VideoRuntimeController;
import org.olat.repository.RepositoryEntry;
@@ -164,14 +165,19 @@ public class VideoHandler extends FileHandler {
} else if (fileName.endsWith(".zip")) {
// 2b) import video from archive from another OpenOLAT instance
dbInstance.commit();
- videoManager.importFromExportArchive(repoEntry, importFile);
+ videoManager.importFromExportArchive(repoEntry, importFile);
+ dbInstance.commit();
}
// 3) Persist Meta data
- videoManager.createVideoMetadata(repoEntry, filesize, fileName);
- dbInstance.commit();
+ VideoMeta videoMeta = videoManager.getVideoMetadata(resource);
+ if(videoMeta == null) {
+ videoMeta =videoManager.createVideoMetadata(repoEntry, filesize, fileName);
+ }
+ dbInstance.commit();
// 4) start transcoding process if enabled
- videoManager.startTranscodingProcessIfEnabled(resource);
-
+ if(!StringHelper.containsNonWhitespace(videoMeta.getUrl())) {
+ videoManager.startTranscodingProcessIfEnabled(resource);
+ }
return repoEntry;
}
@@ -277,9 +283,7 @@ public class VideoHandler extends FileHandler {
@Override
public RepositoryEntry copy(Identity author, RepositoryEntry source,
RepositoryEntry target) {
- OLATResource sourceResource = source.getOlatResource();
- OLATResource targetResource = target.getOlatResource();
- videoManager.copyVideo(sourceResource, targetResource);
+ videoManager.copyVideo(source, target);
return target;
}
diff --git a/src/test/java/org/olat/modules/video/manager/VideoMetaXStreamTest.java b/src/test/java/org/olat/modules/video/manager/VideoMetaXStreamTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..08e4b4c04cb65736d2fccfc8a2f58a2b03afd3ad
--- /dev/null
+++ b/src/test/java/org/olat/modules/video/manager/VideoMetaXStreamTest.java
@@ -0,0 +1,79 @@
+/**
+ * <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.modules.video.manager;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.olat.core.commons.persistence.DB;
+import org.olat.core.logging.OLog;
+import org.olat.core.logging.Tracing;
+import org.olat.modules.video.VideoFormat;
+import org.olat.modules.video.VideoMeta;
+import org.olat.repository.RepositoryEntry;
+import org.olat.test.JunitTestHelper;
+import org.olat.test.OlatTestCase;
+import org.springframework.beans.factory.annotation.Autowired;
+
+/**
+ *
+ * Initial date: 28 nov. 2018<br>
+ * @author srosse, stephane.rosse@frentix.com, http://www.frentix.com
+ *
+ */
+public class VideoMetaXStreamTest extends OlatTestCase {
+
+ private static final OLog log = Tracing.createLoggerFor(VideoMetaXStreamTest.class);
+
+ @Autowired
+ private DB dbInstance;
+ @Autowired
+ private VideoMetadataDAO videoMetadataDao;
+
+ @Test
+ public void writeRead_meta() {
+ RepositoryEntry entry = JunitTestHelper.createAndPersistRepositoryEntry();
+ //create metadata entries
+ VideoMeta meta = videoMetadataDao.createVideoMetadata(entry, 1500, null, VideoFormat.mp4);
+ Assert.assertNotNull(meta);
+ dbInstance.commitAndCloseSession();
+
+ byte[] content = null;
+ try(ByteArrayOutputStream out = new ByteArrayOutputStream()) {
+ VideoMetaXStream.toXml(out, meta);
+ content = out.toByteArray();
+ } catch(IOException e) {
+ log.error("", e);
+ }
+
+ Assert.assertNotNull(content);
+
+ try(ByteArrayInputStream in = new ByteArrayInputStream(content)) {
+ VideoMeta reloadedMeta = VideoMetaXStream.fromXml(in);
+ Assert.assertNotNull(reloadedMeta);
+ } catch(IOException e) {
+ log.error("", e);
+ Assert.fail();
+ }
+ }
+}
diff --git a/src/test/java/org/olat/test/AllTestsJunit4.java b/src/test/java/org/olat/test/AllTestsJunit4.java
index 384f74918937f70fd23271e9d8a12644e91681f9..2e134043af31d8d91fb620f4e099322f773424ad 100644
--- a/src/test/java/org/olat/test/AllTestsJunit4.java
+++ b/src/test/java/org/olat/test/AllTestsJunit4.java
@@ -270,6 +270,7 @@ import org.junit.runners.Suite;
org.olat.modules.video.manager.VideoTranscodingDAOTest.class,
org.olat.modules.video.manager.VideoMetadataDAOTest.class,
org.olat.modules.video.manager.VideoXStreamTest.class,
+ org.olat.modules.video.manager.VideoMetaXStreamTest.class,
org.olat.modules.video.manager.VideoManagerTest.class,
org.olat.modules.webFeed.manager.FeedDAOTest.class,
org.olat.modules.webFeed.manager.ItemDAOTest.class,