Reads the container list and grabs the entire description section from an EAD file into an existing item for display within SobekCM
Inheritance: iMetadata_File_ReaderWriter
        private void Finish_Building_Item(SobekCM_Item Package_To_Finalize, DataSet DatabaseInfo, bool Multiple, List<string> Item_Viewer_Priority, Custom_Tracer Tracer )
        {
            Tracer.Add_Trace("SobekCM_METS_Based_ItemBuilder.Finish_Building_Item", "Load the data from the database into the resource object");

            if ((DatabaseInfo == null) || (DatabaseInfo.Tables[2] == null) || (DatabaseInfo.Tables[2].Rows.Count == 0))
            {
                Tracer.Add_Trace("SobekCM_METS_Based_ItemBuilder.Finish_Building_Item", "Invalid data from the database, either not enough tables, or no rows in Tables[2]");
            }
            else
            {
                // Copy over some basic values
                DataRow mainItemRow = DatabaseInfo.Tables[2].Rows[0];
                Package_To_Finalize.Behaviors.Set_Primary_Identifier(mainItemRow["Primary_Identifier_Type"].ToString(), mainItemRow["Primary_Identifier"].ToString());
                Package_To_Finalize.Behaviors.GroupTitle = mainItemRow["GroupTitle"].ToString();
                Package_To_Finalize.Behaviors.GroupType = mainItemRow["GroupType"].ToString();
                Package_To_Finalize.Web.File_Root = mainItemRow["File_Location"].ToString();
                Package_To_Finalize.Web.AssocFilePath = mainItemRow["File_Location"] + "\\" + Package_To_Finalize.VID + "\\";
                Package_To_Finalize.Behaviors.IP_Restriction_Membership = Convert.ToInt16(mainItemRow["IP_Restriction_Mask"]);
                Package_To_Finalize.Behaviors.CheckOut_Required = Convert.ToBoolean(mainItemRow["CheckoutRequired"]);
                Package_To_Finalize.Behaviors.Text_Searchable = Convert.ToBoolean(mainItemRow["TextSearchable"]);
                Package_To_Finalize.Web.ItemID = Convert.ToInt32(mainItemRow["ItemID"]);
                Package_To_Finalize.Web.GroupID = Convert.ToInt32(mainItemRow["GroupID"]);
                Package_To_Finalize.Behaviors.Suppress_Endeca = Convert.ToBoolean(mainItemRow["SuppressEndeca"]);
                //Package_To_Finalize.Behaviors.Expose_Full_Text_For_Harvesting = Convert.ToBoolean(mainItemRow["SuppressEndeca"]);
                Package_To_Finalize.Tracking.Internal_Comments = mainItemRow["Comments"].ToString();
                Package_To_Finalize.Behaviors.Dark_Flag = Convert.ToBoolean(mainItemRow["Dark"]);
                Package_To_Finalize.Tracking.Born_Digital = Convert.ToBoolean(mainItemRow["Born_Digital"]);
                Package_To_Finalize.Behaviors.Main_Thumbnail = mainItemRow["MainThumbnail"].ToString();
                //Package_To_Finalize.Divisions.Page_Count = Convert.ToInt32(mainItemRow["Pages"]);
                if (mainItemRow["Disposition_Advice"] != DBNull.Value)
                    Package_To_Finalize.Tracking.Disposition_Advice = Convert.ToInt16(mainItemRow["Disposition_Advice"]);
                else
                    Package_To_Finalize.Tracking.Disposition_Advice = -1;
                if (mainItemRow["Material_Received_Date"] != DBNull.Value)
                    Package_To_Finalize.Tracking.Material_Received_Date = Convert.ToDateTime(mainItemRow["Material_Received_Date"]);
                else
                    Package_To_Finalize.Tracking.Material_Received_Date = null;
                if (mainItemRow["Material_Recd_Date_Estimated"] != DBNull.Value)
                    Package_To_Finalize.Tracking.Material_Rec_Date_Estimated = Convert.ToBoolean(mainItemRow["Material_Recd_Date_Estimated"]);
                if (DatabaseInfo.Tables[2].Columns.Contains("Tracking_Box"))
                {
                    if (mainItemRow["Tracking_Box"] != DBNull.Value)
                        Package_To_Finalize.Tracking.Tracking_Box = mainItemRow["Tracking_Box"].ToString();
                }

                // Set more of the sobekcm web portions in the item
                Package_To_Finalize.Web.Set_BibID_VID(Package_To_Finalize.BibID, Package_To_Finalize.VID);
                Package_To_Finalize.Web.Image_Root = Engine_ApplicationCache_Gateway.Settings.Servers.Image_URL;
                if (Multiple)
                    Package_To_Finalize.Web.Siblings = 2;

                // Set the serial hierarchy from the database (if multiple)
                if ((Multiple) && (mainItemRow["Level1_Text"].ToString().Length > 0))
                {
                    Tracer.Add_Trace("SobekCM_METS_Based_ItemBuilder.Finish_Building_Item", "Assigning serial hierarchy from the database info");

                    bool found = false;

                    // Get the values from the database first
                    string level1_text = mainItemRow["Level1_Text"].ToString();
                    string level2_text = mainItemRow["Level2_Text"].ToString();
                    string level3_text = mainItemRow["Level3_Text"].ToString();
                    int level1_index = Convert.ToInt32(mainItemRow["Level1_Index"]);
                    int level2_index = Convert.ToInt32(mainItemRow["Level2_Index"]);
                    int level3_index = Convert.ToInt32(mainItemRow["Level3_Index"]);

                    // Does this match the enumeration
                    if (level1_text.ToUpper().Trim() == Package_To_Finalize.Bib_Info.Series_Part_Info.Enum1.ToUpper().Trim())
                    {
                        // Copy the database values to the enumeration portion
                        Package_To_Finalize.Bib_Info.Series_Part_Info.Enum1 = level1_text;
                        Package_To_Finalize.Bib_Info.Series_Part_Info.Enum1_Index = level1_index;
                        Package_To_Finalize.Bib_Info.Series_Part_Info.Enum2 = level2_text;
                        Package_To_Finalize.Bib_Info.Series_Part_Info.Enum2_Index = level2_index;
                        Package_To_Finalize.Bib_Info.Series_Part_Info.Enum3 = level3_text;
                        Package_To_Finalize.Bib_Info.Series_Part_Info.Enum3_Index = level3_index;
                        found = true;
                    }

                    // Does this match the chronology
                    if ((!found) && (level1_text.ToUpper().Trim() == Package_To_Finalize.Bib_Info.Series_Part_Info.Year.ToUpper().Trim()))
                    {
                        // Copy the database values to the chronology portion
                        Package_To_Finalize.Bib_Info.Series_Part_Info.Year = level1_text;
                        Package_To_Finalize.Bib_Info.Series_Part_Info.Year_Index = level1_index;
                        Package_To_Finalize.Bib_Info.Series_Part_Info.Month = level2_text;
                        Package_To_Finalize.Bib_Info.Series_Part_Info.Month_Index = level2_index;
                        Package_To_Finalize.Bib_Info.Series_Part_Info.Day = level3_text;
                        Package_To_Finalize.Bib_Info.Series_Part_Info.Day_Index = level3_index;
                        found = true;
                    }

                    if (!found)
                    {
                        // No match.  If it is numeric, move it to the chronology, otherwise, enumeration
                        bool charFound = level1_text.Trim().Any(ThisChar => !Char.IsNumber(ThisChar));

                        if (charFound)
                        {
                            // Copy the database values to the enumeration portion
                            Package_To_Finalize.Bib_Info.Series_Part_Info.Enum1 = level1_text;
                            Package_To_Finalize.Bib_Info.Series_Part_Info.Enum1_Index = level1_index;
                            Package_To_Finalize.Bib_Info.Series_Part_Info.Enum2 = level2_text;
                            Package_To_Finalize.Bib_Info.Series_Part_Info.Enum2_Index = level2_index;
                            Package_To_Finalize.Bib_Info.Series_Part_Info.Enum3 = level3_text;
                            Package_To_Finalize.Bib_Info.Series_Part_Info.Enum3_Index = level3_index;
                        }
                        else
                        {
                            // Copy the database values to the chronology portion
                            Package_To_Finalize.Bib_Info.Series_Part_Info.Year = level1_text;
                            Package_To_Finalize.Bib_Info.Series_Part_Info.Year_Index = level1_index;
                            Package_To_Finalize.Bib_Info.Series_Part_Info.Month = level2_text;
                            Package_To_Finalize.Bib_Info.Series_Part_Info.Month_Index = level2_index;
                            Package_To_Finalize.Bib_Info.Series_Part_Info.Day = level3_text;
                            Package_To_Finalize.Bib_Info.Series_Part_Info.Day_Index = level3_index;
                        }
                    }

                    // Copy the database values to the simple serial portion (used to actually determine serial heirarchy)
                    Package_To_Finalize.Behaviors.Serial_Info.Clear();
                    Package_To_Finalize.Behaviors.Serial_Info.Add_Hierarchy(1, level1_index, level1_text);
                    if (level2_text.Length > 0)
                    {
                        Package_To_Finalize.Behaviors.Serial_Info.Add_Hierarchy(2, level2_index, level2_text);
                        if (level3_text.Length > 0)
                        {
                            Package_To_Finalize.Behaviors.Serial_Info.Add_Hierarchy(3, level3_index, level3_text);
                        }
                    }
                }

                // See if this can be described
                bool can_describe = false;
                foreach (DataRow thisRow in DatabaseInfo.Tables[1].Rows)
                {
                    int thisAggregationValue = Convert.ToInt16(thisRow["Items_Can_Be_Described"]);
                    if (thisAggregationValue == 0)
                    {
                        can_describe = false;
                        break;
                    }
                    if (thisAggregationValue == 2)
                    {
                        can_describe = true;
                    }
                }
                Package_To_Finalize.Behaviors.Can_Be_Described = can_describe;

                // Look for rights information to add
                if (mainItemRow["EmbargoEnd"] != DBNull.Value)
                {
                    try
                    {
                        DateTime embargoEnd = DateTime.Parse(mainItemRow["EmbargoEnd"].ToString());
                        string origAccessCode = mainItemRow["Original_AccessCode"].ToString();

                        // Is there already a RightsMD module in the item?
                        // Ensure this metadata module extension exists
                        RightsMD_Info rightsInfo = Package_To_Finalize.Get_Metadata_Module(GlobalVar.PALMM_RIGHTSMD_METADATA_MODULE_KEY) as RightsMD_Info;
                        if (rightsInfo == null)
                        {
                            rightsInfo = new RightsMD_Info();
                            Package_To_Finalize.Add_Metadata_Module(GlobalVar.PALMM_RIGHTSMD_METADATA_MODULE_KEY, rightsInfo);
                        }

                        // Add the data
                        rightsInfo.Access_Code_String = origAccessCode;
                        rightsInfo.Embargo_End = embargoEnd;
                    }
                    catch (Exception)
                    {

                    }
                }
            }

            // Look for user descriptions
            Tracer.Add_Trace("SobekCM_METS_Based_ItemBuilder.Finish_Building_Item", "Look for user descriptions (or tags)");
            foreach (DataRow thisRow in DatabaseInfo.Tables[0].Rows)
            {
                string first_name = thisRow["FirstName"].ToString();
                string nick_name = thisRow["NickName"].ToString();
                string last_name = thisRow["LastName"].ToString();
                int userid = Convert.ToInt32(thisRow["UserID"]);
                string tag = thisRow["Description_Tag"].ToString();
                int tagid = Convert.ToInt32(thisRow["TagID"]);
                DateTime dateAdded = Convert.ToDateTime(thisRow["Date_Modified"]);

                if (nick_name.Length > 0)
                {
                    Package_To_Finalize.Behaviors.Add_User_Tag(userid, nick_name + " " + last_name, tag, dateAdded, tagid);
                }
                else
                {
                    Package_To_Finalize.Behaviors.Add_User_Tag(userid, first_name + " " + last_name, tag, dateAdded, tagid);
                }
            }

            // Look for ticklers
            Tracer.Add_Trace("SobekCM_METS_Based_ItemBuilder.Finish_Building_Item", "Load ticklers from the database info");
            foreach (DataRow thisRow in DatabaseInfo.Tables[3].Rows)
            {
                Package_To_Finalize.Behaviors.Add_Tickler(thisRow["MetadataValue"].ToString().Trim());
            }

            // Set the aggregationPermissions in the package to the aggregation links from the database
            Tracer.Add_Trace("SobekCM_METS_Based_ItemBuilder.Finish_Building_Item", "Load the aggregations from the database info");
            Package_To_Finalize.Behaviors.Clear_Aggregations();
            foreach (DataRow thisRow in DatabaseInfo.Tables[1].Rows)
            {
                if (!Convert.ToBoolean(thisRow["impliedLink"]))
                {
                    string code = thisRow["Code"].ToString();
                    if (String.Compare(code, "all", StringComparison.OrdinalIgnoreCase) != 0)
                    {
                        Package_To_Finalize.Behaviors.Add_Aggregation(code, thisRow["Name"].ToString(), thisRow["Type"].ToString());
                    }
                }
            }

            // If no collections, add some regardless of whether it was IMPLIED
            if ( Package_To_Finalize.Behaviors.Aggregation_Count == 0)
            {
                foreach (DataRow thisRow in DatabaseInfo.Tables[1].Rows)
                {
                    string code = thisRow["Code"].ToString();
                    if (String.Compare(code, "all", StringComparison.OrdinalIgnoreCase) != 0)
                    {
                        Package_To_Finalize.Behaviors.Add_Aggregation(code, thisRow["Name"].ToString(), thisRow["Type"].ToString());
                    }
                }
            }

            // Step through each page and set the static page count
            Tracer.Add_Trace("SobekCM_METS_Based_ItemBuilder.Finish_Building_Item", "Set the static page count");

            pageseq = 0;
            List<Page_TreeNode> pages_encountered = new List<Page_TreeNode>();
            if (!Package_To_Finalize.Behaviors.Dark_Flag)
            {
                foreach (abstract_TreeNode rootNode in Package_To_Finalize.Divisions.Physical_Tree.Roots)
                {
                    recurse_through_nodes(Package_To_Finalize, rootNode, pages_encountered);
                }
            }
            Package_To_Finalize.Web.Static_PageCount = pages_encountered.Count;
            Package_To_Finalize.Web.Static_Division_Count = divseq;

            // Make sure no icons were retained from the METS file itself
            Tracer.Add_Trace("SobekCM_METS_Based_ItemBuilder.Finish_Building_Item", "Load the wordmarks/icons from the database info");
            Package_To_Finalize.Behaviors.Clear_Wordmarks();

            // Add the icons from the database information
            foreach (DataRow iconRow in DatabaseInfo.Tables[5].Rows)
            {
                string image = iconRow[0].ToString();
                string link = iconRow[1].ToString().Replace("&", "&amp;").Replace("\"", "&quot;");
                string code = iconRow[2].ToString();
                string name = iconRow[3].ToString();
                if ( name.Length == 0 )
                    name = code.Replace("&", "&amp;").Replace("\"", "&quot;");

                string html;
                if (link.Length == 0)
                {
                    html = "<img class=\"SobekItemWordmark\" src=\"<%BASEURL%>design/wordmarks/" + image + "\" title=\"" + name + "\" alt=\"" + name + "\" />";
                }
                else
                {
                    if (link[0] == '?')
                    {
                        html = "<a href=\"" + link + "\"><img class=\"SobekItemWordmark\" src=\"<%BASEURL%>design/wordmarks/" + image + "\" alt=\"" + name + "\" /></a>";
                    }
                    else
                    {
                        html = "<a href=\"" + link + "\" target=\"_blank\"><img class=\"SobekItemWordmark\" src=\"<%BASEURL%>design/wordmarks/" + image + "\" alt=\"" + name + "\" /></a>";
                    }
                }

                Wordmark_Info newIcon = new Wordmark_Info {HTML = html, Link = link, Title = name, Code = code};
                Package_To_Finalize.Behaviors.Add_Wordmark(newIcon);
            }

            // Make sure no web skins were retained from the METS file itself
            Tracer.Add_Trace("SobekCM_METS_Based_ItemBuilder.Finish_Building_Item", "Load the web skins from the database info");
            Package_To_Finalize.Behaviors.Clear_Web_Skins();

            // Add the web skins from the database
            foreach (DataRow skinRow in DatabaseInfo.Tables[6].Rows)
            {
                Package_To_Finalize.Behaviors.Add_Web_Skin(skinRow[0].ToString().ToUpper());
            }

            Tracer.Add_Trace("SobekCM_METS_Based_ItemBuilder.Finish_Building_Item", "Set the views from a combination of the METS and the database info");

            // Make sure no views were retained from the METS file itself
            Package_To_Finalize.Behaviors.Clear_Views();
            Package_To_Finalize.Behaviors.Clear_Item_Level_Page_Views();

            // If this has more than 1 sibling (this count includes itself), add the multi-volumes viewer
            if (Multiple)
            {
                Package_To_Finalize.Behaviors.Add_View(View_Enum.ALL_VOLUMES, String.Empty, Package_To_Finalize.Bib_Info.SobekCM_Type_String);
            }

            // Add the full citation view and the (hidden) tracking view and some other ALWAYS views
            Package_To_Finalize.Behaviors.Add_View(View_Enum.CITATION);
            Package_To_Finalize.Behaviors.Add_View(View_Enum.TRACKING);
            Package_To_Finalize.Behaviors.Add_View(View_Enum.TRACKING_SHEET);
            Package_To_Finalize.Behaviors.Add_View(View_Enum.GOOGLE_COORDINATE_ENTRY);
            Package_To_Finalize.Behaviors.Add_View(View_Enum.TEST);
            Package_To_Finalize.Behaviors.Add_View(View_Enum.MANAGE);

            // Add the full text searchable
            if ( Package_To_Finalize.Behaviors.Text_Searchable )
                Package_To_Finalize.Behaviors.Add_View(View_Enum.SEARCH);

            // Is there an embedded video?
            if (Package_To_Finalize.Behaviors.Embedded_Video.Length > 0)
                Package_To_Finalize.Behaviors.Add_View(View_Enum.EMBEDDED_VIDEO);

            // If there is no PURL, add one based on how SobekCM operates
            if (Package_To_Finalize.Bib_Info.Location.PURL.Length == 0)
            {
                Package_To_Finalize.Bib_Info.Location.PURL = Engine_ApplicationCache_Gateway.Settings.Servers.System_Base_URL + Package_To_Finalize.BibID + "/" + Package_To_Finalize.VID;

            }

            // If this is a newspaper, and there is no datecreated, see if we
            // can make one from the  serial hierarchy
            if (Package_To_Finalize.Behaviors.GroupType.ToUpper() == "NEWSPAPER")
            {
                if ((Package_To_Finalize.Bib_Info.Origin_Info.Date_Created.Length == 0) && (Package_To_Finalize.Bib_Info.Origin_Info.Date_Issued.Length == 0))
                {
                    // Is the serial hierarchy three deep?
                    if (Package_To_Finalize.Behaviors.hasSerialInformation)
                    {
                        if (Package_To_Finalize.Behaviors.Serial_Info.Count == 3)
                        {
                            int year;

                            if (Int32.TryParse(Package_To_Finalize.Behaviors.Serial_Info[0].Display, out year))
                            {
                                int day;
                                if (Int32.TryParse(Package_To_Finalize.Behaviors.Serial_Info[2].Display, out day))
                                {
                                    if ((year > 0) && (year < DateTime.Now.Year + 2) && ( day > 0 ) && ( day <= 31 ))
                                    {
                                        // Is the month a number?
                                        int month;
                                        if (Int32.TryParse(Package_To_Finalize.Behaviors.Serial_Info[1].Display, out month))
                                        {
                                            try
                                            {
                                                // Do it this way since hopefully that will work for localization issues
                                                DateTime date = new DateTime(year, month, day);
                                                Package_To_Finalize.Bib_Info.Origin_Info.Date_Created = date.ToShortDateString();
                                            }
                                            catch
                                            {
                                                // If this is an invalid date, catch the error and do nothing
                                            }
                                        }
                                        else
                                        {
                                            Package_To_Finalize.Bib_Info.Origin_Info.Date_Created = Package_To_Finalize.Behaviors.Serial_Info[1].Display + " " + day + ", " + year;
                                        }
                                    }
                                }
                            }
                        }
                        else if ( Package_To_Finalize.Behaviors.Serial_Info.Count == 2 )
                        {
                            int year;
                            if (Int32.TryParse(Package_To_Finalize.Behaviors.Serial_Info[0].Display, out year))
                            {
                                if ((year > 0) && (year < DateTime.Now.Year + 2) && ( Package_To_Finalize.Behaviors.Serial_Info[1].Display.Length > 0 ))
                                {
                                    Package_To_Finalize.Bib_Info.Origin_Info.Date_Created = Package_To_Finalize.Behaviors.Serial_Info[1].Display + " " + year;
                                }
                            }
                        }
                    }
                }
            }

            // IF this is dark, add no other views
            if (Package_To_Finalize.Behaviors.Dark_Flag) return;

            // Check to see which views were present from the database, and build the list
            Dictionary<View_Enum, View_Object> viewsFromDb = new Dictionary<View_Enum, View_Object>();
            foreach (DataRow viewRow in DatabaseInfo.Tables[4].Rows)
            {
                string viewType = viewRow[0].ToString();
                string attribute = viewRow[1].ToString();
                string label = viewRow[2].ToString();

                View_Enum viewTypeEnum = View_Enum.None;
                switch (viewType)
                {
                    case "Dataset Codebook":
                        viewTypeEnum = View_Enum.DATASET_CODEBOOK;
                        break;

                    case "Dataset Reports":
                        viewTypeEnum = View_Enum.DATASET_REPORTS;
                        break;

                    case "Dataset View Data":
                        viewTypeEnum = View_Enum.DATASET_VIEWDATA;
                        break;

                    case "Google Map":
                        viewTypeEnum = View_Enum.GOOGLE_MAP;
                        break;

                    case "Google Map Beta":
                        viewTypeEnum = View_Enum.GOOGLE_MAP_BETA;
                        break;

                    case "HTML Viewer":
                        viewTypeEnum = View_Enum.HTML;
                        break;

                    case "JPEG":
                        viewTypeEnum = View_Enum.JPEG;
                        break;

                    case "JPEG/Text Two Up":
                        viewTypeEnum = View_Enum.JPEG_TEXT_TWO_UP;
                        break;

                    case "JPEG2000":
                        viewTypeEnum = View_Enum.JPEG2000;
                        break;

                    case "Page Turner":
                        viewTypeEnum = View_Enum.PAGE_TURNER;
                        break;

                    case "Related Images":
                        viewTypeEnum = View_Enum.RELATED_IMAGES;
                        break;

                    case "TEI":
                        viewTypeEnum = View_Enum.TEI;
                        break;

                    case "Text":
                        viewTypeEnum = View_Enum.TEXT;
                        break;

                    case "TOC":
                        viewTypeEnum = View_Enum.TOC;
                        break;
                }

                if (viewTypeEnum != View_Enum.None)
                {
                    viewsFromDb[viewTypeEnum] = new View_Object(viewTypeEnum, label, attribute);
                }
            }

            // Add the dataset views (later we should do some checking here, but for
            // now just add them if the user selected them.
            if (viewsFromDb.ContainsKey(View_Enum.DATASET_VIEWDATA))
            {
                Package_To_Finalize.Behaviors.Add_View(viewsFromDb[View_Enum.DATASET_VIEWDATA]);
                viewsFromDb.Remove(View_Enum.DATASET_VIEWDATA);
            }
            if (viewsFromDb.ContainsKey(View_Enum.DATASET_CODEBOOK))
            {
                Package_To_Finalize.Behaviors.Add_View(viewsFromDb[View_Enum.DATASET_CODEBOOK]);
                viewsFromDb.Remove(View_Enum.DATASET_CODEBOOK);
            }
            if (viewsFromDb.ContainsKey(View_Enum.DATASET_REPORTS))
            {
                Package_To_Finalize.Behaviors.Add_View(viewsFromDb[View_Enum.DATASET_REPORTS]);
                viewsFromDb.Remove(View_Enum.DATASET_REPORTS);
            }

            // Add the thumbnail view, if requested and has multiple pages
            if (Package_To_Finalize.Divisions.Page_Count > 1)
            {
                if (viewsFromDb.ContainsKey(View_Enum.RELATED_IMAGES))
                {
                    Package_To_Finalize.Behaviors.Add_View(viewsFromDb[View_Enum.RELATED_IMAGES]);
                    viewsFromDb.Remove(View_Enum.RELATED_IMAGES);
                }
            }
            else
            {
                if (viewsFromDb.ContainsKey(View_Enum.RELATED_IMAGES))
                {
                    viewsFromDb.Remove(View_Enum.RELATED_IMAGES);
                }
            }

            // Always add the QC viewer ( the QC viewer will redirect to upload files if there are NO pages)
            Package_To_Finalize.Behaviors.Add_View(View_Enum.QUALITY_CONTROL);

            // If this item has more than one division, look for the TOC viewer
            if ((Package_To_Finalize.Divisions.Has_Multiple_Divisions) && (!Package_To_Finalize.Bib_Info.ImageClass))
            {
                if (viewsFromDb.ContainsKey(View_Enum.TOC))
                {
                    Package_To_Finalize.Behaviors.Add_View(viewsFromDb[View_Enum.TOC]);
                    viewsFromDb.Remove(View_Enum.TOC);
                }
            }

            // In addition, if there is a latitude or longitude listed, look for the Google Maps
            bool hasCoords = false;
            GeoSpatial_Information geoInfo = (GeoSpatial_Information) Package_To_Finalize.Get_Metadata_Module(GlobalVar.GEOSPATIAL_METADATA_MODULE_KEY);
            if (( geoInfo != null ) && ( geoInfo.hasData ))
            {
                if ((geoInfo.Point_Count > 0) || (geoInfo.Polygon_Count > 0))
                {
                    hasCoords = true;
                }
            }
            if (!hasCoords)
            {
                List<abstract_TreeNode> pageList = Package_To_Finalize.Divisions.Physical_Tree.Pages_PreOrder;
                if (pageList.Select(ThisPage => (GeoSpatial_Information) ThisPage.Get_Metadata_Module(GlobalVar.GEOSPATIAL_METADATA_MODULE_KEY)).Where(GeoInfo2 => (GeoInfo2 != null) && (GeoInfo2.hasData)).Any(GeoInfo2 => (GeoInfo2.Point_Count > 0) || (GeoInfo2.Polygon_Count > 0)))
                {
                    hasCoords = true;
                }
            }

            if (hasCoords)
            {
                if (viewsFromDb.ContainsKey(View_Enum.GOOGLE_MAP))
                {
                    Package_To_Finalize.Behaviors.Add_View(viewsFromDb[View_Enum.GOOGLE_MAP]);
                    viewsFromDb.Remove(View_Enum.GOOGLE_MAP);
                }
                else
                {
                    Package_To_Finalize.Behaviors.Add_View(View_Enum.GOOGLE_MAP);
                }
            }

            // Step through each download and make sure it is fully built
            if (( !Package_To_Finalize.Behaviors.Dark_Flag ) && ( Package_To_Finalize.Divisions.Download_Tree.Has_Files))
            {
                string ead_file = String.Empty;
                int pdf_download = 0;
                int video_download = 0;
                string pdf_download_url = String.Empty;
                List<abstract_TreeNode> downloadPages = Package_To_Finalize.Divisions.Download_Tree.Pages_PreOrder;
                string xsl = String.Empty;

                // Keep track of all the unhandled downloads, which will casue a DOWNLOAD tab to appear
                List<abstract_TreeNode> unhandledDownload = new List<abstract_TreeNode>();

                // Step through each download page
                foreach (Page_TreeNode downloadPage in downloadPages)
                {
                    bool download_handled = false;

                    // If this page has only a single file, might be handled by a single viewer
                    if ((!download_handled) && (downloadPage.Files.Count == 1))
                    {
                        string extension = downloadPage.Files[0].File_Extension;

                        // Was this an EAD page?
                        switch (extension)
                        {
                            case "XML":
                                if (downloadPage.Label == "EAD")
                                {
                                    Package_To_Finalize.Bib_Info.SobekCM_Type = TypeOfResource_SobekCM_Enum.EAD;
                                    ead_file = downloadPage.Files[0].System_Name;
                                    download_handled = true;
                                }
                                break;

                            case "SWF":
                                // FLASH files are always handled
                                string flashlabel = downloadPage.Label;
                                Package_To_Finalize.Behaviors.Add_View(View_Enum.FLASH, flashlabel, String.Empty, downloadPage.Files[0].System_Name);
                                download_handled = true;
                                break;

                            case "PDF":
                                pdf_download++;
                                if (pdf_download == 1)
                                {
                                    pdf_download_url = downloadPage.Files[0].System_Name;
                                    download_handled = true;
                                }
                                break;

                            case "XSL":
                                xsl = downloadPage.Files[0].System_Name;
                                download_handled = true;
                                break;

                            case "HTML":
                            case "HTM":
                                if (viewsFromDb.ContainsKey(View_Enum.HTML))
                                {
                                    if (String.Compare(viewsFromDb[View_Enum.HTML].Attributes, downloadPage.Files[0].System_Name, StringComparison.InvariantCultureIgnoreCase) == 0)
                                    {
                                        download_handled = true;
                                    }
                                }
                                break;

                            case "WEBM":
                            case "OGG":
                            case "MP4":
                            //case "AVI":
                            //case "WMV":
                            //case "MPG":
                            //case "MOV":
                            //case "FLV":
                            //case "VOB":
                            //case "WAV":
                            //case "OGM":
                            //case "MKV":
                                video_download++;
                                download_handled = true;
                                break;
                        }
                    }

                    // Check for video files
                    if ((!download_handled) && ( downloadPage.Files != null ))
                    {
                        foreach (SobekCM_File_Info thisFileInfo in downloadPage.Files)
                        {
                            string extension = thisFileInfo.File_Extension;

                            // Was this an EAD page?
                            switch (extension)
                            {
                                case "WEBM":
                                case "OGG":
                                case "MP4":
                                    //case "AVI":
                                    //case "WMV":
                                    //case "MPG":
                                    //case "MOV":
                                    //case "FLV":
                                    //case "VOB":
                                    //case "WAV":
                                    //case "OGM":
                                    //case "MKV":
                                    video_download++;
                                    download_handled = true;
                                    break;
                            }

                            if (download_handled)
                                break;
                        }
                    }

                    // Step through each download file
                    if (!download_handled)
                    {
                        unhandledDownload.Add(downloadPage);

                        foreach (SobekCM_File_Info thisFile in downloadPage.Files)
                        {
                            if (thisFile.File_Extension == "SWF")
                            {
                                string flashlabel = downloadPage.Label;
                                Package_To_Finalize.Behaviors.Add_View(View_Enum.FLASH, flashlabel, String.Empty, thisFile.System_Name);
                            }

                            if (thisFile.File_Extension == "PDF")
                            {
                                pdf_download++;
                                if (pdf_download == 1)
                                {
                                    pdf_download_url = thisFile.System_Name;
                                }
                            }

                        }
                    }
                }

                // Some special code for EAD objects
                if ((Package_To_Finalize.Bib_Info.SobekCM_Type == TypeOfResource_SobekCM_Enum.EAD) && (ead_file.Length > 0))
                {
                    // Now, read this EAD file information
                    string ead_file_location = Engine_ApplicationCache_Gateway.Settings.Servers.Image_Server_Network + Package_To_Finalize.Web.AssocFilePath + ead_file;
                    EAD_File_ReaderWriter reader = new EAD_File_ReaderWriter();
                    string errorMessage;
                    Dictionary<string, object> options = new Dictionary<string, object>();
                    options["EAD_File_ReaderWriter:XSL_Location"] = Engine_ApplicationCache_Gateway.Settings.Servers.System_Base_URL + "default/sobekcm_default.xsl";

                    reader.Read_Metadata(ead_file_location, Package_To_Finalize, options, out errorMessage);

                    // Clear all existing views
                    Package_To_Finalize.Behaviors.Add_View(View_Enum.EAD_DESCRIPTION);

                    // Get the metadata module for EADs
                    EAD_Info eadInfo = Package_To_Finalize.Get_Metadata_Module(GlobalVar.EAD_METADATA_MODULE_KEY) as EAD_Info;
                    if ((eadInfo != null) && (eadInfo.Container_Hierarchy.Containers.Count > 0))
                        Package_To_Finalize.Behaviors.Add_View(View_Enum.EAD_CONTAINER_LIST);

                }

                //string view_type_of = Package_To_Finalize.Behaviors.Views[0].GetType().ToString();
                //string ufdc_type_of = Package_To_Finalize.Behaviors.Views[0].View_Type.ToString();

                if (unhandledDownload.Count > 0 )
                {
                    Package_To_Finalize.Behaviors.Add_View(View_Enum.DOWNLOADS);
                }

                if (pdf_download == 1)
                {
                    Package_To_Finalize.Behaviors.Add_View(View_Enum.PDF).FileName = pdf_download_url;
                }

                if (video_download > 0)
                {
                    Package_To_Finalize.Behaviors.Add_View(View_Enum.VIDEO);
                }
            }
            else
            {
                if (Package_To_Finalize.Bib_Info.SobekCM_Type == TypeOfResource_SobekCM_Enum.Aerial )
                {
                    Package_To_Finalize.Behaviors.Add_View(View_Enum.DOWNLOADS);
                }
            }

            // If there is a RELATED URL with youtube, add that viewer
            if ((Package_To_Finalize.Bib_Info.hasLocationInformation) && (Package_To_Finalize.Bib_Info.Location.Other_URL.ToLower().IndexOf("www.youtube.com") >= 0))
            {
                View_Object newViewObj = new View_Object(View_Enum.YOUTUBE_VIDEO);
                Package_To_Finalize.Behaviors.Add_View(newViewObj);
            }

            // Look for the HTML type views next, and possible set some defaults
            if ((!Package_To_Finalize.Behaviors.Dark_Flag) && viewsFromDb.ContainsKey(View_Enum.HTML))
            {
                Package_To_Finalize.Behaviors.Add_View(viewsFromDb[View_Enum.HTML]);
                viewsFromDb.Remove(View_Enum.HTML);
            }

            // Copy the TEI flag
            if ((!Package_To_Finalize.Behaviors.Dark_Flag) && viewsFromDb.ContainsKey(View_Enum.TEI))
            {
                Package_To_Finalize.Behaviors.Add_View(viewsFromDb[View_Enum.TEI]);
                viewsFromDb.Remove(View_Enum.TEI);
            }

            // Look to add any index information here ( such as on SANBORN maps)
            Map_Info mapInfo = (Map_Info) Package_To_Finalize.Get_Metadata_Module(GlobalVar.SOBEKCM_MAPS_METADATA_MODULE_KEY);
            if (mapInfo != null)
            {
                //// Were there streets?
                //if (Package_To_Finalize.Map.Streets.Count > 0)
                //{
                //    returnValue.Item_Views.Add(new ViewerFetcher.Streets_ViewerFetcher());
                //}

                //// Were there features?
                //if (Package_To_Finalize.Map.Features.Count > 0)
                //{
                //    returnValue.Item_Views.Add(new ViewerFetcher.Features_ViewerFetcher());
                //}
            }

            // Finally, add all the ITEM VIEWS
            if ((!Package_To_Finalize.Behaviors.Dark_Flag) && (Package_To_Finalize.Web.Pages_By_Sequence != null) && (Package_To_Finalize.Web.Pages_By_Sequence.Count > 0))
            {
                // Look for the RELATED IMAGES view next
                if (viewsFromDb.ContainsKey(View_Enum.RELATED_IMAGES))
                {
                    Package_To_Finalize.Behaviors.Add_View(viewsFromDb[View_Enum.RELATED_IMAGES]);
                    viewsFromDb.Remove(View_Enum.RELATED_IMAGES);
                }

                // Look for the PAGE TURNER view next
                if (viewsFromDb.ContainsKey(View_Enum.PAGE_TURNER))
                {
                    Package_To_Finalize.Behaviors.Add_View(viewsFromDb[View_Enum.PAGE_TURNER]);
                    viewsFromDb.Remove(View_Enum.PAGE_TURNER);
                }

                // Add the individual PAGE VIEWS
                foreach (View_Object thisObject in viewsFromDb.Values)
                {
                    switch (thisObject.View_Type)
                    {
                        case View_Enum.TEXT:
                        case View_Enum.JPEG:
                        case View_Enum.JPEG2000:
                            Package_To_Finalize.Behaviors.Add_Item_Level_Page_View(thisObject);
                            break;
                    }
                }
            }

            // Set the default views for this item
            Tracer.Add_Trace("SobekCM_METS_Based_ItemBuilder.Finish_Building_Item", "Set the default view, if not already assigned");
            Package_To_Finalize.Behaviors.Default_View = null;
            Dictionary<string, View_Object> views_by_view_name = new Dictionary<string, View_Object>();
            foreach (View_Object thisView in Package_To_Finalize.Behaviors.Views)
            {
                if (!views_by_view_name.ContainsKey(thisView.View_Type.ToString()))
                    views_by_view_name[thisView.View_Type.ToString()] = thisView;
            }
            foreach (View_Object thisView in Package_To_Finalize.Behaviors.Item_Level_Page_Views)
            {
                if (!views_by_view_name.ContainsKey(thisView.View_Type.ToString()))
                    views_by_view_name[thisView.View_Type.ToString()] = thisView;
            }

            //If no viewer priorities have been passed in, add the default one
            if (Item_Viewer_Priority == null)
            {
                //TODO: Add default view here if present
               // if (views_by_view_name != null)
               //     Package_To_Finalize.Behaviors.Default_View =
            }
            else
            {
                foreach (string thisViewerType in Item_Viewer_Priority)
                {
                    if (views_by_view_name.ContainsKey(thisViewerType))
                    {
                        Package_To_Finalize.Behaviors.Default_View = views_by_view_name[thisViewerType];
                        break;
                    }
                }
            }

            Tracer.Add_Trace("SobekCM_METS_Based_ItemBuilder.Finish_Building_Item", "Done merging the database information with the resource object");
        }
        private void Finish_Building_Item(SobekCM_Item thisPackage, DataSet databaseInfo, bool multiple)
        {
            // Copy over some basic values
            DataRow mainItemRow = databaseInfo.Tables[2].Rows[0];
            thisPackage.Behaviors.Set_Primary_Identifier(mainItemRow["Primary_Identifier_Type"].ToString(), mainItemRow["Primary_Identifier"].ToString());
            thisPackage.Behaviors.GroupTitle = mainItemRow["GroupTitle"].ToString();
            thisPackage.Web.File_Root = mainItemRow["File_Location"].ToString();
            thisPackage.Web.AssocFilePath = mainItemRow["File_Location"] + "\\" + thisPackage.VID + "\\";
            thisPackage.Behaviors.IP_Restriction_Membership = Convert.ToInt16(mainItemRow["IP_Restriction_Mask"]);
            thisPackage.Behaviors.CheckOut_Required = Convert.ToBoolean(mainItemRow["CheckoutRequired"]);
            thisPackage.Behaviors.Text_Searchable = Convert.ToBoolean(mainItemRow["TextSearchable"]);
            thisPackage.Web.ItemID = Convert.ToInt32(mainItemRow["ItemID"]);
            thisPackage.Web.GroupID = Convert.ToInt32(mainItemRow["GroupID"]);
            thisPackage.Behaviors.Suppress_Endeca = Convert.ToBoolean(mainItemRow["SuppressEndeca"]);
            //thisPackage.Behaviors.Expose_Full_Text_For_Harvesting = Convert.ToBoolean(mainItemRow["SuppressEndeca"]);
            thisPackage.Tracking.Internal_Comments = mainItemRow["Comments"].ToString();
            thisPackage.Behaviors.Dark_Flag = Convert.ToBoolean(mainItemRow["Dark"]);
            thisPackage.Tracking.Born_Digital = Convert.ToBoolean(mainItemRow["Born_Digital"]);
            //thisPackage.Divisions.Page_Count = Convert.ToInt32(mainItemRow["Pages"]);
            if (mainItemRow["Disposition_Advice"] != DBNull.Value)
                thisPackage.Tracking.Disposition_Advice = Convert.ToInt16(mainItemRow["Disposition_Advice"]);
            else
                thisPackage.Tracking.Disposition_Advice = -1;
            if (mainItemRow["Material_Received_Date"] != DBNull.Value)
                thisPackage.Tracking.Material_Received_Date = Convert.ToDateTime(mainItemRow["Material_Received_Date"]);
            else
                thisPackage.Tracking.Material_Received_Date = null;
            if (mainItemRow["Material_Recd_Date_Estimated"] != DBNull.Value)
                thisPackage.Tracking.Material_Rec_Date_Estimated = Convert.ToBoolean(mainItemRow["Material_Recd_Date_Estimated"]);
            if (databaseInfo.Tables[2].Columns.Contains("Tracking_Box"))
            {
                if (mainItemRow["Tracking_Box"] != DBNull.Value)
                    thisPackage.Tracking.Tracking_Box= mainItemRow["Tracking_Box"].ToString();
            }

            // Set more of the sobekcm web portions in the item
            thisPackage.Web.Set_BibID_VID(thisPackage.BibID, thisPackage.VID);
            thisPackage.Web.Image_Root = SobekCM_Library_Settings.Image_URL;
            if (multiple)
                thisPackage.Web.Siblings = 2;

            // Set the serial hierarchy from the database (if multiple)
            if ((multiple) && (mainItemRow["Level1_Text"].ToString().Length > 0))
            {
                bool found = false;

                // Get the values from the database first
                string level1_text = mainItemRow["Level1_Text"].ToString();
                string level2_text = mainItemRow["Level2_Text"].ToString();
                string level3_text = mainItemRow["Level3_Text"].ToString();
                int level1_index = Convert.ToInt32(mainItemRow["Level1_Index"]);
                int level2_index = Convert.ToInt32(mainItemRow["Level2_Index"]);
                int level3_index = Convert.ToInt32(mainItemRow["Level3_Index"]);

                // Does this match the enumeration
                if (level1_text.ToUpper().Trim() == thisPackage.Bib_Info.Series_Part_Info.Enum1.ToUpper().Trim())
                {
                    // Copy the database values to the enumeration portion
                    thisPackage.Bib_Info.Series_Part_Info.Enum1 = level1_text;
                    thisPackage.Bib_Info.Series_Part_Info.Enum1_Index = level1_index;
                    thisPackage.Bib_Info.Series_Part_Info.Enum2 = level2_text;
                    thisPackage.Bib_Info.Series_Part_Info.Enum2_Index = level2_index;
                    thisPackage.Bib_Info.Series_Part_Info.Enum3 = level3_text;
                    thisPackage.Bib_Info.Series_Part_Info.Enum3_Index = level3_index;
                    found = true;
                }

                // Does this match the chronology
                if ((!found) && (level1_text.ToUpper().Trim() == thisPackage.Bib_Info.Series_Part_Info.Year.ToUpper().Trim()))
                {
                    // Copy the database values to the chronology portion
                    thisPackage.Bib_Info.Series_Part_Info.Year = level1_text;
                    thisPackage.Bib_Info.Series_Part_Info.Year_Index = level1_index;
                    thisPackage.Bib_Info.Series_Part_Info.Month = level2_text;
                    thisPackage.Bib_Info.Series_Part_Info.Month_Index = level2_index;
                    thisPackage.Bib_Info.Series_Part_Info.Day = level3_text;
                    thisPackage.Bib_Info.Series_Part_Info.Day_Index = level3_index;
                    found = true;
                }

                if (!found)
                {
                    // No match.  If it is numeric, move it to the chronology, otherwise, enumeration
                    bool charFound = level1_text.Trim().Any(thisChar => !Char.IsNumber(thisChar));

                    if (charFound)
                    {
                        // Copy the database values to the enumeration portion
                        thisPackage.Bib_Info.Series_Part_Info.Enum1 = level1_text;
                        thisPackage.Bib_Info.Series_Part_Info.Enum1_Index = level1_index;
                        thisPackage.Bib_Info.Series_Part_Info.Enum2 = level2_text;
                        thisPackage.Bib_Info.Series_Part_Info.Enum2_Index = level2_index;
                        thisPackage.Bib_Info.Series_Part_Info.Enum3 = level3_text;
                        thisPackage.Bib_Info.Series_Part_Info.Enum3_Index = level3_index;
                    }
                    else
                    {
                        // Copy the database values to the chronology portion
                        thisPackage.Bib_Info.Series_Part_Info.Year = level1_text;
                        thisPackage.Bib_Info.Series_Part_Info.Year_Index = level1_index;
                        thisPackage.Bib_Info.Series_Part_Info.Month = level2_text;
                        thisPackage.Bib_Info.Series_Part_Info.Month_Index = level2_index;
                        thisPackage.Bib_Info.Series_Part_Info.Day = level3_text;
                        thisPackage.Bib_Info.Series_Part_Info.Day_Index = level3_index;
                    }
                }

                // Copy the database values to the simple serial portion (used to actually determine serial heirarchy)
                thisPackage.Behaviors.Serial_Info.Clear();
                thisPackage.Behaviors.Serial_Info.Add_Hierarchy(1, level1_index, level1_text);
                if (level2_text.Length > 0)
                {
                    thisPackage.Behaviors.Serial_Info.Add_Hierarchy(2, level2_index, level2_text);
                    if (level3_text.Length > 0)
                    {
                        thisPackage.Behaviors.Serial_Info.Add_Hierarchy(3, level3_index, level3_text);
                    }
                }
            }

            // See if this can be described
            bool can_describe = false;
            foreach (DataRow thisRow in databaseInfo.Tables[1].Rows)
            {
                int thisAggregationValue = Convert.ToInt16(thisRow["Items_Can_Be_Described"]);
                if (thisAggregationValue == 0)
                {
                    can_describe = false;
                    break;
                }
                if (thisAggregationValue == 2)
                {
                    can_describe = true;
                }
            }
            thisPackage.Behaviors.Can_Be_Described = can_describe;

            // Look for user descriptions
            foreach (DataRow thisRow in databaseInfo.Tables[0].Rows)
            {
                string first_name = thisRow["FirstName"].ToString();
                string nick_name = thisRow["NickName"].ToString();
                string last_name = thisRow["LastName"].ToString();
                int userid = Convert.ToInt32(thisRow["UserID"]);
                string tag = thisRow["Description_Tag"].ToString();
                int tagid = Convert.ToInt32(thisRow["TagID"]);
                DateTime dateAdded = Convert.ToDateTime(thisRow["Date_Modified"]);

                if (nick_name.Length > 0)
                {
                    thisPackage.Behaviors.Add_User_Tag(userid, nick_name + " " + last_name, tag, dateAdded, tagid);
                }
                else
                {
                    thisPackage.Behaviors.Add_User_Tag(userid, first_name + " " + last_name, tag, dateAdded, tagid);
                }
            }

            // Look for ticklers
            foreach (DataRow thisRow in databaseInfo.Tables[3].Rows)
            {
                thisPackage.Behaviors.Add_Tickler(thisRow["MetadataValue"].ToString().Trim());
            }

            // Set the aggregations in the package to the aggregation links from the database
            thisPackage.Behaviors.Clear_Aggregations();
            foreach (DataRow thisRow in databaseInfo.Tables[1].Rows)
            {
                if (!Convert.ToBoolean(thisRow["impliedLink"]))
                {
                    thisPackage.Behaviors.Add_Aggregation(thisRow["Code"].ToString());
                }
            }

            // If no collections, add some regardless of whether it was IMPLIED
            if ( thisPackage.Behaviors.Aggregation_Count == 0)
            {
                foreach (DataRow thisRow in databaseInfo.Tables[1].Rows)
                {
                    if (thisRow["Type"].ToString().ToUpper() == "COLLECTION")
                        thisPackage.Behaviors.Add_Aggregation(thisRow["Code"].ToString());
                }
            }

            // Step through each page and set the static page count
            pageseq = 0;
            List<Page_TreeNode> pages_encountered = new List<Page_TreeNode>();
            foreach (abstract_TreeNode rootNode in thisPackage.Divisions.Physical_Tree.Roots)
            {
                recurse_through_nodes(thisPackage, rootNode, pages_encountered);
            }
            thisPackage.Web.Static_PageCount = pages_encountered.Count;
            thisPackage.Web.Static_Division_Count = divseq;

            // Make sure no icons were retained from the METS file itself
            thisPackage.Behaviors.Clear_Wordmarks();

            // Add the icons from the database information
            foreach (DataRow iconRow in databaseInfo.Tables[5].Rows)
            {
                string image = iconRow[0].ToString();
                string link = iconRow[1].ToString().Replace("&", "&amp;").Replace("\"", "&quot;");
                string code = iconRow[2].ToString();
                string name = code.Replace("&", "&amp;").Replace("\"", "&quot;");

                string html;
                if (link.Length == 0)
                {
                    html = "<img class=\"SobekItemWordmark\" src=\"<%BASEURL%>design/wordmarks/" + image + "\" title=\"" + name + "\" alt=\"" + name + "\" />";
                }
                else
                {
                    if (link[0] == '?')
                    {
                        html = "<a href=\"" + link + "\"><img class=\"SobekItemWordmark\" src=\"<%BASEURL%>design/wordmarks/" + image + "\" title=\"" + name + "\" alt=\"" + name + "\" /></a>";
                    }
                    else
                    {
                        html = "<a href=\"" + link + "\" target=\"_blank\"><img class=\"SobekItemWordmark\" src=\"<%BASEURL%>design/wordmarks/" + image + "\" title=\"" + name + "\" alt=\"" + name + "\" /></a>";
                    }
                }

                Wordmark_Info newIcon = new Wordmark_Info {HTML = html, Link = link, Title = name, Code = code};
                thisPackage.Behaviors.Add_Wordmark(newIcon);
            }

            // Make sure no web skins were retained from the METS file itself
            thisPackage.Behaviors.Clear_Web_Skins();

            // Add the web skins from the database
            foreach (DataRow skinRow in databaseInfo.Tables[6].Rows)
            {
                thisPackage.Behaviors.Add_Web_Skin(skinRow[0].ToString().ToUpper());
            }

            // Make sure no views were retained from the METS file itself
            thisPackage.Behaviors.Clear_Views();

            // If this has more than 1 sibling (this count includes itself), add the multi-volumes viewer
            if (multiple)
            {
                thisPackage.Behaviors.Add_View(View_Enum.ALL_VOLUMES, String.Empty, thisPackage.Bib_Info.SobekCM_Type_String);
            }

            // Add the full citation view and the (hidden) tracking view
            thisPackage.Behaviors.Add_View(View_Enum.CITATION);
            thisPackage.Behaviors.Add_View(View_Enum.TRACKING);

            // Add the full text
            if ( thisPackage.Behaviors.Text_Searchable )
                thisPackage.Behaviors.Add_View(View_Enum.SEARCH);

            // Is there an embedded video?
            if (thisPackage.Behaviors.Embedded_Video.Length > 0)
                thisPackage.Behaviors.Add_View(View_Enum.EMBEDDED_VIDEO);

            // If there is no PURL, add one based on how SobekCM operates
            if (thisPackage.Bib_Info.Location.PURL.Length == 0)
            {
                thisPackage.Bib_Info.Location.PURL = SobekCM_Library_Settings.System_Base_URL + thisPackage.BibID + "/" + thisPackage.VID;

            }

            // IF this is dark, add no other views
            if (!thisPackage.Behaviors.Dark_Flag)
            {
                // Check to see which views were present from the database, and build the list
                Dictionary<View_Enum, View_Object> viewsFromDb = new Dictionary<View_Enum, View_Object>();
                foreach (DataRow viewRow in databaseInfo.Tables[4].Rows)
                {
                    string viewType = viewRow[0].ToString();
                    string attribute = viewRow[1].ToString();
                    string label = viewRow[2].ToString();

                    View_Enum viewTypeEnum = View_Enum.None;
                    switch (viewType)
                    {
                        case "JPEG":
                            viewTypeEnum = View_Enum.JPEG;
                            break;

                        case "JPEG2000":
                            viewTypeEnum = View_Enum.JPEG2000;
                            break;

                        case "Text":
                            viewTypeEnum = View_Enum.TEXT;
                            break;

                        case "Page Turner":
                            viewTypeEnum = View_Enum.PAGE_TURNER;
                            break;

                        case "Google Map":
                            viewTypeEnum = View_Enum.GOOGLE_MAP;
                            break;

                        case "HTML Viewer":
                            viewTypeEnum = View_Enum.HTML;
                            break;

                        case "HTML Map Viewer":
                            viewTypeEnum = View_Enum.HTML_MAP;
                            break;

                        case "Related Images":
                            viewTypeEnum = View_Enum.RELATED_IMAGES;
                            break;

                        case "TOC":
                            viewTypeEnum = View_Enum.TOC;
                            break;

                        case "TEI":
                            viewTypeEnum = View_Enum.TEI;
                            break;
                    }

                    if (viewTypeEnum != View_Enum.None)
                    {
                        viewsFromDb[viewTypeEnum] = new View_Object(viewTypeEnum, label, attribute);
                    }
                }

                // Add the thumbnail view, if requested and has multiple pages
                if (thisPackage.Divisions.Page_Count > 1)
                {
                    if (viewsFromDb.ContainsKey(View_Enum.RELATED_IMAGES))
                    {
                        thisPackage.Behaviors.Add_View(viewsFromDb[View_Enum.RELATED_IMAGES]);
                        viewsFromDb.Remove(View_Enum.RELATED_IMAGES);
                    }

                    thisPackage.Behaviors.Add_View(View_Enum.QUALITY_CONTROL);
                }
                else
                {
                    if (viewsFromDb.ContainsKey(View_Enum.RELATED_IMAGES))
                    {
                        viewsFromDb.Remove(View_Enum.RELATED_IMAGES);
                    }
                }

                // If this item has more than one division, look for the TOC viewer
                if ((thisPackage.Divisions.Has_Multiple_Divisions) && (!thisPackage.Bib_Info.ImageClass))
                {
                    if (viewsFromDb.ContainsKey(View_Enum.TOC))
                    {
                        thisPackage.Behaviors.Add_View(viewsFromDb[View_Enum.TOC]);
                        viewsFromDb.Remove(View_Enum.TOC);
                    }
                }

                // In addition, if there is a latitude or longitude listed, look for the Google Maps
                bool hasCoords = false;
                GeoSpatial_Information geoInfo = (GeoSpatial_Information) thisPackage.Get_Metadata_Module(GlobalVar.GEOSPATIAL_METADATA_MODULE_KEY);
                if (( geoInfo != null ) && ( geoInfo.hasData ))
                {
                    if ((geoInfo.Point_Count > 0) || (geoInfo.Polygon_Count > 0))
                    {
                        hasCoords = true;
                    }
                }
                if (!hasCoords)
                {
                    List<abstract_TreeNode> pageList = thisPackage.Divisions.Physical_Tree.Pages_PreOrder;
                    foreach (abstract_TreeNode thisPage in pageList)
                    {
                        GeoSpatial_Information geoInfo2 = (GeoSpatial_Information) thisPage.Get_Metadata_Module(GlobalVar.GEOSPATIAL_METADATA_MODULE_KEY);
                        if ((geoInfo2 != null) && (geoInfo2.hasData))
                        {
                            if ((geoInfo2.Point_Count > 0) || (geoInfo2.Polygon_Count > 0))
                            {
                                hasCoords = true;
                                break;
                            }
                        }
                    }
                }

                if (hasCoords)
                {
                    if (viewsFromDb.ContainsKey(View_Enum.GOOGLE_MAP))
                    {
                        thisPackage.Behaviors.Add_View(viewsFromDb[View_Enum.GOOGLE_MAP]);
                        viewsFromDb.Remove(View_Enum.GOOGLE_MAP);
                    }
                    else
                    {
                        thisPackage.Behaviors.Add_View(View_Enum.GOOGLE_MAP);
                    }
                }

                // Step through each download and make sure it is fully built
                if (thisPackage.Divisions.Download_Tree.Has_Files)
                {
                    string ead_file = String.Empty;
                    int pdf_download = 0;
                    string pdf_download_url = String.Empty;
                    int non_flash_downloads = 0;
                    List<abstract_TreeNode> downloadPages = thisPackage.Divisions.Download_Tree.Pages_PreOrder;
                    foreach (Page_TreeNode downloadPage in downloadPages)
                    {
                        // Was this an EAD page?
                        if ((downloadPage.Label == GlobalVar.EAD_METADATA_MODULE_KEY) && (downloadPage.Files.Count == 1))
                        {
                            ead_file = downloadPage.Files[0].System_Name;
                        }

                        // Was this an XSL/EAD page?
                        if ((downloadPage.Label == "XSL") && (downloadPage.Files.Count == 1))
                        {
                        }

                        // Step through each download file
                        foreach (SobekCM_File_Info thisFile in downloadPage.Files)
                        {
                            if (thisFile.File_Extension == "SWF")
                            {
                                string flashlabel = downloadPage.Label;
                                View_Object newView = thisPackage.Behaviors.Add_View(View_Enum.FLASH, flashlabel, String.Empty, thisFile.System_Name);
                                thisPackage.Behaviors.Default_View = newView;
                            }
                            else
                            {
                                non_flash_downloads++;
                            }

                            if (thisFile.File_Extension == "PDF")
                            {
                                pdf_download++;
                                pdf_download_url = thisFile.System_Name;
                            }
                        }
                    }

                    if (((non_flash_downloads > 0) && (pdf_download != 1)) || ((non_flash_downloads > 1) && (pdf_download == 1)))
                    {

                        if (thisPackage.Web.Static_PageCount == 0)
                            thisPackage.Behaviors.Default_View = thisPackage.Behaviors.Add_View(View_Enum.DOWNLOADS);
                        else
                            thisPackage.Behaviors.Add_View(View_Enum.DOWNLOADS);
                    }

                    if (pdf_download == 1)
                    {
                        if ((thisPackage.Web.Static_PageCount == 0) && ( thisPackage.Behaviors.Default_View == null ))
                        {
                            thisPackage.Behaviors.Default_View = thisPackage.Behaviors.Add_View(View_Enum.PDF);
                            thisPackage.Behaviors.Default_View.FileName = pdf_download_url;
                        }
                        else
                        {
                            thisPackage.Behaviors.Add_View(View_Enum.PDF).FileName = pdf_download_url;
                        }
                    }

                    // Some special code for EAD objects
                    if ((thisPackage.Bib_Info.SobekCM_Type == TypeOfResource_SobekCM_Enum.Archival ) && (ead_file.Length > 0))
                    {
                        // Now, read this EAD file information
                        string ead_file_location = SobekCM_Library_Settings.Image_Server_Network + thisPackage.Web.AssocFilePath + ead_file;
                        EAD_File_ReaderWriter reader = new EAD_File_ReaderWriter();
                        string Error_Message;
                        Dictionary<string, object> options = new Dictionary<string, object>();
                        options["EAD_File_ReaderWriter:XSL_Location"] = SobekCM_Library_Settings.System_Base_URL + "default/sobekcm_default.xsl";
                        reader.Read_Metadata(ead_file_location, thisPackage, options, out Error_Message);

                        // Clear all existing views
                        thisPackage.Behaviors.Clear_Views();
                        thisPackage.Behaviors.Add_View(View_Enum.CITATION);
                        thisPackage.Behaviors.Default_View = thisPackage.Behaviors.Add_View(View_Enum.EAD_DESCRIPTION);

                        // Get the metadata module for EADs
                        EAD_Info eadInfo = (EAD_Info)thisPackage.Get_Metadata_Module(GlobalVar.EAD_METADATA_MODULE_KEY);
                        if (( eadInfo != null ) && ( eadInfo.Container_Hierarchy.Containers.Count > 0 ))
                            thisPackage.Behaviors.Add_View(View_Enum.EAD_CONTAINER_LIST);

                    }
                }
                else
                {
                    if (thisPackage.Bib_Info.SobekCM_Type == TypeOfResource_SobekCM_Enum.Aerial )
                    {
                        thisPackage.Behaviors.Add_View(View_Enum.DOWNLOADS);
                    }
                }

                // If there is a RELATED URL with youtube, add that viewer
                if ((thisPackage.Bib_Info.hasLocationInformation) && (thisPackage.Bib_Info.Location.Other_URL.ToLower().IndexOf("www.youtube.com") >= 0))
                {
                    View_Object newViewObj = new View_Object(View_Enum.YOUTUBE_VIDEO);
                    thisPackage.Behaviors.Add_View(newViewObj);
                    thisPackage.Behaviors.Default_View = newViewObj;
                }

                // Look for the HTML type views next, and possible set some defaults
                if (viewsFromDb.ContainsKey(View_Enum.HTML))
                {
                    thisPackage.Behaviors.Add_View(viewsFromDb[View_Enum.HTML]);
                    thisPackage.Behaviors.Default_View = viewsFromDb[View_Enum.HTML];
                    viewsFromDb.Remove(View_Enum.HTML);
                }

                // Look for the HTML MAP type views next, and possible set some defaults
                if (viewsFromDb.ContainsKey(View_Enum.HTML_MAP))
                {
                    thisPackage.Behaviors.Add_View(viewsFromDb[View_Enum.HTML_MAP]);
                    thisPackage.Behaviors.Default_View = viewsFromDb[View_Enum.HTML_MAP];
                    viewsFromDb.Remove(View_Enum.HTML_MAP);
                }

                // Copy the TEI flag
                if (viewsFromDb.ContainsKey(View_Enum.TEI))
                {
                    thisPackage.Behaviors.Add_View(viewsFromDb[View_Enum.TEI]);
                    viewsFromDb.Remove(View_Enum.HTML);
                }

                // Look to add any index information here ( such as on SANBORN maps)
                Map_Info mapInfo = (Map_Info) thisPackage.Get_Metadata_Module(GlobalVar.SOBEKCM_MAPS_METADATA_MODULE_KEY);
                if (mapInfo != null)
                {
                    // Was there a HTML map here?
                    if (mapInfo.Index_Count > 0)
                    {
                        Map_Index thisIndex = mapInfo.Get_Index(0);
                        View_Object newMapSanbView = thisPackage.Behaviors.Add_View(View_Enum.HTML_MAP, thisIndex.Title, thisIndex.Image_File + ";" + thisIndex.HTML_File);
                        thisPackage.Behaviors.Default_View = newMapSanbView;
                    }

                    //// Were there streets?
                    //if (thisPackage.Map.Streets.Count > 0)
                    //{
                    //    returnValue.Item_Views.Add(new ViewerFetcher.Streets_ViewerFetcher());
                    //}

                    //// Were there features?
                    //if (thisPackage.Map.Features.Count > 0)
                    //{
                    //    returnValue.Item_Views.Add(new ViewerFetcher.Features_ViewerFetcher());
                    //}
                }

                // Look for the RELATED IMAGES view next
                if (viewsFromDb.ContainsKey(View_Enum.RELATED_IMAGES))
                {
                    thisPackage.Behaviors.Add_View(viewsFromDb[View_Enum.RELATED_IMAGES]);
                    viewsFromDb.Remove(View_Enum.RELATED_IMAGES);
                }

                // Look for the PAGE TURNER view next
                if (viewsFromDb.ContainsKey(View_Enum.PAGE_TURNER))
                {
                    thisPackage.Behaviors.Add_View(viewsFromDb[View_Enum.PAGE_TURNER]);
                    viewsFromDb.Remove(View_Enum.PAGE_TURNER);
                }

                // Finally, add all the ITEM VIEWS
                foreach (View_Object thisObject in viewsFromDb.Values)
                {
                    switch (thisObject.View_Type)
                    {
                        case View_Enum.TEXT:
                        case View_Enum.JPEG:
                        case View_Enum.JPEG2000:
                            thisPackage.Behaviors.Add_Item_Level_Page_View(thisObject);
                            break;
                    }
                }
            }
        }