/// <summary> /// Creates a new resource of type collectionName in the repository. /// </summary> /// <param name="collectionName">The resource type.</param> /// <param name="atomEntry">Information about the resource.</param> /// <returns>A SyndicationItem that describes the newly created resource.</returns> /// <exception cref="ArgumentNullException">Throws exception if collectionName is null/empty /// or atomEntry is null/empty .</exception> SyndicationItem IAtomPubStoreWriter.CreateMember(string collectionName, AtomEntryDocument atomEntry) { if (string.IsNullOrEmpty(collectionName)) { throw new ArgumentNullException("collectionName"); } if (null == atomEntry) { throw new ArgumentNullException("atomEntry"); } AuthenticatedToken authenticatedToken = CoreHelper.GetAuthenticationToken(); using (ZentityContext context = CoreHelper.CreateZentityContext()) { if (!authenticatedToken.HasCreatePermission(context)) { throw new UnauthorizedException(Resources.ATOMPUB_UNAUTHORIZED); } ScholarlyWork resource = CreateScholarlyWork(collectionName); context.AddToResources(resource); ZentityAtomPubStoreWriter.UpdateResourceProperty(context, resource, atomEntry); resource.GrantDefaultPermissions(context, authenticatedToken); context.SaveChanges(); return(ZentityAtomPubStoreReader.GenerateSyndicationItem(this.BaseUri, resource)); } }
/// <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> /// 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> /// <exception cref="ArgumentNullException">Throws exception if collectionName is null/empty /// or mimeType is null/empty or media is null.</exception> protected SyndicationItem 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"); } AuthenticatedToken authenticatedToken = CoreHelper.GetAuthenticationToken(); using (ZentityContext context = CoreHelper.CreateZentityContext()) { if (!authenticatedToken.HasCreatePermission(context)) { throw new UnauthorizedException(Resources.ATOMPUB_UNAUTHORIZED); } ScholarlyWork resource = CreateScholarlyWork(collectionName); resource.DateModified = DateTime.Now; Core.File mediaResource = new Core.File(); mediaResource.MimeType = mimeType; mediaResource.FileExtension = string.IsNullOrEmpty(fileExtension) ? AtomPubHelper.GetFileExtension(mimeType) : fileExtension; context.AddToResources(mediaResource); context.SaveChanges(); resource.Files.Add(mediaResource); MemoryStream mediaStream = ZentityAtomPubStoreWriter.GetMediaStream(media); context.UploadFileContent(mediaResource, mediaStream); mediaStream.Close(); resource.GrantDefaultPermissions(context, authenticatedToken); mediaResource.GrantDefaultPermissions(context, authenticatedToken); context.SaveChanges(); return(ZentityAtomPubStoreReader.GenerateSyndicationItem(this.BaseUri, resource)); } }
/// <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)); } }