Example #1
0
        /// <summary>
        /// Processes the GET request sent to the sword service.
        /// </summary>
        /// <param name="context">Object of HttpContext containing the request information.</param>
        /// <param name="statusCode">Out parameter returns status of the request.</param>
        /// <returns>String containing the response to the specified request.</returns>
        public override string ProcessRequest(HttpContext context, out System.Net.HttpStatusCode statusCode)
        {
            string response = string.Empty;

            AtomPubRequestType requestType = AtomPubHelper.GetAtomPubRequestType(context, base.BaseUri);

            switch (requestType)
            {
            case AtomPubRequestType.ServiceDocument:
                statusCode = System.Net.HttpStatusCode.OK;
                response   = this.GetServiceDocument(context);

                // Set content type for Service Document - Bug Fix : 183173
                context.Response.ContentType = AtomPubConstants.ServiceDocumentContentType;
                break;

            case AtomPubRequestType.Collection:
            case AtomPubRequestType.CollectionWithPageNo:
            case AtomPubRequestType.EditMember:
            case AtomPubRequestType.EditMedia:
                response = base.ProcessRequest(context, out statusCode);
                break;

            case AtomPubRequestType.Unknwon:
            default:
                statusCode = System.Net.HttpStatusCode.BadRequest;
                response   = Properties.Resources.ATOMPUB_BAD_REQUEST;
                break;
            }

            return(response);
        }
Example #2
0
        /// <summary>
        /// Processes the request.
        /// </summary>
        /// <param name="context">The HttpContext for the incoming HTTP request.</param>
        /// <param name="statusCode">The HTTP Status Code that must be returned to the client.</param>
        /// <returns>The response that must be sent to the client.</returns>
        public override string ProcessRequest(HttpContext context, out HttpStatusCode statusCode)
        {
            if (!AtomPubHelper.ValidatePrecondition(context, base.BaseUri, out statusCode))
            {
                if (HttpStatusCode.PreconditionFailed == statusCode)
                {
                    return(Properties.Resources.ATOMPUB_PRECONDITION_FAILED);
                }
                else
                {
                    return(Properties.Resources.ATOMPUB_RESOURCE_NOT_MODIFIED);
                }
            }

            string errorMessage = string.Empty;
            // used to hold updated member metadata.
            AtomEntryDocument  atomDocument = null;
            AtomPubRequestType requestType  = AtomPubHelper.GetAtomPubRequestType(context, base.BaseUri);

            try
            {
                switch (requestType)
                {
                case AtomPubRequestType.EditMember:
                    atomDocument = UpdateMember(context);
                    break;

                case AtomPubRequestType.EditMedia:
                    atomDocument = UpdateMedia(context);
                    break;

                case AtomPubRequestType.ServiceDocument:
                case AtomPubRequestType.Collection:
                case AtomPubRequestType.CollectionWithPageNo:
                case AtomPubRequestType.Unknwon:
                default:
                    statusCode   = HttpStatusCode.BadRequest;
                    errorMessage = Resources.ATOMPUB_INVALID_URL;
                    break;
                }
            }
            catch (ResourceNotFoundException)
            {
                statusCode = HttpStatusCode.NotFound;
                return(Properties.Resources.ATOMPUB_RESOURCE_NOT_FOUND);
            }

            if (null != atomDocument)
            {
                statusCode = HttpStatusCode.OK;
                string memberId = AtomPubHelper.GetValueOfParameterFromUri(context, base.BaseUri, AtomPubParameterType.Id);
                string eTag     = AtomPubHelper.CalculateETag(memberId);
                context.Response.AddHeader(AtomPubConstants.KeyETag, eTag);
                return(atomDocument.AtomEntry);
            }
            else
            {
                return(errorMessage);
            }
        }
Example #3
0
        /// <summary>
        /// Updates the metadata for the specified resource.
        /// </summary>
        /// <param name="collectionName">Name of the target collection.</param>
        /// <param name="memberResourceId">The Id of the member resource.</param>
        /// <param name="atomEntry">Describes the resource to be modified.</param>
        /// <returns>A SyndicationItem that describes the updated resource.</returns>
        /// <exception cref="ArgumentNullException">Throws exception if collectionName is null/empty
        /// or atomEntry is null.</exception>
        /// <exception cref="ArgumentException">Throws exception if requested memberResourceId is not a unique identifier.</exception>
        SyndicationItem IAtomPubStoreWriter.UpdateMemberInfo(string collectionName, string memberResourceId, AtomEntryDocument atomEntry)
        {
            if (string.IsNullOrEmpty(collectionName))
            {
                throw new ArgumentNullException("collectionName");
            }

            if (string.IsNullOrEmpty(memberResourceId))
            {
                throw new ArgumentNullException("memberResourceId");
            }

            if (null == atomEntry)
            {
                throw new ArgumentNullException("atomEntry");
            }

            using (ZentityContext context = CoreHelper.CreateZentityContext())
            {
                ScholarlyWork resource = (ScholarlyWork)AtomPubHelper.GetMember(context, collectionName, memberResourceId, "Update");
                resource.Files.Load();

                // Bug Fix : 177689 - AtomPub (M2): Author node is appending after every PUT request instead of overwriting it.
                resource.Authors.Load();
                resource.Contributors.Load();

                UpdateResourceProperty(context, resource, atomEntry);
                context.SaveChanges();

                return(ZentityAtomPubStoreReader.GenerateSyndicationItem(this.BaseUri, resource));
            }
        }
        /// <summary>
        /// Gets the resource property.
        /// </summary>
        /// <param name="resource">The resource.</param>
        /// <param name="propertyName">Name of the property.</param>
        /// <returns>A <see cref="ResourceProperty"/>.</returns>
        internal static ResourceProperty GetResourceProperty(ScholarlyWork resource, string propertyName)
        {
            if (!resource.ResourceProperties.IsLoaded)
            {
                try
                {
                    resource.ResourceProperties.Load();

                    foreach (ResourceProperty resourceProperties in resource.ResourceProperties)
                    {
                        if (!resourceProperties.PropertyReference.IsLoaded)
                        {
                            resourceProperties.PropertyReference.Load();
                        }
                    }
                }
                catch (InvalidOperationException)
                {
                    // Do nothing if resource is not attached to the context.
                }
            }
            string propertyUri = AtomPubHelper.GetPropertyUri(propertyName);

            return(resource.ResourceProperties
                   .Where(tuple => tuple.Property.Uri == propertyUri)
                   .FirstOrDefault());
        }
 /// <summary>
 /// Gets the specified resource.
 /// </summary>
 /// <param name="collectionName">The name of the resource type.</param>
 /// <param name="memberResourceId">The Guid of the resource to return.</param>
 /// <returns>A SyndicationItem for the specified resource.</returns>
 /// <exception cref="ArgumentNullException">Throws exception if collectionName is null/empty.</exception>
 SyndicationItem IAtomPubStoreReader.GetMember(string collectionName, string memberResourceId)
 {
     using (ZentityContext context = CoreHelper.CreateZentityContext())
     {
         ScholarlyWork resource = (ScholarlyWork)AtomPubHelper.GetMember(context, collectionName, memberResourceId, "Read");
         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);
            }
        }
Example #7
0
        /// <summary>
        /// Updates the Resource.File of the specified resource.
        /// </summary>
        /// <param name="collectionName">The type of the resource.</param>
        /// <param name="memberResourceId">The resource whose File needs to be updated.</param>
        /// <param name="mimeType">The MIME type of media.</param>
        /// <param name="media">The new File contents.</param>
        /// <returns>A SyndicationItem that describes the updated resource.</returns>
        /// <exception cref="ArgumentNullException">Throws exception if collectionName is null/empty
        /// or media is null.</exception>
        /// <exception cref="ArgumentException">Throws exception if requested memberResourceId is not a unique identifier.</exception>
        SyndicationItem IAtomPubStoreWriter.UpdateMedia(string collectionName, string memberResourceId, string mimeType, byte[] media)
        {
            if (string.IsNullOrEmpty(collectionName))
            {
                throw new ArgumentNullException("collectionName");
            }

            if (null == media)
            {
                throw new ArgumentNullException("media");
            }

            if (string.IsNullOrEmpty(memberResourceId))
            {
                throw new ArgumentNullException("memberResourceId");
            }

            if (!AtomPubHelper.IsValidGuid(memberResourceId))
            {
                throw new ArgumentException(Resources.ATOMPUB_INVALID_RESOURCE_ID, "memberResourceId");
            }

            using (ZentityContext context = CoreHelper.CreateZentityContext())
            {
                Type collectionType = CoreHelper.GetSystemResourceType(collectionName);
                // Prepare a query to get a resource with specified Id and specified type.
                string commandText = string.Format(CultureInfo.InvariantCulture, AtomPubConstants.EsqlToGetFileContents,
                                                   collectionType.FullName);

                ObjectQuery <Core.File> query = new ObjectQuery <Core.File>(commandText, context);
                query.Parameters.Add(new ObjectParameter("Id", new Guid(memberResourceId)));
                Core.File mediaResource = query.FirstOrDefault();

                if (null == mediaResource)
                {
                    throw new ResourceNotFoundException(Resources.ATOMPUB_RESOURCE_NOT_FOUND);
                }

                if (!mediaResource.Authorize("Update", context, CoreHelper.GetAuthenticationToken()))
                {
                    throw new UnauthorizedException(Resources.ATOMPUB_UNAUTHORIZED);
                }

                mediaResource.Resources.Load();
                ScholarlyWork resource = (ScholarlyWork)mediaResource.Resources.First();
                resource.DateModified       = DateTime.Now;
                mediaResource.MimeType      = mimeType;
                mediaResource.FileExtension = AtomPubHelper.GetFileExtension(mimeType);

                MemoryStream mediaStream = ZentityAtomPubStoreWriter.GetMediaStream(media);
                context.UploadFileContent(mediaResource, mediaStream);

                // Bug Fix : 180811 - Save Changes once mime type and contents are set.
                context.SaveChanges();

                return(ZentityAtomPubStoreReader.GenerateSyndicationItem(this.BaseUri, resource));
            }
        }
        /// <summary>
        /// Deletes a media resource using the information present in the HttpContext.
        /// </summary>
        /// <param name="context">The HttpContext for the incoming HTTP request.</param>
        /// <returns>True if the operation succeeds, False otherwise.</returns>
        private bool DeleteMedia(HttpContext context)
        {
            // Gets the atom request template match result to get requested collection name.
            string collectionName = AtomPubHelper.GetValueOfParameterFromUri(context, base.BaseUri, AtomPubParameterType.CollectionName);
            string memberId       = AtomPubHelper.GetValueOfParameterFromUri(context, base.BaseUri, AtomPubParameterType.Id);

            IAtomPubStoreWriter atomPubStoreWriter = AtomPubStoreFactory.GetAtomPubStoreWriter(base.BaseUri.OriginalString);

            return(atomPubStoreWriter.DeleteMedia(collectionName, memberId));
        }
        /// <summary>
        /// Gets a media contents of a member resource.
        /// </summary>
        /// <param name="collectionName">Name of the target collection.</param>
        /// <param name="memberResourceId">The Id of the member resource.</param>
        /// <param name="outputStream">A stream containing the media corresponding to the specified resource. If no matching media is found, null is returned.</param>
        /// <exception cref="ArgumentNullException">Throws exception if memberResourceId is null/empty
        /// or outputStream is null.</exception>
        /// <exception cref="ArgumentException">Throws exception if outputStream stream is not readable.</exception>
        void IAtomPubStoreReader.GetMedia(string collectionName, string memberResourceId, Stream outputStream)
        {
            if (string.IsNullOrEmpty(collectionName))
            {
                throw new ArgumentNullException("collectionName");
            }

            if (string.IsNullOrEmpty(memberResourceId))
            {
                throw new ArgumentNullException("memberResourceId");
            }

            if (null == outputStream)
            {
                throw new ArgumentNullException("outputStream");
            }

            if (!AtomPubHelper.IsValidGuid(memberResourceId))
            {
                throw new ArgumentException(Resources.ATOMPUB_INVALID_RESOURCE_ID);
            }

            if (!outputStream.CanWrite)
            {
                throw new ArgumentException(Properties.Resources.ATOMPUB_CANNOT_WRITE_ON_STREAM, "outputStream");
            }

            using (ZentityContext context = CoreHelper.CreateZentityContext())
            {
                ResourceType collectionType = coreHelper.GetResourceType(collectionName);

                // Prepare a query to get a resource with specified Id and specified type.
                string commandText = string.Format(CultureInfo.InvariantCulture, AtomPubConstants.EsqlToGetFileContents,
                                                   collectionType.FullName);

                ObjectQuery <Core.File> query = new ObjectQuery <Core.File>(commandText, context);
                query.Parameters.Add(new ObjectParameter("Id", new Guid(memberResourceId)));
                Core.File mediaFile = query.FirstOrDefault();

                if (null == mediaFile)
                {
                    throw new ResourceNotFoundException(Resources.ATOMPUB_RESOURCE_NOT_FOUND);
                }

                if (!mediaFile.Authorize("Read", context, CoreHelper.GetAuthenticationToken()))
                {
                    throw new UnauthorizedException(Resources.ATOMPUB_UNAUTHORIZED);
                }

                context.DownloadFileContent(mediaFile, outputStream);
            }
        }
Example #10
0
        /// <summary>
        /// Creates a member resource using the information present in the HttpContext.
        /// </summary>
        /// <param name="context">The HttpContext for the incoming HTTP request.</param>
        /// <returns>An AtomEntryDocument corresponding to the newly created member resource.</returns>
        private AtomEntryDocument CreateMember(HttpContext context)
        {
            string collectionName = AtomPubHelper.GetValueOfParameterFromUri(context, base.BaseUri,
                                                                             AtomPubParameterType.CollectionName);

            //Get AtomEntryDocument for request to update the member information.
            AtomEntryDocument atomEntry = new AtomEntryDocument(context.Request.InputStream);

            IAtomPubStoreWriter atomPubStoreWriter = AtomPubStoreFactory.GetAtomPubStoreWriter(base.BaseUri.OriginalString);
            SyndicationItem     item = atomPubStoreWriter.CreateMember(collectionName, atomEntry);

            // Create atom entry document from syndication item.
            return(new AtomEntryDocument(item));
        }
Example #11
0
        /// <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));
            }
        }
Example #12
0
        /// <summary>
        /// Updates a member resource using the information present in the HttpContext.
        /// </summary>
        /// <param name="context">The HttpContext for the incoming HTTP request.</param>
        /// <returns>An AtomEntryDocument corresponding to the updated member resource.</returns>
        private AtomEntryDocument UpdateMember(HttpContext context)
        {
            // Gets the atom request template match result to get requested collection name.
            string collectionName = AtomPubHelper.GetValueOfParameterFromUri(context, base.BaseUri, AtomPubParameterType.CollectionName);
            string memberId       = AtomPubHelper.GetValueOfParameterFromUri(context, base.BaseUri, AtomPubParameterType.Id);

            IAtomPubStoreWriter atomPubStoreWriter = AtomPubStoreFactory.GetAtomPubStoreWriter(base.BaseUri.OriginalString);

            //Get AtomEntryDocument for request to update the member information.
            AtomEntryDocument atomDocument = new AtomEntryDocument(context.Request.InputStream);

            SyndicationItem item = atomPubStoreWriter.UpdateMemberInfo(collectionName, memberId, atomDocument);

            // Get AtomEntryDocument for response.
            return(new AtomEntryDocument(item));
        }
Example #13
0
        /// <summary>
        /// Gets the property.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="propertyName">Name of the property.</param>
        /// <returns>A <see cref="Property"/> type.</returns>
        private static Property GetProperty(ZentityContext context, string propertyName)
        {
            string   propertyUri = AtomPubHelper.GetPropertyUri(propertyName);
            Property property    = context.Properties.FirstOrDefault(prp => prp.Uri == propertyUri);

            if (null == property)
            {
                property = new Property
                {
                    Name = propertyName,
                    Uri  = propertyUri
                };
            }

            return(property);
        }
Example #14
0
        /// <summary>
        /// Add Core.Person items to Navigation property of a resource.
        /// </summary>
        /// <param name="context">ZentityContext to search a person in database</param>
        /// <param name="contacts">Navigation property of resource to add persons</param>
        /// <param name="authors">List of persons to add to navigation property.</param>
        protected static void AddPersons(ZentityContext context, EntityCollection <Contact> contacts, IEnumerable <Person> authors)
        {
            foreach (Person author in authors)
            {
                if (!string.IsNullOrEmpty(author.Title))
                {
                    Match nameMatch = Regex.Match(author.Title, AtomPubConstants.PersonNamePattern, RegexOptions.IgnoreCase);
                    author.FirstName  = nameMatch.Groups[AtomPubConstants.FirstName].Value;
                    author.MiddleName = nameMatch.Groups[AtomPubConstants.MiddleName].Value;
                    author.LastName   = nameMatch.Groups[AtomPubConstants.LastName].Value;
                }

                System.Linq.Expressions.Expression filter = null;
                ParameterExpression param = System.Linq.Expressions.Expression.Parameter(typeof(Person), "person");

                if (!string.IsNullOrEmpty(author.Uri))
                {
                    AtomPubHelper.GeneratePersonFilterExpression("Uri", author.Uri, param, ref filter);
                }
                else if (!string.IsNullOrEmpty(author.Email))
                {
                    AtomPubHelper.GeneratePersonFilterExpression("Email", author.Email, param, ref filter);
                }
                else
                {
                    AtomPubHelper.GeneratePersonFilterExpression(AtomPubConstants.FirstName, author.FirstName, param, ref filter);
                    AtomPubHelper.GeneratePersonFilterExpression(AtomPubConstants.MiddleName, author.MiddleName, param, ref filter);
                    AtomPubHelper.GeneratePersonFilterExpression(AtomPubConstants.LastName, author.LastName, param, ref filter);
                }

                if (null == filter)
                {
                    continue;
                }

                Expression <Func <Person, bool> > predicate = System.Linq.Expressions.Expression.Lambda(filter, param) as Expression <Func <Person, bool> >;

                Person contact = context.People().FirstOrDefault(predicate);

                if (null == contact)
                {
                    contact = author;
                }

                contacts.Add(contact);
            }
        }
        /// <summary>
        /// Processes the request.
        /// </summary>
        /// <param name="context">The HttpContext for the incoming HTTP request.</param>
        /// <param name="statusCode">The HTTP Status Code that must be returned to the client.</param>
        /// <returns>The response that must be sent to the client.</returns>
        public override string ProcessRequest(HttpContext context, out System.Net.HttpStatusCode statusCode)
        {
            string             response = string.Empty;
            bool               isDeleted;
            AtomPubRequestType requestType = AtomPubHelper.GetAtomPubRequestType(context, base.BaseUri);

            try
            {
                switch (requestType)
                {
                case AtomPubRequestType.EditMember:
                    isDeleted = DeleteMember(context);
                    break;

                case AtomPubRequestType.EditMedia:
                    isDeleted = DeleteMedia(context);
                    break;

                case AtomPubRequestType.ServiceDocument:
                case AtomPubRequestType.Collection:
                case AtomPubRequestType.CollectionWithPageNo:
                case AtomPubRequestType.Unknwon:
                default:
                    isDeleted = false;
                    response  = Resources.ATOMPUB_INVALID_URL;
                    break;
                }
            }
            catch (ResourceNotFoundException)
            {
                statusCode = HttpStatusCode.NotFound;
                return(Properties.Resources.ATOMPUB_RESOURCE_NOT_FOUND);
            }

            if (isDeleted)
            {
                statusCode = HttpStatusCode.OK;
            }
            else
            {
                statusCode = HttpStatusCode.BadRequest;
            }

            return(response);
        }
Example #16
0
        /// <summary>
        /// Handles the POST request send to the collection Uri. The method assumes that the request is
        /// already validated using ValidateRequest method.
        /// </summary>
        /// <param name="context">HttpContext containing the request object.</param>
        /// <param name="statusCode">returns the status of the request.</param>
        /// <returns>A string containing the response for the specified AtomPub request.</returns>
        public override string ProcessRequest(HttpContext context, out System.Net.HttpStatusCode statusCode)
        {
            string response = string.Empty;

            AtomEntryDocument atomEntryDocument = null;
            bool isAtomEntryType = AtomPubHelper.IsAtomEntryMediaType(context.Request.ContentType);

            if (isAtomEntryType)
            {
                // If request stream contains AtomEntryDocument, then client wants to create new Member.
                atomEntryDocument = this.CreateMember(context);
            }
            else
            {
                // If request stream contains something other than AtomEntryDocument,
                // then client wants to create new member with Media.
                atomEntryDocument = this.CreateMedia(context);
            }

            // Add Location Header
            SyndicationLink editLink = atomEntryDocument.Links
                                       .Where(link => link.RelationshipType == AtomPubConstants.Edit)
                                       .FirstOrDefault();

            if (null != editLink)
            {
                context.Response.AddHeader(AtomPubConstants.KeyLocation, editLink.Uri.AbsoluteUri);
            }

            // Add ETag header
            string[] memberIds = atomEntryDocument.Id.Split(new string[] { AtomPubConstants.IdPrefix },
                                                            StringSplitOptions.RemoveEmptyEntries);
            if (0 < memberIds.Length)
            {
                string eTag = AtomPubHelper.CalculateETag(memberIds[0]);

                context.Response.AddHeader(AtomPubConstants.KeyETag, eTag);
            }

            response   = atomEntryDocument.AtomEntry;
            statusCode = HttpStatusCode.Created;

            return(response);
        }
Example #17
0
        /// <summary>
        /// Validates the incoming request.
        /// </summary>
        /// <param name="context">The HttpContext for the incoming HTTP request.</param>
        /// <param name="errorMessage">The HTTP Status Code if the request is invalid.</param>
        /// <returns>True if the request is valid, False otherwise.</returns>
        public override bool ValidateRequest(HttpContext context, out string errorMessage)
        {
            // Verify that type of request is edit member or edit media request.
            AtomPubRequestType requestType = AtomPubHelper.GetAtomPubRequestType(context, base.BaseUri);

            if (!(AtomPubRequestType.EditMember == requestType || AtomPubRequestType.EditMedia == requestType))
            {
                errorMessage = Resources.ATOMPUB_INVALID_URL;
                return(false);
            }

            bool isAtomEntryType = AtomPubHelper.IsAtomEntryMediaType(context.Request.ContentType);

            if (requestType == AtomPubRequestType.EditMember && !isAtomEntryType)
            {
                errorMessage = Resources.ATOMPUB_UNSUPPORTED_CONTENT_TYPE;
                return(false);
            }

            // Get the requested member type and its id for verifying it existents.
            string collectionName = AtomPubHelper.GetValueOfParameterFromUri(context, base.BaseUri, AtomPubParameterType.CollectionName);

            if (!string.IsNullOrEmpty(collectionName) &&
                AtomPubHelper.IsValidCollectionType(collectionName))
            {
                string memberId = AtomPubHelper.GetValueOfParameterFromUri(context, base.BaseUri, AtomPubParameterType.Id);

                if (!string.IsNullOrEmpty(memberId) && AtomPubHelper.IsValidGuid(memberId))
                {
                    errorMessage = string.Empty;
                    return(true);
                }
                else
                {
                    errorMessage = Resources.ATOMPUB_INVALID_RESOURCE_ID;
                    return(false);
                }
            }
            else
            {
                errorMessage = Resources.ATOMPUB_UNSUPPORTED_COLLECTION_NAME;
                return(false);
            }
        }
Example #18
0
        /// <summary>
        /// Updates a media resource using the information present in the HttpContext.
        /// </summary>
        /// <param name="context">The HttpContext for the incoming HTTP request.</param>
        /// <returns>An AtomEntryDocument corresponding to the updated media resource.</returns>
        private AtomEntryDocument UpdateMedia(HttpContext context)
        {
            // Gets the atom request template match result to get requested collection name.
            string collectionName = AtomPubHelper.GetValueOfParameterFromUri(context, base.BaseUri, AtomPubParameterType.CollectionName);
            string memberId       = AtomPubHelper.GetValueOfParameterFromUri(context, base.BaseUri, AtomPubParameterType.Id);

            IAtomPubStoreWriter atomPubStoreWriter = AtomPubStoreFactory.GetAtomPubStoreWriter(base.BaseUri.OriginalString);

            // Get byte array to update media.
            BinaryReader reader = new BinaryReader(context.Request.InputStream);

            byte[] media = new byte[context.Request.InputStream.Length];
            reader.Read(media, 0, media.Length);

            SyndicationItem item = atomPubStoreWriter.UpdateMedia(collectionName, memberId, context.Request.ContentType, media);

            // Get AtomEntryDocument for response.
            return(new AtomEntryDocument(item));
        }
        /// <summary>
        /// Gets the resource properties.
        /// </summary>
        /// <param name="resource">The resource.</param>
        /// <param name="propertyName">Name of the property.</param>
        /// <returns>List of <see cref="ResourceProperty"/>.</returns>
        internal static List <ResourceProperty> GetResourceProperties(ScholarlyWork resource, string propertyName)
        {
            if (!resource.ResourceProperties.IsLoaded)
            {
                try
                {
                    resource.ResourceProperties.Load();
                }
                catch (InvalidOperationException)
                {
                    // Do nothing if resource is not attached to the context.
                }
            }
            string propertyUri = AtomPubHelper.GetPropertyUri(propertyName);

            return(resource.ResourceProperties
                   .Where(tuple => tuple.Property.Uri == propertyUri)
                   .ToList());
        }
Example #20
0
        /// <summary>
        /// Validates the specified Sword request.
        /// </summary>
        /// <param name="context">An instance of HttpContext containing the request details.</param>
        /// <param name="errorMessage">An error message describing the reason if validation is failed.</param>
        /// <returns>True if the request is valid, otherwise false.</returns>
        public bool ValidateRequest(HttpContext context, out string errorMessage)
        {
            string httpRequestType = context.Request.RequestType.ToUpperInvariant();

            // Verify request type is GET, PUT, POST, DELETE
            if (!(PlatformConstants.GetRequestType == httpRequestType ||
                  PlatformConstants.PutRequestType == httpRequestType ||
                  PlatformConstants.PostRequestType == httpRequestType ||
                  PlatformConstants.DeleteRequestType == httpRequestType))
            {
                errorMessage = Resources.ATOMPUB_INVALID_METHOD;
                return(false);
            }

            Uri baseUri = new Uri(SwordHelper.GetBaseUri());
            AtomPubRequestType requestType = AtomPubHelper.GetAtomPubRequestType(context, baseUri);
            bool isValidRequest            = AtomPubRequestType.Unknwon != requestType;

            errorMessage = (isValidRequest) ? string.Empty : Resources.ATOMPUB_BAD_REQUEST;
            return(isValidRequest);
        }
Example #21
0
        /// <summary>
        /// Gets the member.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="collectionName">Name of the collection.</param>
        /// <param name="memberResourceId">The member resource id.</param>
        /// <returns>The <see cref="Resource"/>.</returns>
        internal static Resource GetMember(ZentityContext context, string collectionName, string memberResourceId)
        {
            if (string.IsNullOrEmpty(collectionName))
            {
                throw new ArgumentNullException("collectionName");
            }

            if (string.IsNullOrEmpty(memberResourceId))
            {
                throw new ArgumentNullException("memberResourceId");
            }

            if (!AtomPubHelper.IsValidGuid(memberResourceId))
            {
                throw new ArgumentException(Resources.ATOMPUB_INVALID_RESOURCE_ID, "memberResourceId");
            }

            Type collectionType = CoreHelper.GetSystemResourceType(collectionName);

            if (collectionType == null)
            {
                throw new ResourceNotFoundException(Resources.ATOMPUB_RESOURCE_NOT_FOUND);
            }

            string commandText = string.Format(CultureInfo.InvariantCulture, AtomPubConstants.EsqlToGetResourceById,
                                               collectionType.FullName);

            ObjectQuery <ScholarlyWork> resourceQuery = new ObjectQuery <ScholarlyWork>(commandText, context);

            resourceQuery.Parameters.Add(new ObjectParameter("Id", new Guid(memberResourceId)));

            Resource resource = resourceQuery.FirstOrDefault();

            if (resource == null)
            {
                throw new ResourceNotFoundException(Resources.ATOMPUB_RESOURCE_NOT_FOUND);
            }

            return(resource);
        }
Example #22
0
        /// <summary>
        /// Deletes the Resource.File for the specified resource.
        /// </summary>
        /// <param name="collectionName">The type of the resource.</param>
        /// <param name="memberResourceId">The Guid of the resource.</param>
        /// <returns>True if the operation succeeds, False otherwise.</returns>
        /// <exception cref="ArgumentNullException">Throws exception if collectionName is null/empty.</exception>
        /// <exception cref="ArgumentException">Throws exception if requested memberResourceId is not a unique identifier.</exception>
        bool IAtomPubStoreWriter.DeleteMedia(string collectionName, string memberResourceId)
        {
            if (string.IsNullOrEmpty(collectionName))
            {
                throw new ArgumentNullException("collectionName");
            }

            if (!AtomPubHelper.IsValidGuid(memberResourceId))
            {
                throw new ArgumentException(Resources.ATOMPUB_INVALID_RESOURCE_ID, "memberResourceId");
            }

            using (ZentityContext context = CoreHelper.CreateZentityContext())
            {
                Type   collectionType = CoreHelper.GetSystemResourceType(collectionName);
                string commandText    = string.Format(CultureInfo.InvariantCulture, AtomPubConstants.EsqlToGetFileContents,
                                                      collectionType.FullName);

                ObjectQuery <Core.File> query = new ObjectQuery <Core.File>(commandText, context);
                query.Parameters.Add(new ObjectParameter("Id", new Guid(memberResourceId)));

                Core.File mediaFile = query.FirstOrDefault();

                if (null == mediaFile)
                {
                    throw new ResourceNotFoundException(Resources.ATOMPUB_RESOURCE_NOT_FOUND);
                }

                if (!mediaFile.Authorize("Delete", context, CoreHelper.GetAuthenticationToken()))
                {
                    throw new UnauthorizedException(Resources.ATOMPUB_UNAUTHORIZED);
                }

                DeleteRelationships(context, mediaFile);
                context.DeleteObject(mediaFile);
                context.SaveChanges();
                return(true);
            }
        }
        /// <summary>
        /// Create resource using metadata.
        /// </summary>
        /// <param name="dataSection">Metadata Section containing metadata of the resource.</param>
        /// <returns>A resource of type ScholarlyWork or its derived type.</returns>
        private static ScholarlyWork CreateResouceUsingMetsMetadata(MetadataSection dataSection)
        {
            if (null == dataSection)
            {
                throw new ArgumentNullException("dataSection");
            }

            ScholarlyWork resource     = null;
            Type          resourceType = null;

            // Get the resource type specified in METS document.
            if (null != dataSection.DescriptiveMetadata && null != dataSection.DescriptiveMetadata.ResourceType &&
                0 < dataSection.DescriptiveMetadata.ResourceType.Count)
            {
                string resourceTypeName = dataSection.DescriptiveMetadata.ResourceType[0];

                // Check if the resource type is derived from ScholarlyWork,
                // as Sword & AtomPub supports only ScholarlyWork and its derivatives.
                if (AtomPubHelper.IsValidCollectionType(resourceTypeName))
                {
                    resourceType = CoreHelper.GetSystemResourceType(resourceTypeName);
                }
            }

            // Take ScholarlyWork as default resource type.
            if (null == resourceType)
            {
                resourceType = typeof(ScholarlyWork);
            }

            // Create resource of type ScholarlyWork or its derived types.
            resource = Activator.CreateInstance(resourceType, false) as ScholarlyWork;
            if (null == resource)
            {
                throw new SwordException(Properties.Resources.UNSUPPORTED_RESOURCE_TYPE);
            }

            return(resource);
        }
Example #24
0
        /// <summary>
        /// Creates a media resource using the information present in the HttpContext.
        /// </summary>
        /// <param name="context">The HttpContext for the incoming HTTP request.</param>
        /// <returns>An AtomEntryDocument corresponding to the newly created media resource.</returns>
        private AtomEntryDocument CreateMedia(HttpContext context)
        {
            SyndicationItem item = null;

            string collectionName = AtomPubHelper.GetValueOfParameterFromUri(context,
                                                                             base.BaseUri,
                                                                             AtomPubParameterType.CollectionName);

            // Get byte array to update media.
            BinaryReader reader = new BinaryReader(context.Request.InputStream);

            byte[] media = new byte[context.Request.InputStream.Length];
            reader.Read(media, 0, media.Length);

            string fileExtention = string.Empty;

            if (context.Request.Headers.AllKeys.Contains("Content-Disposition"))
            {
                fileExtention = AtomPubHelper.GetFileExtentionFromContentDisposition(
                    context.Request.Headers["Content-Disposition"]);
            }

            IAtomPubStoreWriter swordStoreWriter = AtomPubStoreFactory.GetSwordStoreWriter();

            item = swordStoreWriter.CreateMedia(collectionName, context.Request.ContentType, media, fileExtention);

            AtomEntryDocument atomEntryDocument = null;

            if (null != item)
            {
                // Add <sword:treatment>Successfully created a {Collection Name}</sword:treatment> element.
                SwordPostProcessor.AddTreatmentElement(collectionName, item);

                // Create atom entry document from syndication item.
                atomEntryDocument = new AtomEntryDocument(item);
            }

            return(atomEntryDocument);
        }
Example #25
0
        /// <summary>
        /// Validates the request uri and returns the appropriate error message.
        /// If the request is valid, 'error' with empty string is returned.
        /// </summary>
        /// <param name="context">HttpContext containing the request object.</param>
        /// <param name="errorMessage">Contains the error message.</param>
        /// <returns>True if the request is valid, else false.</returns>
        public override bool ValidateRequest(HttpContext context, out string errorMessage)
        {
            bool isValid = false;

            AtomPubRequestType requestType = AtomPubHelper.GetAtomPubRequestType(context, base.BaseUri);

            switch (requestType)
            {
            case AtomPubRequestType.Collection:

                // Get collection name
                string collectionName = AtomPubHelper.GetValueOfParameterFromUri(context, base.BaseUri,
                                                                                 AtomPubParameterType.CollectionName);

                // If valid collection name, then proceed.
                if (!string.IsNullOrEmpty(collectionName) &&
                    AtomPubHelper.IsValidCollectionType(collectionName))
                {
                    errorMessage = string.Empty;
                    isValid      = true;
                }
                else
                {
                    errorMessage = Properties.Resources.ATOMPUB_UNSUPPORTED_COLLECTION_NAME;
                    isValid      = false;
                }

                break;

            case AtomPubRequestType.Unknwon:
            default:
                errorMessage = Properties.Resources.ATOMPUB_INVALID_URL;
                isValid      = false;
                break;
            }

            return(isValid);
        }
Example #26
0
        /// <summary>
        /// Gets the value of specified parameter from the request Uri.
        /// </summary>
        /// <param name="context">HttpContext containing the request uri.</param>
        /// <param name="baseUri">Base Uri for the specified request.</param>
        /// <param name="parameterName"><typeref name="AtomPubParameterType"/> name of the parameter whose value is to be retrieved.</param>
        /// <returns>String containing value for the specified parameter.</returns>
        internal static string GetValueOfParameterFromUri(HttpContext context, Uri baseUri, AtomPubParameterType parameterName)
        {
            UriTemplateMatch matchResult = AtomPubHelper.GetTemplateMatchFromUri(baseUri, context.Request.Url);

            if (null == matchResult)
            {
                return(string.Empty);
            }

            string paramName  = parameterName.ToString();
            string paramValue = string.Empty;

            foreach (string paramKey in matchResult.BoundVariables.Keys)
            {
                if (paramKey.Equals(paramName, StringComparison.OrdinalIgnoreCase))
                {
                    paramValue = matchResult.BoundVariables[paramKey];
                    break;
                }
            }

            return(paramValue);
        }
        /// <summary>
        /// Gets all the resource types that inherit from ScholarlyWork, including ScholarlyWork.
        /// </summary>
        /// <returns>An array of strings containing the resource type names.</returns>
        string[] IAtomPubStoreReader.GetCollectionNames()
        {
            List <string> resourceTypes = new List <string>();

            using (ZentityContext zentityContext = CoreHelper.CreateZentityContext())
            {
                resourceTypes = new List <string>();

                // Get all resource types which are derived from ScholarlyWork as
                // only ScholarlyWork type supports authors list.
                foreach (ResourceType typeInfo in CoreHelper.GetResourceTypes(zentityContext))
                {
                    if (AtomPubHelper.IsValidCollectionType(typeInfo.Name))
                    {
                        resourceTypes.Add(typeInfo.Name);
                    }
                }
            }

            return(resourceTypes
                   .OrderBy(name => name)
                   .ToArray());
        }
Example #28
0
        /// <summary>
        /// Deletes the specified resource.
        /// </summary>
        /// <param name="collectionName">The type of the resource.</param>
        /// <param name="memberResourceId">The Guid of the resource.</param>
        /// <returns>True if the operation succeeds, False otherwise.</returns>
        /// <exception cref="ArgumentNullException">Throws exception if collectionName is null/empty.</exception>
        /// <exception cref="ArgumentException">Throws exception if requested memberResourceId is not a unique identifier.</exception>
        bool IAtomPubStoreWriter.DeleteMember(string collectionName, string memberResourceId)
        {
            using (ZentityContext context = CoreHelper.CreateZentityContext())
            {
                ScholarlyWork resource = (ScholarlyWork)AtomPubHelper.GetMember(context, collectionName, memberResourceId, "Delete");

                // Load to delete all Core.File resource associated to requested scholarlywork.
                if (!resource.Files.IsLoaded)
                {
                    resource.Files.Load();
                }

                Zentity.Core.File[] resourceFiles = resource.Files.ToArray();

                for (int i = 0; i < resourceFiles.Length; i++)
                {
                    DeleteRelationships(context, resourceFiles[i]);
                    context.DeleteObject(resourceFiles[i]);
                }

                DeleteRelationships(context, resource);

                // Delete associated Resource propertes
                resource.ResourceProperties.Load();
                List <ResourceProperty> resProperties = resource.ResourceProperties.ToList();
                foreach (ResourceProperty property in resProperties)
                {
                    resource.ResourceProperties.Remove(property);
                    context.DeleteObject(property);
                }

                context.DeleteObject(resource);
                context.SaveChanges();
                return(true);
            }
        }
Example #29
0
        /// <summary>
        /// Creates a media resource using the information present in the HttpContext.
        /// </summary>
        /// <param name="context">The HttpContext for the incoming HTTP request.</param>
        /// <returns>An AtomEntryDocument corresponding to the newly created media resource.</returns>
        private AtomEntryDocument CreateMedia(HttpContext context)
        {
            string collectionName = AtomPubHelper.GetValueOfParameterFromUri(context, base.BaseUri,
                                                                             AtomPubParameterType.CollectionName);

            string fileExtention = string.Empty;

            if (context.Request.Headers.AllKeys.Contains("Content-Disposition"))
            {
                fileExtention = AtomPubHelper.GetFileExtentionFromContentDisposition(
                    context.Request.Headers["Content-Disposition"]);
            }
            // Get byte array to update media.
            BinaryReader reader = new BinaryReader(context.Request.InputStream);

            byte[] media = new byte[context.Request.InputStream.Length];
            reader.Read(media, 0, media.Length);

            IAtomPubStoreWriter atomPubStoreWriter = AtomPubStoreFactory.GetAtomPubStoreWriter(base.BaseUri.OriginalString);
            SyndicationItem     item = atomPubStoreWriter.CreateMedia(collectionName, context.Request.ContentType, media, fileExtention);

            // Create atom entry document from syndication item.
            return(new AtomEntryDocument(item));
        }
Example #30
0
        /// <summary>
        /// Validates the request uri and returns the appropriate error message.
        /// If the request is valid, 'error' with empty string is returned.
        /// Following requests are considered as valid :
        /// 1. Service Document Uri
        /// 2. Collection Uri
        /// 3. Collection Uri for next / previous page
        /// 4. Member resource Uri
        /// 5. Media Entry resource Uri
        /// </summary>
        /// <param name="context">HttpContext containing the request object.</param>
        /// <param name="errorMessage">Contains the error message.</param>
        /// <returns>True if the request is valid, else false.</returns>
        public override bool ValidateRequest(HttpContext context, out string errorMessage)
        {
            errorMessage = string.Empty;
            AtomPubRequestType requestType = AtomPubHelper.GetAtomPubRequestType(context, base.BaseUri);

            if (AtomPubRequestType.Unknwon == requestType)
            {
                errorMessage = Resources.ATOMPUB_INVALID_URL;
                return(false);
            }

            // If ServiceDocument uri then no need of further validations.
            if (AtomPubRequestType.ServiceDocument == requestType)
            {
                return(true);
            }

            // Get collection name
            string collectionName = AtomPubHelper.GetValueOfParameterFromUri(context, base.BaseUri,
                                                                             AtomPubParameterType.CollectionName);

            bool isValid = false;

            // If valid collection name, then proceed.
            if (!string.IsNullOrEmpty(collectionName) &&
                AtomPubHelper.IsValidCollectionType(collectionName))
            {
                switch (requestType)
                {
                case AtomPubRequestType.Collection:
                    isValid = true;
                    break;

                case AtomPubRequestType.CollectionWithPageNo:
                    string strPageNo = AtomPubHelper.GetValueOfParameterFromUri(context, base.BaseUri,
                                                                                AtomPubParameterType.PageNo);
                    long pageNumber = 0;

                    if (!long.TryParse(strPageNo, out pageNumber))
                    {
                        errorMessage = Resources.ATOMPUB_INVALID_PAGE_NUMBER;
                    }
                    else
                    {
                        isValid = true;
                    }

                    break;

                case AtomPubRequestType.EditMember:
                case AtomPubRequestType.EditMedia:
                    // Get the requested id for verify it is GUID
                    string memberId = AtomPubHelper.GetValueOfParameterFromUri(context, base.BaseUri,
                                                                               AtomPubParameterType.Id);
                    if (AtomPubHelper.IsValidGuid(memberId))
                    {
                        isValid = true;
                    }
                    else
                    {
                        errorMessage = Resources.ATOMPUB_INVALID_RESOURCE_ID;
                    }

                    break;

                default:
                    isValid      = false;
                    errorMessage = Resources.ATOMPUB_INVALID_URL;
                    break;
                }
            }
            else
            {
                errorMessage = Resources.ATOMPUB_UNSUPPORTED_COLLECTION_NAME;
            }

            return(isValid);
        }