C# SobekCM_Item.Get_Metadata_Module方法代码示例

 /// <summary> Flag indicates if this active reader/writer will write a dmdSec </summary>
 /// <param name="METS_Item"> Package with all the metadata to save</param>
 /// <returns> TRUE if the package has data to be written, otherwise fALSE </returns>
 public bool Include_dmdSec(SobekCM_Item METS_Item, Dictionary<string, object> Options)
 {
     // Ensure this metadata module extension exists and has data
     VRACore_Info vraInfo = METS_Item.Get_Metadata_Module(GlobalVar.VRACORE_METADATA_MODULE_KEY) as VRACore_Info;
     if ((vraInfo == null) || (!vraInfo.hasData))
         return false;
     return true;
 }

 /// <summary> Flag indicates if this active reader/writer will write a dmdSec </summary>
 /// <param name="METS_Item"> Package with all the metadata to save</param>
 /// <param name="Options"> Dictionary of any options which this METS section writer may utilize</param>
 /// <returns> TRUE if the package has data to be written, otherwise fALSE </returns>
 public bool Include_dmdSec(SobekCM_Item METS_Item, Dictionary<string, object> Options)
 {
     // Ensure this metadata module extension exists and has data
     Thesis_Dissertation_Info thesisInfo = METS_Item.Get_Metadata_Module(GlobalVar.THESIS_METADATA_MODULE_KEY) as Thesis_Dissertation_Info;
     if ((thesisInfo == null) || (!thesisInfo.hasData))
         return false;
     return true;
 }

 /// <summary> Flag indicates if this active reader/writer will write a dmdSec </summary>
 /// <param name="METS_Item"> Package with all the metadata to save</param>
 /// <param name="Options"> Dictionary of any options which this METS section writer may utilize</param>
 /// <returns> TRUE if the package has data to be written, otherwise fALSE </returns>
 public bool Include_dmdSec(SobekCM_Item METS_Item, Dictionary<string, object> Options)
 {
     // GEt the geo-spatial information if it exists
     GeoSpatial_Information geoInfo = METS_Item.Get_Metadata_Module(GlobalVar.GEOSPATIAL_METADATA_MODULE_KEY) as GeoSpatial_Information;
     if ((geoInfo == null) || (!geoInfo.hasData))
         return false;
     return true;
 }

 /// <summary> Flag indicates if this active reader/writer will write a dmdSec </summary>
 /// <param name="METS_Item"> Package with all the metadata to save</param>
 /// <param name="Options"> Dictionary of any options which this METS section writer may utilize</param>
 /// <returns> TRUE if the package has data to be written, otherwise fALSE </returns>
 public bool Include_dmdSec(SobekCM_Item METS_Item, Dictionary<string, object> Options)
 {
     // Ensure this metadata module extension exists and has data
     Zoological_Taxonomy_Info taxonInfo = METS_Item.Get_Metadata_Module(GlobalVar.ZOOLOGICAL_TAXONOMY_METADATA_MODULE_KEY) as Zoological_Taxonomy_Info;
     if ((taxonInfo == null) || (!taxonInfo.hasData))
         return false;
     return true;
 }

 /// <summary> Flag indicates if this active reader/writer will write a dmdSec </summary>
 /// <param name="METS_Item"> Package with all the metadata to save</param>
 /// <param name="Options"> Dictionary of any options which this METS section writer may utilize</param>
 /// <returns> TRUE if the package has data to be written, otherwise fALSE </returns>
 public bool Include_dmdSec(SobekCM_Item METS_Item, Dictionary<string, object> Options)
 {
     // Ensure this metadata module extension exists and has data
     LearningObjectMetadata lomInfo = METS_Item.Get_Metadata_Module(GlobalVar.IEEE_LOM_METADATA_MODULE_KEY) as LearningObjectMetadata;
     if ((lomInfo == null) || (!lomInfo.hasData))
         return false;
     return true;
 }

 /// <summary> Flag indicates if this active reader/writer will write an amdSec </summary>
 /// <param name="METS_Item"> Package with all the metadata to save</param>
 /// <param name="Options"> Dictionary of any options which this METS section writer may utilize</param>
 /// <returns> TRUE if the package has data to be written, otherwise fALSE </returns>
 public bool Include_amdSec(SobekCM_Item METS_Item, Dictionary<string, object> Options)
 {
     // Ensure this metadata module extension exists and has data
     DAITSS_Info daitssInfo = METS_Item.Get_Metadata_Module(GlobalVar.DAITSS_METADATA_MODULE_KEY) as DAITSS_Info;
     if ((daitssInfo == null) || (!daitssInfo.hasData))
         return false;
     return true;
 }

 /// <summary> Flag indicates if this active reader/writer will write a dmdSec </summary>
 /// <param name="METS_Item"> Package with all the metadata to save</param>
 /// <param name="Options"> Dictionary of any options which this METS section writer may utilize</param>
 /// <returns> TRUE if the package has data to be written, otherwise fALSE </returns>
 public bool Include_dmdSec(SobekCM_Item METS_Item, Dictionary<string, object> Options)
 {
     // Ensure this metadata module extension exists and has data
     Map_Info mapInfo = METS_Item.Get_Metadata_Module(GlobalVar.SOBEKCM_MAPS_METADATA_MODULE_KEY) as Map_Info;
     if ((mapInfo == null) || (!mapInfo.hasData))
         return false;
     return true;
 }

 /// <summary> Flag indicates if this active reader/writer will write an amdSec </summary>
 /// <param name="METS_Item"> Package with all the metadata to save</param>
 /// <param name="Options"> Dictionary of any options which this METS section writer may utilize</param>
 /// <returns> TRUE if the package has data to be written, otherwise fALSE </returns>
 public bool Include_amdSec(SobekCM_Item METS_Item, Dictionary<string, object> Options)
 {
     // Ensure this metadata module extension exists and has data
     RightsMD_Info rightsInfo = METS_Item.Get_Metadata_Module( GlobalVar.PALMM_RIGHTSMD_METADATA_MODULE_KEY)  as RightsMD_Info;
     if ((rightsInfo == null) || (!rightsInfo.hasData))
         return false;
     return true;
 }

        /// <summary> Writes the dmdSec for the entire package to the text writer </summary>
        /// <param name="Output_Stream">Stream to which the formatted text is written </param>
        /// <param name="METS_Item">Package with all the metadata to save</param>
        /// <param name="Options"> Dictionary of any options which this METS section writer may utilize</param>
        /// <returns>TRUE if successful, otherwise FALSE </returns>
        public override bool Write_dmdSec(TextWriter Output_Stream, SobekCM_Item METS_Item, Dictionary<string, object> Options)
        {
            // Ensure this metadata module extension exists and has data
            Thesis_Dissertation_Info thesisInfo = METS_Item.Get_Metadata_Module(GlobalVar.THESIS_METADATA_MODULE_KEY) as Thesis_Dissertation_Info;
            if ((thesisInfo == null) || (!thesisInfo.hasData))
                return true;

            Output_Stream.WriteLine("<palmm:thesis>");
            if (!String.IsNullOrEmpty(thesisInfo.Committee_Chair))
                Output_Stream.WriteLine("<palmm:committeeChair>" + Convert_String_To_XML_Safe(thesisInfo.Committee_Chair) + "</palmm:committeeChair>");
            if (!String.IsNullOrEmpty(thesisInfo.Committee_Co_Chair))
                Output_Stream.WriteLine("<palmm:committeeCoChair>" + Convert_String_To_XML_Safe(thesisInfo.Committee_Co_Chair) + "</palmm:committeeCoChair>");
            if (thesisInfo.Committee_Members_Count > 0)
            {
                foreach (string thisCommitteeMember in thesisInfo.Committee_Members)
                {
                    Output_Stream.WriteLine("<palmm:committeeMember>" + Convert_String_To_XML_Safe(thisCommitteeMember) + "</palmm:committeeMember>");
                }
            }
            if (thesisInfo.Graduation_Date.HasValue)
            {
                string encoded_date = thesisInfo.Graduation_Date.Value.Year + "-" + thesisInfo.Graduation_Date.Value.Month.ToString().PadLeft(2, '0') + "-" + thesisInfo.Graduation_Date.Value.Day.ToString().PadLeft(2, '0');
                Output_Stream.WriteLine("<palmm:graduationDate>" + encoded_date + "</palmm:graduationDate>");
            }
            if (!String.IsNullOrEmpty(thesisInfo.Degree))
                Output_Stream.WriteLine("<palmm:degree>" + Convert_String_To_XML_Safe(thesisInfo.Degree) + "</palmm:degree>");
            if (thesisInfo.Degree_Disciplines_Count > 0)
            {
                if ( thesisInfo.Degree_Disciplines_Count == 1 )
                    Output_Stream.WriteLine("<palmm:degreeDiscipline>" + Convert_String_To_XML_Safe(thesisInfo.Degree_Disciplines[0]) + "</palmm:degreeDiscipline>");
                else
                {
                    Output_Stream.Write("<palmm:degreeDiscipline>");
                    bool first = true;
                    foreach (string thisDiscipline in thesisInfo.Degree_Disciplines)
                    {
                        if ( !first )
                            Output_Stream.Write(";");
                        else
                            first = false;

                        Output_Stream.Write( Convert_String_To_XML_Safe(thisDiscipline));
                    }
                    Output_Stream.WriteLine("</palmm:degreeDiscipline>");
                }
            }
            if (!String.IsNullOrEmpty(thesisInfo.Degree_Grantor))
                Output_Stream.WriteLine("<palmm:degreeGrantor>" + Convert_String_To_XML_Safe(thesisInfo.Degree_Grantor) + "</palmm:degreeGrantor>");
            if (thesisInfo.Degree_Level == Thesis_Dissertation_Info.Thesis_Degree_Level_Enum.Bachelors)
                Output_Stream.WriteLine("<palmm:degreeLevel>Bachelors</palmm:degreeLevel>");
            if (thesisInfo.Degree_Level == Thesis_Dissertation_Info.Thesis_Degree_Level_Enum.Masters)
                Output_Stream.WriteLine("<palmm:degreeLevel>Masters</palmm:degreeLevel>");
            if (thesisInfo.Degree_Level == Thesis_Dissertation_Info.Thesis_Degree_Level_Enum.Doctorate)
                Output_Stream.WriteLine("<palmm:degreeLevel>Doctorate</palmm:degreeLevel>");
            Output_Stream.WriteLine("</palmm:thesis>");
            return true;
        }

        /// <summary> Reads the dmdSec at the current position in the XmlTextReader and associates it with the 
        /// entire package  </summary>
        /// <param name="Input_XmlReader"> Open XmlReader from which to read the metadata </param>
        /// <param name="Return_Package"> Package into which to read the metadata</param>
        /// <param name="Options"> Dictionary of any options which this METS section reader may utilize</param>
        /// <returns> TRUE if successful, otherwise FALSE</returns>
        public bool Read_dmdSec(XmlReader Input_XmlReader, SobekCM_Item Return_Package, Dictionary<string, object> Options)
        {
            // Ensure this metadata module extension exists
            LearningObjectMetadata lomInfo = Return_Package.Get_Metadata_Module(GlobalVar.IEEE_LOM_METADATA_MODULE_KEY) as LearningObjectMetadata;
            if (lomInfo == null)
            {
                lomInfo = new LearningObjectMetadata();
                Return_Package.Add_Metadata_Module(GlobalVar.IEEE_LOM_METADATA_MODULE_KEY, lomInfo);
            }

            // Loop through reading each XML node
            do
            {
                // If this is the end of this section, return
                if ((Input_XmlReader.NodeType == XmlNodeType.EndElement) && ((Input_XmlReader.Name == "METS:mdWrap") || (Input_XmlReader.Name == "mdWrap")))
                    return true;

                // get the right division information based on node type
                if (Input_XmlReader.NodeType == XmlNodeType.Element)
                {
                    string name = Input_XmlReader.Name.ToLower();
                    if (( lom_namespace.Length > 0 ) && ( name.IndexOf( lom_namespace ) == 0))
                        name = name.Substring(lom_namespace.Length);

                    switch (name)
                    {
                        case "general":
                            read_general(Input_XmlReader.ReadSubtree(), lomInfo);
                            break;

                        case "lifecycle":
                            read_lifecycle(Input_XmlReader.ReadSubtree(), lomInfo);
                            break;

                        case "technical":
                            read_technical(Input_XmlReader.ReadSubtree(), lomInfo);
                            break;

                        case "educational":
                            read_educational(Input_XmlReader.ReadSubtree(), lomInfo);
                            break;

                        case "classification":
                            read_classification(Input_XmlReader.ReadSubtree(), lomInfo);
                            break;

                    }
                }

            } while (Input_XmlReader.Read());

            return true;
        }

        /// <summary> Reads the dmdSec at the current position in the XmlTextReader and associates it with the 
        /// entire package  </summary>
        /// <param name="Input_XmlReader"> Open XmlReader from which to read the metadata </param>
        /// <param name="Return_Package"> Package into which to read the metadata</param>
        /// <param name="Options"> Dictionary of any options which this METS section reader may utilize</param>
        /// <returns> TRUE if successful, otherwise FALSE</returns>  
        public bool Read_dmdSec(XmlReader Input_XmlReader, SobekCM_Item Return_Package, Dictionary<string, object> Options)
        {
            // Get the geo-spatial information if it exists or create a new one
            GeoSpatial_Information geoInfo = Return_Package.Get_Metadata_Module(GlobalVar.GEOSPATIAL_METADATA_MODULE_KEY) as GeoSpatial_Information;
            if (geoInfo == null)
            {
                geoInfo = new GeoSpatial_Information();
                Return_Package.Add_Metadata_Module(GlobalVar.GEOSPATIAL_METADATA_MODULE_KEY, geoInfo);
            }

            return Read_Metadata_Section(Input_XmlReader, geoInfo, Options);
        }

        /// <summary> Reads the dmdSec at the current position in the XmlTextReader and associates it with the 
        /// entire package  </summary>
        /// <param name="Input_XmlReader"> Open XmlReader from which to read the metadata </param>
        /// <param name="Return_Package"> Package into which to read the metadata</param>
        /// <param name="Options"> Dictionary of any options which this METS section reader may utilize</param>
        /// <returns> TRUE if successful, otherwise FALSE</returns>
        public bool Read_dmdSec(XmlReader Input_XmlReader, SobekCM_Item Return_Package, Dictionary<string, object> Options)
        {
            // Ensure this metadata module extension exists
            Map_Info mapInfo = Return_Package.Get_Metadata_Module(GlobalVar.SOBEKCM_MAPS_METADATA_MODULE_KEY) as Map_Info;
            if (mapInfo == null)
            {
                mapInfo = new Map_Info();
                Return_Package.Add_Metadata_Module(GlobalVar.SOBEKCM_MAPS_METADATA_MODULE_KEY, mapInfo);
            }

            // Try to get the attributes from here first
            if (Input_XmlReader.MoveToAttribute("id"))
                mapInfo.MapID = Input_XmlReader.Value;

            // Step through each field
            while (Input_XmlReader.Read())
            {
                if ((Input_XmlReader.NodeType == XmlNodeType.EndElement) && (Input_XmlReader.Name == "map:ufdc_map"))
                    return true;

                if (Input_XmlReader.NodeType == XmlNodeType.Element)
                {
                    switch (Input_XmlReader.Name)
                    {
                        case "map:indexes":
                            read_map_indexes(Input_XmlReader, mapInfo);
                            break;

                        case "map:entities":
                            read_map_entities(Input_XmlReader, mapInfo);
                            break;

                        case "map:sheets":
                            read_map_sheets(Input_XmlReader, mapInfo);
                            break;
                    }
                }
            }

            // Return false since this read all the way to the end of the steam
            return false;
        }

        /// <summary> Reads the amdSec at the current position in the XmlTextReader and associates it with the 
        /// entire package  </summary>
        /// <param name="Input_XmlReader"> Open XmlReader from which to read the metadata </param>
        /// <param name="Return_Package"> Package into which to read the metadata</param>
        /// <param name="Options"> Dictionary of any options which this METS section reader may utilize</param>
        /// <returns> TRUE if successful, otherwise FALSE</returns>
        public bool Read_amdSec(XmlReader Input_XmlReader, SobekCM_Item Return_Package, Dictionary<string, object> Options)
        {
            // Ensure this metadata module extension exists
            DAITSS_Info daitssInfo = Return_Package.Get_Metadata_Module(GlobalVar.DAITSS_METADATA_MODULE_KEY) as DAITSS_Info;
            if (daitssInfo == null)
            {
                daitssInfo = new DAITSS_Info();
                Return_Package.Add_Metadata_Module(GlobalVar.DAITSS_METADATA_MODULE_KEY, daitssInfo);
            }

            // Loop through reading each XML node
            do
            {
                // If this is the end of this section, return
                if ((Input_XmlReader.NodeType == XmlNodeType.EndElement) && ((Input_XmlReader.Name == "METS:mdWrap") || (Input_XmlReader.Name == "mdWrap")))
                    return true;

                // get the right division information based on node type
                switch (Input_XmlReader.NodeType)
                {
                    case XmlNodeType.Element:
                        if ((Input_XmlReader.Name.ToLower() == "daitss:agreement_info") && (Input_XmlReader.HasAttributes))
                        {
                            if (Input_XmlReader.MoveToAttribute("ACCOUNT"))
                                daitssInfo.Account = Input_XmlReader.Value;

                            if (Input_XmlReader.MoveToAttribute("SUB_ACCOUNT"))
                                daitssInfo.SubAccount = Input_XmlReader.Value;

                            if (Input_XmlReader.MoveToAttribute("PROJECT"))
                                daitssInfo.Project = Input_XmlReader.Value;
                        }
                        break;
                }
            } while (Input_XmlReader.Read());

            // Return false since this read all the way to the end of the steam
            return false;
        }

        /// <summary> Writes the dmdSec for the entire package to the text writer </summary>
        /// <param name="Output_Stream">Stream to which the formatted text is written </param>
        /// <param name="METS_Item">Package with all the metadata to save</param>
        /// <param name="Options"> Dictionary of any options which this METS section writer may utilize</param>
        /// <returns>TRUE if successful, otherwise FALSE </returns>
        /// <remarks>This utilized the DC writer in the base class and just adds the ETD information </remarks>
        public override bool Write_dmdSec(System.IO.TextWriter Output_Stream, SobekCM_Item METS_Item, Dictionary<string, object> Options)
        {
            // Write the base stuff
            base.Write_dmdSec(Output_Stream, METS_Item, Options);

            // Ensure this metadata module extension exists and has data
            Thesis_Dissertation_Info thesisInfo = METS_Item.Get_Metadata_Module(GlobalVar.THESIS_METADATA_MODULE_KEY) as Thesis_Dissertation_Info;
            if ((thesisInfo == null) || (!thesisInfo.hasData))
                return true;

            // Add the ETD stuff if the ETD metadata module exists
            if (!String.IsNullOrEmpty(thesisInfo.Degree))
                Output_Stream.WriteLine("<thesis.degree.name>" + Convert_String_To_XML_Safe(thesisInfo.Degree) + "</thesis.degree.name>");

            if (thesisInfo.Degree_Level == Thesis_Dissertation_Info.Thesis_Degree_Level_Enum.Bachelors)
                Output_Stream.WriteLine("<thesis.degree.level>Bachelors</thesis.degree.level>");
            if (thesisInfo.Degree_Level == Thesis_Dissertation_Info.Thesis_Degree_Level_Enum.Masters)
                Output_Stream.WriteLine("<thesis.degree.level>Masters</thesis.degree.level>");
            if (thesisInfo.Degree_Level == Thesis_Dissertation_Info.Thesis_Degree_Level_Enum.Doctorate)
                Output_Stream.WriteLine("<thesis.degree.level>Doctorate</thesis.degree.level>");
            if (thesisInfo.Degree_Level == Thesis_Dissertation_Info.Thesis_Degree_Level_Enum.PostDoctorate)
                Output_Stream.WriteLine("<thesis.degree.level>Post-Doctorate</thesis.degree.level>");

            if (thesisInfo.Degree_Disciplines_Count > 0)
            {
                foreach (string thisDiscipline in thesisInfo.Degree_Disciplines)
                {
                    Output_Stream.WriteLine("<thesis.degree.discipline>" + Convert_String_To_XML_Safe(thisDiscipline) + "</thesis.degree.discipline>");
                }
            }

            if (!String.IsNullOrEmpty(thesisInfo.Degree_Grantor))
                Output_Stream.WriteLine("<thesis.degree.grantor>" + Convert_String_To_XML_Safe(thesisInfo.Degree_Grantor) + "</thesis.degree.grantor>");

            return true;
        }

        /// <summary> Flag indicates if this active reader/writer needs to append schema reference information
        /// to the METS XML header by analyzing the contents of the digital resource item </summary>
        /// <param name="METS_Item"> Package with all the metadata to save</param>
        /// <returns> TRUE if the schema should be attached, otherwise fALSE </returns>
        public bool Schema_Reference_Required_Package(SobekCM_Item METS_Item)
        {
            Thesis_Dissertation_Info thesisInfo = METS_Item.Get_Metadata_Module(GlobalVar.THESIS_METADATA_MODULE_KEY) as Thesis_Dissertation_Info;
            if (thesisInfo == null)
                return false;

            return thesisInfo.hasData;
        }