Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Licensed to The Apereo Foundation under one or more contributor license
* agreements. See the NOTICE file distributed with this work for additional
* information regarding copyright ownership.
*
*
* The Apereo Foundation licenses this file to you under the Educational
* Community License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of the License
* at:
*
* http://opensource.org/licenses/ecl2.txt
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*
*/
package org.opencastproject.mediapackage.elementbuilder;
import org.opencastproject.mediapackage.Attachment;
import org.opencastproject.mediapackage.MediaPackageElement;
import org.opencastproject.mediapackage.MediaPackageElementFlavor;
import org.opencastproject.mediapackage.MediaPackageReferenceImpl;
import org.opencastproject.mediapackage.MediaPackageSerializer;
import org.opencastproject.mediapackage.UnsupportedElementException;
import org.opencastproject.mediapackage.attachment.AttachmentImpl;
import org.opencastproject.util.Checksum;
import org.opencastproject.util.MimeType;
import org.opencastproject.util.MimeTypes;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import java.net.URI;
import java.net.URISyntaxException;
import java.security.NoSuchAlgorithmException;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpressionException;
/**
* This implementation of the {@link MediaPackageElementBuilderPlugin} recognizes attachments and provides utility
* methods for creating media package element representations for them.
*/
public abstract class AbstractAttachmentBuilderPlugin extends AbstractElementBuilderPlugin {
/** the logging facility provided by log4j */
private static final Logger logger = LoggerFactory.getLogger(AbstractAttachmentBuilderPlugin.class);
/** The flavor to look for */
protected MediaPackageElementFlavor flavor = null;
/**
* Creates a new attachment plugin builder that will accept attachments with any flavor.
*/
public AbstractAttachmentBuilderPlugin() {
this(null);
}
/**
* Creates a new attachment plugin builder that will accept attachments with the given flavor.
*
* @param flavor
* the attachment flavor
*/
public AbstractAttachmentBuilderPlugin(MediaPackageElementFlavor flavor) {
this.flavor = flavor;
}
/**
* @see org.opencastproject.mediapackage.elementbuilder.MediaPackageElementBuilderPlugin#accept(URI,
* org.opencastproject.mediapackage.MediaPackageElement.Type ,
* org.opencastproject.mediapackage.MediaPackageElementFlavor)
*/
@Override
public boolean accept(URI uri, MediaPackageElement.Type type, MediaPackageElementFlavor flavor) {
return accept(type, flavor);
}
/**
* This implementation of accept tests for the element type (attachment).
*
* @see org.opencastproject.mediapackage.elementbuilder.MediaPackageElementBuilderPlugin#accept(org.opencastproject.mediapackage.MediaPackageElement.Type
* , org.opencastproject.mediapackage.MediaPackageElementFlavor)
*/
@Override
public boolean accept(MediaPackageElement.Type type, MediaPackageElementFlavor flavor) {
if (this.flavor != null && !this.flavor.equals(flavor))
return false;
return type == null || MediaPackageElement.Type.Attachment.toString().equalsIgnoreCase(type.toString());
}
/**
* This implementation of accept tests for the correct node type (attachment).
*
* @see org.opencastproject.mediapackage.elementbuilder.MediaPackageElementBuilderPlugin#accept(org.w3c.dom.Node)
*/
@Override
public boolean accept(Node elementNode) {
try {
// Test for attachment
String nodeName = elementNode.getNodeName();
if (nodeName.contains(":")) {
nodeName = nodeName.substring(nodeName.indexOf(":") + 1);
}
if (!MediaPackageElement.Type.Attachment.toString().equalsIgnoreCase(nodeName))
return false;
// Check flavor
if (this.flavor != null) {
String nodeFlavor = (String) xpath.evaluate("@type", elementNode, XPathConstants.STRING);
if (!flavor.eq(nodeFlavor))
return false;
}
// Check mime type
if (mimeTypes != null && mimeTypes.size() > 0) {
String nodeMimeType = (String) xpath.evaluate("mimetype", elementNode, XPathConstants.STRING);
MimeType mimeType = MimeTypes.parseMimeType(nodeMimeType);
if (!mimeTypes.contains(mimeType))
return false;
}
return true;
} catch (XPathExpressionException e) {
logger.warn("Error while reading attachment flavor from manifest: " + e.getMessage());
return false;
}
}
/**
* @see org.opencastproject.mediapackage.MediaPackageElementBuilder#newElement(org.opencastproject.mediapackage.MediaPackageElement.Type
* , org.opencastproject.mediapackage.MediaPackageElementFlavor)
*/
@Override
public MediaPackageElement newElement(MediaPackageElement.Type type, MediaPackageElementFlavor flavor) {
Attachment attachment = new AttachmentImpl();
attachment.setFlavor(flavor);
return attachment;
}
/**
* @see org.opencastproject.mediapackage.elementbuilder.MediaPackageElementBuilderPlugin#elementFromManifest(org.w3c.dom.Node,
* org.opencastproject.mediapackage.MediaPackageSerializer)
*/
@Override
public MediaPackageElement elementFromManifest(Node elementNode, MediaPackageSerializer serializer)
throws UnsupportedElementException {
String id = null;
String attachmentFlavor = null;
String reference = null;
URI uri = null;
long size = -1;
Checksum checksum = null;
MimeType mimeType = null;
try {
// id
id = (String) xpath.evaluate("@id", elementNode, XPathConstants.STRING);
// flavor
attachmentFlavor = (String) xpath.evaluate("@type", elementNode, XPathConstants.STRING);
// reference
reference = (String) xpath.evaluate("@ref", elementNode, XPathConstants.STRING);
// url
uri = serializer.decodeURI(new URI(xpath.evaluate("url/text()", elementNode).trim()));
// size
String attachmentSize = xpath.evaluate("size/text()", elementNode).trim();
if (!"".equals(attachmentSize))
size = Long.parseLong(attachmentSize);
// checksum
String checksumValue = (String) xpath.evaluate("checksum/text()", elementNode, XPathConstants.STRING);
String checksumType = (String) xpath.evaluate("checksum/@type", elementNode, XPathConstants.STRING);
if (StringUtils.isNotEmpty(checksumValue) && checksumType != null)
checksum = Checksum.create(checksumType.trim(), checksumValue.trim());
// mimetype
String mimeTypeValue = (String) xpath.evaluate("mimetype/text()", elementNode, XPathConstants.STRING);
if (StringUtils.isNotEmpty(mimeTypeValue))
mimeType = MimeTypes.parseMimeType(mimeTypeValue);
// create the attachment
AttachmentImpl attachment = (AttachmentImpl) AttachmentImpl.fromURI(uri);
if (StringUtils.isNotEmpty(id))
attachment.setIdentifier(id);
// Add url
attachment.setURI(uri);
// Add reference
if (StringUtils.isNotEmpty(reference))
attachment.referTo(MediaPackageReferenceImpl.fromString(reference));
// Add type/flavor information
if (StringUtils.isNotEmpty(attachmentFlavor)) {
try {
MediaPackageElementFlavor flavor = MediaPackageElementFlavor.parseFlavor(attachmentFlavor);
attachment.setFlavor(flavor);
} catch (IllegalArgumentException e) {
logger.warn("Unable to read attachment flavor: " + e.getMessage());
}
}
// Set the size
if (size > 0)
attachment.setSize(size);
// Set checksum
if (checksum != null)
attachment.setChecksum(checksum);
// Set mimetype
if (mimeType != null)
attachment.setMimeType(mimeType);
// Set the description
String description = xpath.evaluate("description/text()", elementNode);
if (StringUtils.isNotEmpty(description))
attachment.setElementDescription(description.trim());
// Set tags
NodeList tagNodes = (NodeList) xpath.evaluate("tags/tag", elementNode, XPathConstants.NODESET);
for (int i = 0; i < tagNodes.getLength(); i++) {
attachment.addTag(tagNodes.item(i).getTextContent());
}
return specializeAttachment(attachment);
} catch (XPathExpressionException e) {
throw new UnsupportedElementException("Error while reading attachment from manifest: " + e.getMessage());
} catch (NoSuchAlgorithmException e) {
throw new UnsupportedElementException("Unsupported digest algorithm: " + e.getMessage());
} catch (URISyntaxException e) {
throw new UnsupportedElementException("Error while reading attachment file " + uri + ": " + e.getMessage());
}
}
/**
* Utility method that returns an attachment object from the given url.
*
* @param uri
* the element location
* @return an attachment object
* @throws UnsupportedElementException
* if the attachment cannto be read
*/
@Override
public MediaPackageElement elementFromURI(URI uri) throws UnsupportedElementException {
logger.trace("Creating attachment from " + uri);
return specializeAttachment(AttachmentImpl.fromURI(uri));
}
/**
* @see org.opencastproject.mediapackage.MediaPackageElementBuilder#elementFromURI(URI,
* org.opencastproject.mediapackage.MediaPackageElement.Type ,
* org.opencastproject.mediapackage.MediaPackageElementFlavor)
*/
public MediaPackageElement elementFromURI(URI uri, MediaPackageElement.Type type, MediaPackageElementFlavor flavor)
throws UnsupportedElementException {
return elementFromURI(uri);
}
/**
* Overwrite this method in order to return a specialization of the attachment. This implementation just returns the
* attachment that is was given.
*
* @param attachment
* the general attachment representation
* @return a specialized attachment
* @throws UnsupportedElementException
* if the attachment fails to be specialized
*/
protected Attachment specializeAttachment(Attachment attachment) throws UnsupportedElementException {
return attachment;
}
/**
* @see java.lang.Object#toString()
*/
@Override
public String toString() {
return "Attachment Builder Plugin";
}
}
