/// <summary>
/// Adds the child resources.
/// </summary>
/// <param name="extractionPath">The extraction path.</param>
/// <param name="document">The document.</param>
/// <param name="resource">The resource.</param>
/// <param name="zentityContext">The zentity context.</param>
private static void AddChildResources(
string extractionPath,
MetsDocument document,
ScholarlyWork resource,
ZentityContext zentityContext)
{
resource.Container = new ScholarlyWorkContainer();
ScholarlyWorkContainer childContainer = null;
string[] fileNames = Directory.GetFiles(extractionPath)
.Select(path => GetFileName(path))
.Where(name => SwordConstants.MetsDocumentName != name)
.ToArray();
if (0 < fileNames.Length)
{
childContainer = new ScholarlyWorkContainer();
resource.Container.ContainedWorks.Add(childContainer);
}
// Loop though all files which are extracted.
foreach (string fileName in fileNames)
{
// Get the extension
int dotIndex = fileName.LastIndexOf('.');
string fileExtension = (0 < dotIndex) ? fileName.Substring(dotIndex + 1) : string.Empty;
#region Upload Zip File Contents
// Get Metadata for the specified fileName
MetadataSection dataSection = document.Files[fileName];
// Create resource against each type as specified in the METS document.
ScholarlyWork individualResource = CreateResouceUsingMetsMetadata(dataSection);
UpdateResourceProeprties(zentityContext, individualResource, dataSection);
// Create Media and Upload file contents.
Core.File individualMediaResource = AddFileResource(zentityContext,
individualResource,
extractionPath + "\\" + fileName);
individualMediaResource.MimeType = AtomPubHelper.GetMimeTypeFromFileExtension(fileExtension);
individualMediaResource.FileExtension = fileExtension;
// Save file name in notes for future references.
individualMediaResource.Description = fileName;
// Associate with the main resource.
childContainer.ContainedWorks.Add(individualResource);
#endregion
AuthenticatedToken authenticatedToken = CoreHelper.GetAuthenticationToken();
individualResource.GrantDefaultPermissions(zentityContext, authenticatedToken);
individualMediaResource.GrantDefaultPermissions(zentityContext, authenticatedToken);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MetadataSectionCollection"/> class.
/// </summary>
/// <param name="metsDocument">METS document instance.</param>
internal MetadataSectionCollection(MetsDocument metsDocument)
{
this.MetsXmlDocument = metsDocument;
// Catches all file names from the given MetsDocument.
if (null != this.MetsXmlDocument.MetadataPointer)
{
Files = this.MetsXmlDocument.MetadataPointer.Select(ptr => ptr.FileName).Distinct().ToArray();
}
}
/// <summary>
/// Creates a new Resource.File for a specified resource of type collectionName in the repository.
/// </summary>
/// <param name="collectionName">The resource type.</param>
/// <param name="mimeType">The MIME type of media.</param>
/// <param name="media">The new File contents.</param>
/// <param name="fileExtension">The media file extension.</param>
/// <returns>A SyndicationItem that describes the newly created resource.</returns>
SyndicationItem IAtomPubStoreWriter.CreateMedia(string collectionName, string mimeType,
byte[] media, string fileExtension)
{
if (string.IsNullOrEmpty(collectionName))
{
throw new ArgumentNullException("collectionName");
}
if (string.IsNullOrEmpty(mimeType))
{
throw new ArgumentNullException("mimeType");
}
if (null == media)
{
throw new ArgumentNullException("media");
}
if (SwordConstants.ZipContentType != mimeType)
{
return(base.CreateMedia(collectionName, mimeType, media, fileExtension));
}
// Convert byte array to stream.
MemoryStream mediaStream = ZentityAtomPubStoreWriter.GetMediaStream(media);
string extractionPath = ExtractZipContent(mediaStream);
HttpContext.Current.Items[SwordConstants.ZipExtractedPath] = extractionPath;
// Get the path of METS xml file.
string metsFilePath = extractionPath + "\\" + SwordConstants.MetsDocumentName;
if (!System.IO.File.Exists(metsFilePath))
{
//string errorMessage = string.Format(CultureInfo.CurrentCulture,
// Properties.Resources.SWORD_MISSING_METS_DOCUMENT,
// SwordConstants.MetsDocumentName);
//throw new MetsException(errorMessage);
return(base.CreateMedia(collectionName, mimeType, media, fileExtension));
}
AuthenticatedToken authenticatedToken = CoreHelper.GetAuthenticationToken();
using (ZentityContext zentityContext = CoreHelper.CreateZentityContext())
{
if (!authenticatedToken.HasCreatePermission(zentityContext))
{
throw new UnauthorizedException(Resources.ATOMPUB_UNAUTHORIZED);
}
// Generate METS document from given METS xml file.
MetsDocument document = new MetsDocument(metsFilePath);
// Create resource of specified collection type.
ScholarlyWork resource = CreateScholarlyWork(collectionName);
resource.DateModified = DateTime.Now;
// Upload the zip file contents as media for main resource.
// This will be required in AtomPub get requests and further use.
Core.File mediaResource = AddFileResource(zentityContext, resource, mediaStream);
mediaResource.MimeType = mimeType;
mediaResource.FileExtension = AtomPubHelper.GetFileExtension(mimeType);
// close the stream
mediaStream.Close();
AddChildResources(extractionPath, document, resource, zentityContext);
resource.GrantDefaultPermissions(zentityContext, authenticatedToken);
mediaResource.GrantDefaultPermissions(zentityContext, authenticatedToken);
// Save all changes at the end
zentityContext.SaveChanges();
return(ZentityAtomPubStoreReader.GenerateSyndicationItem(base.BaseUri, resource));
}
}
