Esempio n. 1
0
 /// <summary>
 /// Catches descriptive metadata id and administrative metadata id (Right section) for all files in the METS xml document.
 /// </summary>
 private void LoadFileMetadataPointer()
 {
     MetadataPointer = MetsElement.Descendants(this.MetsNamespace + MetsConstants.File)
                       .Where(fl => fl.Element(this.MetsNamespace + MetsConstants.Flocat) != null &&
                              fl.Element(this.MetsNamespace + MetsConstants.Flocat).Attribute(this.XlinkNamespace + MetsConstants.Href) != null)
                       .Select(fl => new FileMetadataPointer
     {
         Id        = fl.Attribute(MetsConstants.Id).Value,
         FileName  = fl.Element(this.MetsNamespace + MetsConstants.Flocat).Attribute(this.XlinkNamespace + MetsConstants.Href).Value,
         RightsIds = (null == fl.Attribute(MetsConstants.AdmId)) ? new string[] { } :
         fl.Attribute(MetsConstants.AdmId).Value.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries),
         DescriptiveIds = (null == fl.Attribute(MetsConstants.DmdId)) ? new string[] { } :
         fl.Attribute(MetsConstants.DmdId).Value.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)
     })
                       .ToArray();
 }
Esempio n. 2
0
        /// <summary>
        /// Get xmlData section for a file in METS xml.
        /// </summary>
        /// <param name="fileName">Name of file to get XML data sections.</param>
        /// <returns>Array of XML data section.</returns>
        private XmlMetadata[] GetXmlData(string fileName)
        {
            IEnumerable <FileMetadataPointer> filePointers = MetadataPointer.Where(flmdptr => flmdptr.FileName
                                                                                   .Equals(fileName, StringComparison.OrdinalIgnoreCase));

            if (0 == filePointers.Count())
            {
                return(null);
            }

            var descriptiveData = filePointers.SelectMany(file => file.DescriptiveIds)
                                  .Join(MetsElement.Descendants(this.MetsNamespace + MetsConstants.DmdSec),
                                        dmdId => dmdId,
                                        md => md.Attribute(MetsConstants.Id).Value,
                                        (dmdId, md) => new
            {
                MdWrap        = md.Descendants(this.MetsNamespace + MetsConstants.MdWrap).FirstOrDefault(),
                IsDiscriptive = true
            });

            var rightsData = filePointers.SelectMany(file => file.RightsIds)
                             .Join(MetsElement.Descendants(this.MetsNamespace + MetsConstants.RightsMD),
                                   admId => admId,
                                   md => md.Attribute(MetsConstants.Id).Value,
                                   (admId, md) => new
            {
                MdWrap        = md.Descendants(this.MetsNamespace + MetsConstants.MdWrap).FirstOrDefault(),
                IsDiscriptive = false
            });

            XmlMetadata[] fileMetadata = descriptiveData.Union(rightsData)
                                         .Where(wp => wp.MdWrap != null &&
                                                wp.MdWrap.Attribute(MetsConstants.MimeType) != null &&
                                                wp.MdWrap.Attribute(MetsConstants.MimeType).Value.Equals(
                                                    MetsConstants.TextXml, StringComparison.OrdinalIgnoreCase))
                                         .Select(wp => new XmlMetadata
            {
                Metadata = wp.MdWrap.Descendants(this.MetsNamespace + MetsConstants.XmlData)
                           .FirstOrDefault(),
                MdType        = wp.MdWrap.Attribute(MetsConstants.MdType).Value,
                IsDiscriptive = wp.IsDiscriptive
            })
                                         .ToArray();

            return(fileMetadata);
        }
Esempio n. 3
0
        /// <summary>
        /// Validate Dublin Core xml data against Dublin Core xml schema.
        /// </summary>
        private void ValidDublinCoreContent()
        {
            var dublinCoreElements = MetsElement.Descendants(this.MetsNamespace + MetsConstants.MdWrap)
                                     .Where(wrap => wrap.Attribute(MetsConstants.MimeType) != null &&
                                            wrap.Attribute(MetsConstants.MimeType).Value == MetsConstants.TextXml &&
                                            wrap.Attribute(MetsConstants.MdType).Value == MetsConstants.DublinCorePrefix)
                                     .Select(wrap => wrap.Element(this.MetsNamespace + MetsConstants.XmlData));

            foreach (XElement dublinCoreXml in dublinCoreElements)
            {
                XmlReaderSettings xmlRdSetting = new XmlReaderSettings();
                xmlRdSetting.ValidationType   = ValidationType.Schema;
                xmlRdSetting.ConformanceLevel = ConformanceLevel.Auto;
                xmlRdSetting.Schemas.Add(this.DublinCoreSchema);
                XmlTextReader dublinCoreData = new XmlTextReader(
                    dublinCoreXml.ToString(),
                    XmlNodeType.Element,
                    null);
                XmlReader validatorReader = null;

                try
                {
                    validatorReader = XmlReader.Create(dublinCoreData, xmlRdSetting);
                    while (validatorReader.Read())
                    {
                        ;
                    }
                }
                finally
                {
                    if (null != validatorReader)
                    {
                        validatorReader.Close();
                    }
                    if (null != dublinCoreData)
                    {
                        dublinCoreData.Close();
                    }
                }
            }
        }