Пример #1
0
        /// <summary> Constructor for a new instance of the Legacy_SolrDocument class </summary>
        /// <param name="Digital_Object"> Digital object to create an easily indexable view object for </param>
        /// <param name="File_Location"> Location for all of the text files associated with this item </param>
        /// <remarks> Some work is done in the constructor; in particular, work that eliminates the number of times
        /// iterations must be made through objects which may be indexed in a number of places.
        /// This includes subject keywords, spatial information, genres, and information from the table of contents </remarks>
        public Legacy_SolrDocument(SobekCM_Item Digital_Object, string File_Location)
        {
            digitalObject = Digital_Object;
            fileLocation  = File_Location;

            // Add the subjects
            if (digitalObject.Bib_Info.Subjects_Count > 0)
            {
                foreach (Subject_Info thisSubject in digitalObject.Bib_Info.Subjects)
                {
                    // Add every subject to the complete list of subjects
                    allsubjects.Add(thisSubject.ToString(false));

                    // Add name subjects
                    if (thisSubject.Class_Type == Subject_Info_Type.Name)
                    {
                        namesubject.Add(thisSubject.ToString(false));
                    }

                    // Add title subjects
                    if (thisSubject.Class_Type == Subject_Info_Type.TitleInfo)
                    {
                        titlesubject.Add(thisSubject.ToString(false));
                    }

                    // Add the subject keywords
                    if ((thisSubject.Class_Type == Subject_Info_Type.Standard) && (thisSubject.ID.IndexOf("690") < 0) && (thisSubject.ID.IndexOf("691") < 0))
                    {
                        // Cast to the hierarchical subject type
                        Subject_Info_Standard standSubj = (Subject_Info_Standard)thisSubject;

                        if (standSubj.Genres_Count > 0)
                        {
                            foreach (string genreTerm in standSubj.Genres)
                            {
                                genre.Add(genreTerm.ToLower());
                            }
                        }
                        if (standSubj.Geographics_Count > 0)
                        {
                            foreach (string geoTerm in standSubj.Geographics)
                            {
                                spatialcoverage.Add(geoTerm);
                            }
                        }
                        if (standSubj.Topics_Count > 0)
                        {
                            foreach (string topicTerm in standSubj.Topics)
                            {
                                subjectkeyword.Add(topicTerm);
                            }
                        }
                    }

                    // Add hierarchical spatial info
                    if (thisSubject.Class_Type == Subject_Info_Type.Hierarchical_Spatial)
                    {
                        // Cast to the hierarchical subject type
                        Subject_Info_HierarchicalGeographic hiero = (Subject_Info_HierarchicalGeographic)thisSubject;

                        // Check for existing subfacets and add if not there
                        if ((hiero.Continent.Length > 0) && (!spatialcoverage.Contains(hiero.Continent)))
                        {
                            spatialcoverage.Add(hiero.Continent);
                        }
                        if ((hiero.Country.Length > 0) && (!country.Contains(hiero.Country)))
                        {
                            country.Add(hiero.Country);
                        }
                        if ((hiero.State.Length > 0) && (!state.Contains(hiero.State)))
                        {
                            state.Add(hiero.State);
                        }
                        if ((hiero.County.Length > 0) && (!county.Contains(hiero.County)))
                        {
                            county.Add(hiero.County);
                        }
                        if ((hiero.City.Length > 0) && (!city.Contains(hiero.City)))
                        {
                            city.Add(hiero.City);
                        }
                        if ((hiero.Island.Length > 0) && (!spatialcoverage.Contains(hiero.Island)))
                        {
                            spatialcoverage.Add(hiero.Island);
                        }
                    }
                }
            }

            // Add the individual genre information (just to be done with genre)
            if (digitalObject.Bib_Info.Genres_Count > 0)
            {
                foreach (Genre_Info thisGenre in digitalObject.Bib_Info.Genres)
                {
                    genre.Add(thisGenre.Genre_Term.ToLower());
                }
            }

            // Add all the temporal subjects
            if (digitalObject.Bib_Info.TemporalSubjects_Count > 0)
            {
                foreach (Temporal_Info thisTemporal in digitalObject.Bib_Info.TemporalSubjects)
                {
                    if (thisTemporal.TimePeriod.Length > 0)
                    {
                        allsubjects.Add(thisTemporal.TimePeriod);
                        temporalsubject.Add(thisTemporal.TimePeriod);
                    }
                }
            }

            // Prepare to step through all the divisions/pages in this item
            int pageorder = 1;

            tocterms  = new List <string>();
            solrpages = new List <Legacy_SolrPage>();
            List <abstract_TreeNode> divsAndPages = digitalObject.Divisions.Physical_Tree.Divisions_PreOrder;

            // Get the list of all TXT files in this division
            string[] text_files = Directory.GetFiles(File_Location, "*.txt");
            Dictionary <string, string> text_files_existing = new Dictionary <string, string>();

            foreach (string thisTextFile in text_files)
            {
                string filename = (new FileInfo(thisTextFile)).Name.ToUpper();
                text_files_existing[filename] = filename;
            }

            // Get the list of all THM.JPG files in this division
            string[] thumbnail_files = Directory.GetFiles(File_Location, "*thm.jpg");
            Dictionary <string, string> thumbnail_files_existing = new Dictionary <string, string>();

            foreach (string thisTextFile in thumbnail_files)
            {
                string filename = (new FileInfo(thisTextFile)).Name;
                thumbnail_files_existing[filename.ToUpper().Replace("THM.JPG", "")] = filename;
            }

            // Step through all division nodes from the physical tree here
            List <string> text_files_included = new List <string>();

            foreach (abstract_TreeNode thisNode in divsAndPages)
            {
                if (thisNode.Page)
                {
                    // Cast to a page to continnue
                    Page_TreeNode pageNode = (Page_TreeNode)thisNode;

                    // If this is a unique page label, add it
                    if (pageNode.Label.Length > 0)
                    {
                        if (pageNode.Label.ToUpper().IndexOf("PAGE ") < 0)
                        {
                            tocterms.Add(pageNode.Label);
                        }
                    }

                    // Look for the root filename and then look for a matching TEXT file
                    if (pageNode.Files.Count > 0)
                    {
                        string root = pageNode.Files[0].File_Name_Sans_Extension;
                        if (text_files_existing.ContainsKey(root.ToUpper() + ".TXT"))
                        {
                            try
                            {
                                // SInce this is marked to be included, save this name
                                text_files_included.Add(root.ToUpper() + ".TXT");

                                // Read the page text
                                StreamReader reader   = new StreamReader(File_Location + "\\" + root + ".txt");
                                string       pageText = reader.ReadToEnd().Trim();
                                reader.Close();

                                // Look for a matching thumbnail
                                string thumbnail = String.Empty;
                                if (thumbnail_files_existing.ContainsKey(root.ToUpper()))
                                {
                                    thumbnail = thumbnail_files_existing[root.ToUpper()];
                                }

                                Legacy_SolrPage newPage = new Legacy_SolrPage(digitalObject.BibID, digitalObject.VID, pageorder, pageNode.Label, pageText, thumbnail);
                                solrpages.Add(newPage);
                            }
                            catch
                            {
                            }
                        }
                    }

                    // Increment the page order for the next page irregardless
                    pageorder++;
                }
                else
                {
                    // Add the label or type for this division
                    if (thisNode.Label.Length > 0)
                    {
                        tocterms.Add(thisNode.Label);
                    }
                    else if (thisNode.Type.Length > 0)
                    {
                        tocterms.Add(thisNode.Type);
                    }
                }
            }

            // Now, check for any other valid text files
            additional_text_files = new List <string>();
            foreach (string thisTextFile in text_files_existing.Keys)
            {
                if ((!text_files_included.Contains(thisTextFile.ToUpper())) && (thisTextFile.ToUpper() != "AGREEMENT.TXT") && (thisTextFile.ToUpper().IndexOf("REQUEST") != 0))
                {
                    additional_text_files.Add(thisTextFile);
                }
            }
        }
        /// <summary> Build the solr document from the SobekCM Digital Resource object  </summary>
        /// <param name="Digital_Object"> Digital object to create an easily indexable view object for </param>
        /// <param name="File_Location"> Location for all of the text files associated with this item </param>
        /// <returns> Fully built (v5) solr document </returns>
        public v5_SolrDocument Build_Solr_Document(SobekCM_Item Digital_Object, string File_Location)
        {
            // Start the return object
            v5_SolrDocument returnValue = new v5_SolrDocument();

            returnValue.FileLocation = File_Location;

            // Set the unique key
            returnValue.DID = Digital_Object.BibID + ":" + Digital_Object.VID;

            // Add the administrative fields
            returnValue.Aggregations = new List <string>();
            returnValue.Aggregations.AddRange(Digital_Object.Behaviors.Aggregation_Code_List);
            returnValue.BibID         = Digital_Object.BibID;
            returnValue.VID           = Digital_Object.VID;
            returnValue.MainThumbnail = Digital_Object.Behaviors.Main_Thumbnail;

            // Add the made public field
            if (Digital_Object.Web.MadePublicDate.HasValue)
            {
                returnValue.MadePublicDate = Digital_Object.Web.MadePublicDate.Value;
            }
            else
            {
                // If this is public and non-dark, but no date for made
                // public exists, make it today
                if ((!Digital_Object.Behaviors.Dark_Flag) && (Digital_Object.Behaviors.IP_Restriction_Membership >= 0))
                {
                    Digital_Object.Web.MadePublicDate = DateTime.Now;
                }
            }

            // Add Serial hierarchy fields
            returnValue.Level1_Text  = String.Empty;
            returnValue.Level1_Index = -1;
            returnValue.Level1_Facet = "NONE";
            returnValue.Level2_Text  = String.Empty;
            returnValue.Level2_Index = -1;
            returnValue.Level2_Facet = "NONE";
            returnValue.Level3_Text  = String.Empty;
            returnValue.Level3_Index = -1;
            returnValue.Level3_Facet = "NONE";
            returnValue.Level4_Text  = String.Empty;
            returnValue.Level4_Index = -1;
            returnValue.Level4_Facet = "NONE";
            returnValue.Level5_Text  = String.Empty;
            returnValue.Level5_Index = -1;
            returnValue.Level5_Facet = "NONE";

            if (Digital_Object.Behaviors != null)
            {
                if (Digital_Object.Behaviors.Serial_Info.Count > 0)
                {
                    returnValue.Level1_Index        = Digital_Object.Behaviors.Serial_Info[0].Order;
                    returnValue.Level1_Text         = Digital_Object.Behaviors.Serial_Info[0].Display;
                    returnValue.Level1_Text_Display = Digital_Object.Behaviors.Serial_Info[0].Display;
                    returnValue.Level1_Facet        = Digital_Object.Behaviors.Serial_Info[0].Order.ToString().PadLeft(5, '0') + '|' + Digital_Object.Behaviors.Serial_Info[0].Display;
                }
                if (Digital_Object.Behaviors.Serial_Info.Count > 1)
                {
                    returnValue.Level2_Index        = Digital_Object.Behaviors.Serial_Info[1].Order;
                    returnValue.Level2_Text         = Digital_Object.Behaviors.Serial_Info[1].Display;
                    returnValue.Level2_Text_Display = Digital_Object.Behaviors.Serial_Info[1].Display;
                    returnValue.Level2_Facet        = Digital_Object.Behaviors.Serial_Info[1].Order.ToString().PadLeft(5, '0') + '|' + Digital_Object.Behaviors.Serial_Info[1].Display;
                }
                if (Digital_Object.Behaviors.Serial_Info.Count > 2)
                {
                    returnValue.Level3_Index        = Digital_Object.Behaviors.Serial_Info[2].Order;
                    returnValue.Level3_Text         = Digital_Object.Behaviors.Serial_Info[2].Display;
                    returnValue.Level3_Text_Display = Digital_Object.Behaviors.Serial_Info[2].Display;
                    returnValue.Level3_Facet        = Digital_Object.Behaviors.Serial_Info[2].Order.ToString().PadLeft(5, '0') + '|' + Digital_Object.Behaviors.Serial_Info[2].Display;
                }
                if (Digital_Object.Behaviors.Serial_Info.Count > 3)
                {
                    returnValue.Level4_Index        = Digital_Object.Behaviors.Serial_Info[3].Order;
                    returnValue.Level4_Text         = Digital_Object.Behaviors.Serial_Info[3].Display;
                    returnValue.Level4_Text_Display = Digital_Object.Behaviors.Serial_Info[3].Display;
                    returnValue.Level4_Facet        = Digital_Object.Behaviors.Serial_Info[3].Order.ToString().PadLeft(5, '0') + '|' + Digital_Object.Behaviors.Serial_Info[3].Display;
                }
                if (Digital_Object.Behaviors.Serial_Info.Count > 4)
                {
                    returnValue.Level5_Index        = Digital_Object.Behaviors.Serial_Info[4].Order;
                    returnValue.Level5_Text         = Digital_Object.Behaviors.Serial_Info[4].Display;
                    returnValue.Level5_Text_Display = Digital_Object.Behaviors.Serial_Info[4].Display;
                    returnValue.Level5_Facet        = Digital_Object.Behaviors.Serial_Info[4].Order.ToString().PadLeft(5, '0') + '|' + Digital_Object.Behaviors.Serial_Info[4].Display;
                }

                returnValue.Hidden = Digital_Object.Behaviors.Dark_Flag;
            }

            // Some defaults
            returnValue.Discover_Groups = new List <int> {
                0
            };
            returnValue.Discover_Users = new List <int> {
                0
            };
            returnValue.RestrictedMsg = String.Empty;

            // Set the IP restrictions based on PRIVATE or NOT
            if (Digital_Object.Behaviors.IP_Restriction_Membership == -1)
            {
                returnValue.Discover_IPs = new List <int> {
                    -1
                }
            }
            ;
            else
            {
                returnValue.Discover_IPs = new List <int> {
                    0
                };

                // If some restrictions, set the restriction message
                if (Digital_Object.Behaviors.IP_Restriction_Membership > 0)
                {
                    returnValue.RestrictedMsg = "Access Restrictions Apply";
                }
            }

            // Set the spatial KML
            GeoSpatial_Information geo = Digital_Object.Get_Metadata_Module(GlobalVar.GEOSPATIAL_METADATA_MODULE_KEY) as GeoSpatial_Information;

            if (geo != null)
            {
                if (returnValue.SpatialFootprintKml == null)
                {
                    returnValue.SpatialFootprintKml = new List <string>();
                }
                returnValue.SpatialFootprintKml.Add(geo.SobekCM_Main_Spatial_String);

                returnValue.SpatialDistance = (int)geo.SobekCM_Main_Spatial_Distance;
            }

            // Get the rest of the metadata, from the item
            List <KeyValuePair <string, string> > searchTerms = Digital_Object.Search_Terms;

            // Loop through and add each data field
            foreach (KeyValuePair <string, string> searchTerm in searchTerms)
            {
                // Ensure there is a value here
                if (String.IsNullOrWhiteSpace(searchTerm.Value))
                {
                    continue;
                }

                // Assign based on the key term
                switch (searchTerm.Key.ToLower())
                {
                case "title":
                    returnValue.Title = searchTerm.Value;
                    break;

                case "sort title":
                    returnValue.SortTitle = searchTerm.Value;
                    break;

                case "other title":
                    if (returnValue.AltTitle == null)
                    {
                        returnValue.AltTitle = new List <string>();
                    }
                    returnValue.AltTitle.Add(searchTerm.Value);
                    break;

                case "translated title":
                    if (returnValue.TranslatedTitle == null)
                    {
                        returnValue.TranslatedTitle = new List <string>();
                    }
                    returnValue.TranslatedTitle.Add(searchTerm.Value);
                    break;

                case "series title":
                    returnValue.SeriesTitle = searchTerm.Value;
                    break;

                case "other citation":
                    if (returnValue.OtherCitation == null)
                    {
                        returnValue.OtherCitation = new List <string>();
                    }
                    returnValue.OtherCitation.Add(searchTerm.Value);
                    break;

                case "tickler":
                    if (returnValue.Tickler == null)
                    {
                        returnValue.Tickler = new List <string>();
                    }
                    returnValue.Tickler.Add(searchTerm.Value);
                    break;

                case "abstract":
                    if (returnValue.Abstract == null)
                    {
                        returnValue.Abstract = new List <string>();
                    }
                    returnValue.Abstract.Add(searchTerm.Value);
                    break;

                case "affililation":
                    if (returnValue.Affiliation == null)
                    {
                        returnValue.Affiliation = new List <string>();
                    }
                    returnValue.Affiliation.Add(searchTerm.Value);

                    // For now, also put this in the display
                    if (returnValue.AffiliationDisplay == null)
                    {
                        returnValue.AffiliationDisplay = new List <string>();
                    }
                    returnValue.AffiliationDisplay.Add(searchTerm.Value);
                    break;

                case "affililation display":
                    if (returnValue.AffiliationDisplay == null)
                    {
                        returnValue.AffiliationDisplay = new List <string>();
                    }
                    returnValue.AffiliationDisplay.Add(searchTerm.Value);
                    break;

                case "genre":
                    if (returnValue.Genre == null)
                    {
                        returnValue.Genre = new List <string>();
                    }
                    returnValue.Genre.Add(searchTerm.Value);
                    break;

                case "genre display":
                    if (returnValue.GenreDisplay == null)
                    {
                        returnValue.GenreDisplay = new List <string>();
                    }
                    returnValue.GenreDisplay.Add(searchTerm.Value);
                    break;

                case "donor":
                    returnValue.Donor = searchTerm.Value;
                    break;

                case "identifier":
                    if (returnValue.Identifier == null)
                    {
                        returnValue.Identifier = new List <string>();
                    }
                    returnValue.Identifier.Add(searchTerm.Value);
                    break;

                case "identifier display":
                    if (returnValue.IdentifierDisplay == null)
                    {
                        returnValue.IdentifierDisplay = new List <string>();
                    }
                    returnValue.IdentifierDisplay.Add(searchTerm.Value);
                    break;

                case "accession number":
                    // Set the display value (also used for faceting) to the full term
                    returnValue.AccessionNumberDisplay = searchTerm.Value;

                    // Make sure the list is built
                    if (returnValue.AccessionNumber == null)
                    {
                        returnValue.AccessionNumber = new List <string>();
                    }

                    // If there are any periods, represeting a hierarchical identifier, split it
                    if (searchTerm.Value.IndexOf(".") > 0)
                    {
                        // Add each segment of the identifier
                        string[]      split   = searchTerm.Value.Split(".".ToCharArray());
                        StringBuilder builder = new StringBuilder(split[0]);
                        returnValue.AccessionNumber.Add(builder.ToString());
                        for (int i = 1; i < split.Length; i++)
                        {
                            builder.Append("." + split[i]);
                            returnValue.AccessionNumber.Add(builder.ToString());
                        }
                    }
                    else
                    {
                        returnValue.AccessionNumber.Add(searchTerm.Value);
                    }

                    break;

                case "language":
                    if (returnValue.Language == null)
                    {
                        returnValue.Language = new List <string>();
                    }
                    returnValue.Language.Add(searchTerm.Value);
                    break;

                case "creator":
                    if (returnValue.Creator == null)
                    {
                        returnValue.Creator = new List <string>();
                    }
                    returnValue.Creator.Add(searchTerm.Value);
                    break;

                case "creator.display":
                    if (returnValue.Creator_Display == null)
                    {
                        returnValue.Creator_Display = new List <string>();
                    }
                    returnValue.Creator_Display.Add(searchTerm.Value);
                    break;

                case "publisher":
                    if (returnValue.Publisher == null)
                    {
                        returnValue.Publisher = new List <string>();
                    }
                    returnValue.Publisher.Add(searchTerm.Value);
                    break;

                case "publisher.display":
                    if (returnValue.Publisher_Display == null)
                    {
                        returnValue.Publisher_Display = new List <string>();
                    }
                    returnValue.Publisher_Display.Add(searchTerm.Value);
                    break;

                case "holding location":
                    returnValue.Holding = searchTerm.Value;
                    break;

                case "notes":
                    if (returnValue.Notes == null)
                    {
                        returnValue.Notes = new List <string>();
                    }
                    returnValue.Notes.Add(searchTerm.Value);
                    break;

                case "frequency":
                    if (returnValue.Frequency == null)
                    {
                        returnValue.Frequency = new List <string>();
                    }
                    returnValue.Frequency.Add(searchTerm.Value);
                    break;

                case "edition":
                    returnValue.Edition = searchTerm.Value;
                    break;

                case "publication place":
                    if (returnValue.PubPlace == null)
                    {
                        returnValue.PubPlace = new List <string>();
                    }
                    returnValue.PubPlace.Add(searchTerm.Value);
                    break;

                case "format":
                    returnValue.Format = searchTerm.Value;
                    break;

                case "source institution":
                    returnValue.Source = searchTerm.Value;
                    break;

                case "target audience":
                    if (returnValue.Audience == null)
                    {
                        returnValue.Audience = new List <string>();
                    }
                    returnValue.Audience.Add(searchTerm.Value);
                    break;

                case "type":
                    returnValue.Type = searchTerm.Value;
                    break;

                case "name as subject":
                    if (returnValue.NameAsSubject == null)
                    {
                        returnValue.NameAsSubject = new List <string>();
                    }
                    returnValue.NameAsSubject.Add(searchTerm.Value);
                    break;

                case "name as subject dispay":
                    if (returnValue.NameAsSubjectDisplay == null)
                    {
                        returnValue.NameAsSubjectDisplay = new List <string>();
                    }
                    returnValue.NameAsSubjectDisplay.Add(searchTerm.Value);
                    break;

                case "title as subject":
                    if (returnValue.TitleAsSubject == null)
                    {
                        returnValue.TitleAsSubject = new List <string>();
                    }
                    returnValue.TitleAsSubject.Add(searchTerm.Value);
                    break;

                case "title as subject display":
                    if (returnValue.TitleAsSubjectDisplay == null)
                    {
                        returnValue.TitleAsSubjectDisplay = new List <string>();
                    }
                    returnValue.TitleAsSubjectDisplay.Add(searchTerm.Value);
                    break;

                case "spatial coverage":
                    if (returnValue.Spatial == null)
                    {
                        returnValue.Spatial = new List <string>();
                    }
                    returnValue.Spatial.Add(searchTerm.Value);
                    break;

                case "spatial coverage.display":
                    if (returnValue.SpatialDisplay == null)
                    {
                        returnValue.SpatialDisplay = new List <string>();
                    }
                    returnValue.SpatialDisplay.Add(searchTerm.Value);
                    break;

                case "country":
                    if (returnValue.Country == null)
                    {
                        returnValue.Country = new List <string>();
                    }
                    returnValue.Country.Add(searchTerm.Value);
                    break;

                case "state":
                    if (returnValue.State == null)
                    {
                        returnValue.State = new List <string>();
                    }
                    returnValue.State.Add(searchTerm.Value);
                    break;

                case "county":
                    if (returnValue.County == null)
                    {
                        returnValue.County = new List <string>();
                    }
                    returnValue.County.Add(searchTerm.Value);
                    break;

                case "city":
                    if (returnValue.City == null)
                    {
                        returnValue.City = new List <string>();
                    }
                    returnValue.City.Add(searchTerm.Value);
                    break;

                case "subject keyword":
                    if (returnValue.Subject == null)
                    {
                        returnValue.Subject = new List <string>();
                    }
                    returnValue.Subject.Add(searchTerm.Value.Trim());
                    break;

                case "subjects.display":
                    if (returnValue.SubjectDisplay == null)
                    {
                        returnValue.SubjectDisplay = new List <string>();
                    }
                    returnValue.SubjectDisplay.Add(searchTerm.Value.Trim());
                    break;

                case "publication date":
                    returnValue.Date        = searchTerm.Value;
                    returnValue.DateDisplay = searchTerm.Value;
                    break;

                case "date year":
                    returnValue.DateYear = searchTerm.Value;
                    break;

                case "toc":
                    if (returnValue.TableOfContents == null)
                    {
                        returnValue.TableOfContents = new List <string>();
                    }
                    returnValue.TableOfContents.Add(searchTerm.Value.Trim());
                    break;

                case "mime type":
                    if (returnValue.MimeType == null)
                    {
                        returnValue.MimeType = new List <string>();
                    }
                    returnValue.MimeType.Add(searchTerm.Value.Trim());
                    break;

                case "cultural context":
                    if (returnValue.CulturalContext == null)
                    {
                        returnValue.CulturalContext = new List <string>();
                    }
                    returnValue.CulturalContext.Add(searchTerm.Value.Trim());
                    break;

                case "inscription":
                    if (returnValue.Inscription == null)
                    {
                        returnValue.Inscription = new List <string>();
                    }
                    returnValue.Inscription.Add(searchTerm.Value.Trim());
                    break;

                case "materials":
                case "material":
                    if (returnValue.Material == null)
                    {
                        returnValue.Material = new List <string>();
                    }
                    returnValue.Material.Add(searchTerm.Value.Trim());
                    break;

                case "materials display":
                case "material display":
                    if (returnValue.MaterialDisplay == null)
                    {
                        returnValue.MaterialDisplay = new List <string>();
                    }
                    returnValue.MaterialDisplay.Add(searchTerm.Value.Trim());
                    break;

                case "measurements":
                    if (returnValue.Measurements == null)
                    {
                        returnValue.Measurements = new List <string>();
                    }
                    returnValue.Measurements.Add(searchTerm.Value.Trim());
                    break;

                case "measurements display":
                    if (returnValue.MeasurementsDisplay == null)
                    {
                        returnValue.MeasurementsDisplay = new List <string>();
                    }
                    returnValue.MeasurementsDisplay.Add(searchTerm.Value.Trim());
                    break;

                case "style period":
                    if (returnValue.StylePeriod == null)
                    {
                        returnValue.StylePeriod = new List <string>();
                    }
                    returnValue.StylePeriod.Add(searchTerm.Value.Trim());
                    break;

                case "technique":
                    if (returnValue.Technique == null)
                    {
                        returnValue.Technique = new List <string>();
                    }
                    returnValue.Technique.Add(searchTerm.Value.Trim());
                    break;

                case "interviewee":
                    if (returnValue.Interviewee == null)
                    {
                        returnValue.Interviewee = new List <string>();
                    }
                    returnValue.Interviewee.Add(searchTerm.Value.Trim());
                    break;

                case "interviewer":
                    if (returnValue.Interviewer == null)
                    {
                        returnValue.Interviewer = new List <string>();
                    }
                    returnValue.Interviewer.Add(searchTerm.Value.Trim());
                    break;

                case "performance":
                    returnValue.Performance = searchTerm.Value.Trim();

                    // For now, we aren't setting the performance display any differently than performance
                    returnValue.PerformanceDisplay = searchTerm.Value.Trim();
                    break;

                case "performance date":
                    returnValue.PerformanceDate = searchTerm.Value.Trim();
                    break;

                case "performer":
                    if (returnValue.Performer == null)
                    {
                        returnValue.Performer = new List <string>();
                    }
                    returnValue.Performer.Add(searchTerm.Value.Trim());

                    // For now, we aren't setting the performer display any differently than performer
                    if (returnValue.PerformerDisplay == null)
                    {
                        returnValue.PerformerDisplay = new List <string>();
                    }
                    returnValue.PerformerDisplay.Add(searchTerm.Value.Trim());
                    break;

                case "etd committee":
                    if (returnValue.EtdCommittee == null)
                    {
                        returnValue.EtdCommittee = new List <string>();
                    }
                    returnValue.EtdCommittee.Add(searchTerm.Value.Trim());
                    break;

                case "etd degree":
                    returnValue.EtdDegree = searchTerm.Value.Trim();
                    break;

                case "etd degree discipline":
                    returnValue.EtdDegreeDiscipline = searchTerm.Value.Trim();
                    break;

                case "etd degree division":
                    returnValue.EtdDegreeDivision = searchTerm.Value.Trim();
                    break;

                case "etd degree grantor":
                    returnValue.EtdDegreeGrantor = searchTerm.Value.Trim();
                    break;

                case "etd degree level":
                    returnValue.EtdDegreeLevel = searchTerm.Value.Trim();
                    break;

                case "zt kingdom":
                    if (returnValue.ZoologicalKingdom == null)
                    {
                        returnValue.ZoologicalKingdom = new List <string>();
                    }
                    returnValue.ZoologicalKingdom.Add(searchTerm.Value.Trim());
                    break;

                case "zt phylum":
                    if (returnValue.ZoologicalPhylum == null)
                    {
                        returnValue.ZoologicalPhylum = new List <string>();
                    }
                    returnValue.ZoologicalPhylum.Add(searchTerm.Value.Trim());
                    break;

                case "zt class":
                    if (returnValue.ZoologicalClass == null)
                    {
                        returnValue.ZoologicalClass = new List <string>();
                    }
                    returnValue.ZoologicalClass.Add(searchTerm.Value.Trim());
                    break;

                case "zt order":
                    if (returnValue.ZoologicalOrder == null)
                    {
                        returnValue.ZoologicalOrder = new List <string>();
                    }
                    returnValue.ZoologicalOrder.Add(searchTerm.Value.Trim());
                    break;

                case "zt family":
                    if (returnValue.ZoologicalFamily == null)
                    {
                        returnValue.ZoologicalFamily = new List <string>();
                    }
                    returnValue.ZoologicalFamily.Add(searchTerm.Value.Trim());
                    break;

                case "zt genus":
                    if (returnValue.ZoologicalGenus == null)
                    {
                        returnValue.ZoologicalGenus = new List <string>();
                    }
                    returnValue.ZoologicalGenus.Add(searchTerm.Value.Trim());
                    break;

                case "zt species":
                    if (returnValue.ZoologicalSpecies == null)
                    {
                        returnValue.ZoologicalSpecies = new List <string>();
                    }
                    returnValue.ZoologicalSpecies.Add(searchTerm.Value.Trim());
                    break;

                case "zt common name":
                    if (returnValue.ZoologicalCommonName == null)
                    {
                        returnValue.ZoologicalCommonName = new List <string>();
                    }
                    returnValue.ZoologicalCommonName.Add(searchTerm.Value.Trim());
                    break;

                case "zt scientific name":
                    if (returnValue.ZoologicalScientificName == null)
                    {
                        returnValue.ZoologicalScientificName = new List <string>();
                    }
                    returnValue.ZoologicalScientificName.Add(searchTerm.Value.Trim());
                    break;

                case "zt hierarchical":
                    if (returnValue.ZoologicalHierarchical == null)
                    {
                        returnValue.ZoologicalHierarchical = new List <string>();
                    }
                    returnValue.ZoologicalHierarchical.Add(searchTerm.Value.Trim());
                    break;

                // Solr already rolls up to a zt_all field, so ignore this
                case "zt all taxonomy":
                    break;

                case "lom aggregation":
                    returnValue.LomAggregation = searchTerm.Value.Trim();
                    break;

                case "lom context":
                    if (returnValue.LomContext == null)
                    {
                        returnValue.LomContext = new List <string>();
                    }
                    returnValue.LomContext.Add(searchTerm.Value.Trim());
                    break;

                case "lom context display":
                    if (returnValue.LomContextDisplay == null)
                    {
                        returnValue.LomContextDisplay = new List <string>();
                    }
                    returnValue.LomContextDisplay.Add(searchTerm.Value.Trim());
                    break;

                case "lom difficulty":
                    returnValue.LomDifficulty = searchTerm.Value.Trim();
                    break;

                case "lom intended end user":
                    if (returnValue.LomIntendedEndUser == null)
                    {
                        returnValue.LomIntendedEndUser = new List <string>();
                    }
                    returnValue.LomIntendedEndUser.Add(searchTerm.Value.Trim());
                    break;

                case "lom intended end user display":
                    returnValue.LomIntendedEndUserDisplay = searchTerm.Value.Trim();
                    break;

                case "lom interactivity level":
                    returnValue.LomInteractivityLevel = searchTerm.Value.Trim();
                    break;

                case "lom interactivity type":
                    returnValue.LomInteractivityType = searchTerm.Value.Trim();
                    break;

                case "lom status":
                    returnValue.LomStatus = searchTerm.Value.Trim();
                    break;

                case "lom requirement":
                    if (returnValue.LomRequirement == null)
                    {
                        returnValue.LomRequirement = new List <string>();
                    }
                    returnValue.LomRequirement.Add(searchTerm.Value.Trim());
                    break;

                case "lom requirement display":
                    if (returnValue.LomRequirementDisplay == null)
                    {
                        returnValue.LomRequirementDisplay = new List <string>();
                    }
                    returnValue.LomRequirementDisplay.Add(searchTerm.Value.Trim());
                    break;

                case "lom age range":
                    if (returnValue.LomAgeRange == null)
                    {
                        returnValue.LomAgeRange = new List <string>();
                    }
                    returnValue.LomAgeRange.Add(searchTerm.Value.Trim());
                    break;

                case "lom resource type":
                    if (returnValue.LomResourceType == null)
                    {
                        returnValue.LomResourceType = new List <string>();
                    }
                    returnValue.LomResourceType.Add(searchTerm.Value.Trim());
                    break;

                case "lom resource type display":
                    if (returnValue.LomResourceTypeDisplay == null)
                    {
                        returnValue.LomResourceTypeDisplay = new List <string>();
                    }
                    returnValue.LomResourceTypeDisplay.Add(searchTerm.Value.Trim());
                    break;

                case "lom learning time":
                    returnValue.LomLearningTime = searchTerm.Value.Trim();
                    break;

                case "temporal subject":
                    returnValue.TemporalSubject = searchTerm.Value.Trim();
                    break;

                case "temporal subject display":
                    returnValue.TemporalSubjectDisplay = searchTerm.Value.Trim();
                    break;


                // Not handled yet
                case "temporal year":
                case "ead name":
                    break;


                // Ignore these
                case "bibid":
                case "vid":
                    break;

                // Some more to ignore, since these are handled differently in solr
                case "all subjects":
                case "aggregation":
                    break;

                default:
                    StreamWriter writer = new StreamWriter("missing_fields.txt", true);
                    writer.WriteLine(searchTerm.Key);
                    writer.Flush();
                    writer.Close();
                    break;
                }
            }

            // Find the Gregorian date issues value
            string pub_date = Digital_Object.Bib_Info.Origin_Info.Date_Check_All_Fields;

            returnValue.Date        = pub_date;
            returnValue.DateDisplay = pub_date;
            DateTime gregDate;

            if (DateTime.TryParse(pub_date, out gregDate))
            {
                returnValue.Date          = returnValue.Date + " (Date Auto-Converted to " + gregDate.ToShortDateString() + ")";
                returnValue.GregorianDate = gregDate;
                returnValue.DateYear      = gregDate.Year.ToString();

                // For now (since temporal subject isn't the best) just use this date for the timeline
                returnValue.TimelineDate        = gregDate;
                returnValue.TimelineDateDisplay = pub_date;
            }
            else
            {
                int year_only;
                if ((pub_date.Length == 4) && (int.TryParse(pub_date, out year_only)))
                {
                    gregDate         = new DateTime(year_only, 1, 1);
                    returnValue.Date = returnValue.Date = returnValue.Date + " (Date Converted to " + gregDate.ToShortDateString() + ")";


                    returnValue.GregorianDate = gregDate;
                    returnValue.DateYear      = gregDate.Year.ToString();

                    // For now (since temporal subject isn't the best) just use this date for the timeline
                    returnValue.TimelineDate        = gregDate;
                    returnValue.TimelineDateDisplay = pub_date;
                }
                else
                {
                    returnValue.Date = returnValue.Date + " (Date NOT Converted)";
                }
            }


            //// Subject metadata fields ( and also same spatial information )
            //List<string> spatials = new List<string>();
            //List<Subject_Info_HierarchicalGeographic> hierarhicals = new List<Subject_Info_HierarchicalGeographic>();
            //if ( Digital_Object.Bib_Info.Subjects_Count > 0 )
            //{
            //    List<string> subjects = new List<string>();
            //    List<string> name_as_subject = new List<string>();
            //    List<string> title_as_subject = new List<string>();

            //    // Collect the types of subjects
            //    foreach (Subject_Info thisSubject in Digital_Object.Bib_Info.Subjects)
            //    {
            //        switch (thisSubject.Class_Type)
            //        {
            //            case Subject_Info_Type.Name:
            //                name_as_subject.Add(thisSubject.ToString());
            //                break;

            //             case Subject_Info_Type.TitleInfo:
            //                title_as_subject.Add(thisSubject.ToString());
            //                break;

            //             case Subject_Info_Type.Standard:
            //                subjects.Add(thisSubject.ToString());
            //                Subject_Info_Standard standardSubj = thisSubject as Subject_Info_Standard;
            //                if (standardSubj.Geographics_Count > 0)
            //                {
            //                    spatials.AddRange(standardSubj.Geographics);
            //                }
            //                break;

            //            case Subject_Info_Type.Hierarchical_Spatial:
            //                hierarhicals.Add( thisSubject as Subject_Info_HierarchicalGeographic);
            //                break;
            //        }
            //    }

            //    // Now add to this document, if present
            //    if (name_as_subject.Count > 0)
            //    {
            //        NameAsSubject = new List<string>();
            //        NameAsSubject.AddRange(name_as_subject);
            //    }
            //    if (title_as_subject.Count > 0)
            //    {
            //        TitleAsSubject = new List<string>();
            //        TitleAsSubject.AddRange(title_as_subject);
            //    }
            //    if (subjects.Count > 0)
            //    {
            //        Subject = new List<string>();
            //        Subject.AddRange(subjects);
            //    }
            //}



            // Add the empty solr pages for now
            returnValue.Solr_Pages = new List <Legacy_SolrPage>();

            // Prepare to step through all the divisions/pages in this item
            int pageorder = 1;
            List <abstract_TreeNode> divsAndPages = Digital_Object.Divisions.Physical_Tree.Divisions_PreOrder;

            // Get the list of all TXT files in this division
            string[] text_files = Directory.GetFiles(File_Location, "*.txt");
            Dictionary <string, string> text_files_existing = new Dictionary <string, string>();

            foreach (string thisTextFile in text_files)
            {
                string filename = (new FileInfo(thisTextFile)).Name.ToUpper();
                text_files_existing[filename] = filename;
            }

            // Get the list of all THM.JPG files in this division
            string[] thumbnail_files = Directory.GetFiles(File_Location, "*thm.jpg");
            Dictionary <string, string> thumbnail_files_existing = new Dictionary <string, string>();

            foreach (string thisTextFile in thumbnail_files)
            {
                string filename = (new FileInfo(thisTextFile)).Name;
                thumbnail_files_existing[filename.ToUpper().Replace("THM.JPG", "")] = filename;
            }

            // Step through all division nodes from the physical tree here
            List <string> text_files_included = new List <string>();

            foreach (abstract_TreeNode thisNode in divsAndPages)
            {
                if (thisNode.Page)
                {
                    // Cast to a page to continnue
                    Page_TreeNode pageNode = (Page_TreeNode)thisNode;

                    // Look for the root filename and then look for a matching TEXT file
                    if (pageNode.Files.Count > 0)
                    {
                        string root = pageNode.Files[0].File_Name_Sans_Extension;
                        if (text_files_existing.ContainsKey(root.ToUpper() + ".TXT"))
                        {
                            try
                            {
                                // SInce this is marked to be included, save this name
                                text_files_included.Add(root.ToUpper() + ".TXT");

                                // Read the page text
                                StreamReader reader   = new StreamReader(File_Location + "\\" + root + ".txt");
                                string       pageText = reader.ReadToEnd().Trim();
                                reader.Close();

                                // Look for a matching thumbnail
                                string thumbnail = String.Empty;
                                if (thumbnail_files_existing.ContainsKey(root.ToUpper()))
                                {
                                    thumbnail = thumbnail_files_existing[root.ToUpper()];
                                }

                                Legacy_SolrPage newPage = new Legacy_SolrPage(Digital_Object.BibID, Digital_Object.VID, pageorder, pageNode.Label, pageText, thumbnail);
                                returnValue.Solr_Pages.Add(newPage);
                            }
                            catch
                            {
                            }
                        }
                    }

                    // Increment the page order for the next page irregardless
                    pageorder++;
                }
            }

            // Now, check for any other valid text files
            returnValue.AdditionalTextFiles = new List <string>();
            foreach (string thisTextFile in text_files_existing.Keys)
            {
                if ((!text_files_included.Contains(thisTextFile.ToUpper())) && (thisTextFile.ToUpper() != "AGREEMENT.TXT") && (thisTextFile.ToUpper().IndexOf("REQUEST") != 0))
                {
                    returnValue.AdditionalTextFiles.Add(thisTextFile);
                }
            }

            return(returnValue);
        }