private static void read_map_person(XmlReader Input_XmlReader, Map_Info MapInfo)
{
if (Input_XmlReader.MoveToAttribute("id"))
{
try
{
long personid = Convert.ToInt64(Input_XmlReader.Value.Replace("PER", "").Replace("S", "").Replace("O", "").Replace("N", ""));
while (Input_XmlReader.Read())
{
if ((Input_XmlReader.NodeType == XmlNodeType.EndElement) && (Input_XmlReader.Name == "map:person"))
{
return;
}
if ((Input_XmlReader.NodeType == XmlNodeType.Element) && (Input_XmlReader.Name == "map:persname") && (!Input_XmlReader.IsEmptyElement))
{
Input_XmlReader.Read();
if (Input_XmlReader.NodeType == XmlNodeType.Text)
{
MapInfo.New_Person(personid, Input_XmlReader.Value);
}
}
}
}
catch
{
// Do nothing in this case
}
}
}
private static void read_map_entities(XmlReader Input_XmlReader, Map_Info MapInfo)
{
while (Input_XmlReader.Read())
{
if ((Input_XmlReader.NodeType == XmlNodeType.EndElement) && (Input_XmlReader.Name == "map:entities"))
{
return;
}
if (Input_XmlReader.NodeType == XmlNodeType.Element)
{
switch (Input_XmlReader.Name)
{
case "map:street":
read_map_street(Input_XmlReader, MapInfo);
break;
case "map:feature":
read_map_feature(Input_XmlReader, MapInfo);
break;
case "map:person":
read_map_person(Input_XmlReader, MapInfo);
break;
case "map:corporation":
read_map_corporation(Input_XmlReader, MapInfo);
break;
}
}
}
}
private static void read_map_corporation(XmlReader Input_XmlReader, Map_Info mapInfo)
{
if (Input_XmlReader.MoveToAttribute("id"))
{
try
{
long corpid = Convert.ToInt64(Input_XmlReader.Value.Replace("COR", "").Replace("P", ""));
string type = String.Empty;
string primary_name = String.Empty;
List <string> alternate_names = new List <string>();
while (Input_XmlReader.Read())
{
if ((Input_XmlReader.NodeType == XmlNodeType.EndElement) && (Input_XmlReader.Name == "map:corporation"))
{
if ((corpid > 0) && (primary_name.Length > 0))
{
Map_Corporation thisCorp = mapInfo.New_Corporation(corpid, primary_name);
foreach (string altName in alternate_names)
{
thisCorp.Add_Alt_Name(altName);
}
}
return;
}
if ((Input_XmlReader.NodeType == XmlNodeType.Element) && (Input_XmlReader.Name == "map:corpname") && (!Input_XmlReader.IsEmptyElement))
{
if (Input_XmlReader.MoveToAttribute("type"))
{
type = Input_XmlReader.Value;
}
else
{
type = String.Empty;
}
Input_XmlReader.Read();
if (Input_XmlReader.NodeType == XmlNodeType.Text)
{
if ((type.Length == 0) || (type == "primary"))
{
primary_name = Input_XmlReader.Value;
}
else
{
alternate_names.Add(Input_XmlReader.Value);
}
}
}
}
}
catch
{
}
}
}
/// <summary> Flag indicates if this active reader/writer needs to append schema reference information
/// to the METS XML header by analyzing the contents of the digital resource item </summary>
/// <param name="METS_Item"> Package with all the metadata to save</param>
/// <returns> TRUE if the schema should be attached, otherwise fALSE </returns>
public bool Schema_Reference_Required_Package(SobekCM_Item METS_Item)
{
Map_Info mapInfo = METS_Item.Get_Metadata_Module(GlobalVar.SOBEKCM_MAPS_METADATA_MODULE_KEY) as Map_Info;
if (mapInfo == null)
{
return(false);
}
return(mapInfo.hasData);
}
/// <summary> Flag indicates if this active reader/writer will write a dmdSec </summary>
/// <param name="METS_Item"> Package with all the metadata to save</param>
/// <param name="Options"> Dictionary of any options which this METS section writer may utilize</param>
/// <returns> TRUE if the package has data to be written, otherwise fALSE </returns>
public bool Include_dmdSec(SobekCM_Item METS_Item, Dictionary <string, object> Options)
{
// Ensure this metadata module extension exists and has data
Map_Info mapInfo = METS_Item.Get_Metadata_Module(GlobalVar.SOBEKCM_MAPS_METADATA_MODULE_KEY) as Map_Info;
if ((mapInfo == null) || (!mapInfo.hasData))
{
return(false);
}
return(true);
}
public void CreateDefenseMap(int maxMap = 0)
{
int mapIdx = 0;
GameManager.CurGameMode = GameMode.Defense;
Map_Info mapInfo = new Map_Info();
mapInfo.mapCode = "H1000";
m_mapInfoes.Add(mapIdx, mapInfo);
}
public void SaveInitialEnemyData(Map_Info info)
{
JObject saveData = new JObject();
JArray enemyStatsDatas = new JArray();
JArray enemyPosDatas = new JArray();
// 파일로 저장
string savestring = JsonConvert.SerializeObject(saveData, Formatting.Indented);
// JObject를 Serialize하여 json string 생성
File.WriteAllText("Assets/Resources/Data/ScoreData.json", savestring); // 생성된 string을 파일에 쓴다 }
}
private static void read_map_sheets(XmlReader Input_XmlReader, Map_Info mapInfo)
{
string id_string = String.Empty;
string file = String.Empty;
while (Input_XmlReader.Read())
{
if (Input_XmlReader.NodeType == XmlNodeType.EndElement)
{
switch (Input_XmlReader.Name)
{
case "map:sheets":
return;
case "map:sheet":
try
{
long id = Convert.ToInt64(id_string.ToUpper().Replace("MS", ""));
mapInfo.New_Sheet(id, 0, file, String.Empty);
}
catch
{
}
// Clear the variables
id_string = String.Empty;
file = String.Empty;
break;
}
}
else if (Input_XmlReader.NodeType == XmlNodeType.Element)
{
switch (Input_XmlReader.Name)
{
case "map:sheet":
if (Input_XmlReader.MoveToAttribute("id"))
{
id_string = Input_XmlReader.Value;
}
break;
case "map:fileref":
if (Input_XmlReader.MoveToAttribute("fileid"))
{
file = Input_XmlReader.Value;
}
break;
}
}
}
}
/// <summary> Writes the dmdSec for the entire package to the text writer </summary>
/// <param name="Output_Stream">Stream to which the formatted text is written </param>
/// <param name="METS_Item">Package with all the metadata to save</param>
/// <param name="Options"> Dictionary of any options which this METS section writer may utilize</param>
/// <returns>TRUE if successful, otherwise FALSE </returns>
public bool Write_dmdSec(TextWriter Output_Stream, SobekCM_Item METS_Item, Dictionary <string, object> Options)
{
// Ensure this metadata module extension exists and has data
Map_Info mapInfo = METS_Item.Get_Metadata_Module(GlobalVar.SOBEKCM_MAPS_METADATA_MODULE_KEY) as Map_Info;
if ((mapInfo == null) || (!mapInfo.hasData))
{
return(true);
}
// Now, collect the data to include here
string map_data = mapInfo.ToXML("map:", false);
Output_Stream.Write(map_data);
return(true);
}
/// <summary> Reads the dmdSec at the current position in the XmlTextReader and associates it with the
/// entire package </summary>
/// <param name="Input_XmlReader"> Open XmlReader from which to read the metadata </param>
/// <param name="Return_Package"> Package into which to read the metadata</param>
/// <param name="Options"> Dictionary of any options which this METS section reader may utilize</param>
/// <returns> TRUE if successful, otherwise FALSE</returns>
public bool Read_dmdSec(XmlReader Input_XmlReader, SobekCM_Item Return_Package, Dictionary <string, object> Options)
{
// Ensure this metadata module extension exists
Map_Info mapInfo = Return_Package.Get_Metadata_Module(GlobalVar.SOBEKCM_MAPS_METADATA_MODULE_KEY) as Map_Info;
if (mapInfo == null)
{
mapInfo = new Map_Info();
Return_Package.Add_Metadata_Module(GlobalVar.SOBEKCM_MAPS_METADATA_MODULE_KEY, mapInfo);
}
// Try to get the attributes from here first
if (Input_XmlReader.MoveToAttribute("id"))
{
mapInfo.MapID = Input_XmlReader.Value;
}
// Step through each field
while (Input_XmlReader.Read())
{
if ((Input_XmlReader.NodeType == XmlNodeType.EndElement) && (Input_XmlReader.Name == "map:ufdc_map"))
{
return(true);
}
if (Input_XmlReader.NodeType == XmlNodeType.Element)
{
switch (Input_XmlReader.Name)
{
case "map:indexes":
read_map_indexes(Input_XmlReader, mapInfo);
break;
case "map:entities":
read_map_entities(Input_XmlReader, mapInfo);
break;
case "map:sheets":
read_map_sheets(Input_XmlReader, mapInfo);
break;
}
}
}
// Return false since this read all the way to the end of the steam
return(false);
}
public void SaveDefenseModeData(Map_Info mapInfo)
{
SaveDefenseMapData(mapInfo.mapCode);
}
private static void read_map_feature(XmlReader Input_XmlReader, Map_Info MapInfo)
{
string name = String.Empty;
string type = String.Empty;
if (Input_XmlReader.MoveToAttribute("name"))
{
name = Input_XmlReader.Value;
}
if (Input_XmlReader.MoveToAttribute("type"))
{
type = Input_XmlReader.Value;
}
// Determine the feature id
long featid;
Int64.TryParse(Input_XmlReader.Value.Replace("FEAT", "").Replace("U", "").Replace("R", "").Replace("E", "").Trim(), out featid);
// Add this feature
Map_Info_Tables.FeatureRow thisFeature = MapInfo.Add_Feature(featid, name, type);
while (Input_XmlReader.Read())
{
if ((Input_XmlReader.NodeType == XmlNodeType.EndElement) && (Input_XmlReader.Name == "map:feature"))
{
return;
}
if (Input_XmlReader.NodeType == XmlNodeType.Element)
{
switch (Input_XmlReader.Name)
{
case "map:desc":
thisFeature.Description = Input_XmlReader.Value;
break;
case "map:coordinates":
for (int i = 0; i < Input_XmlReader.AttributeCount; i++)
{
Input_XmlReader.MoveToAttribute(i);
switch (Input_XmlReader.Name)
{
case "units":
thisFeature.Units = Input_XmlReader.Value;
break;
case "latitude":
thisFeature.Latitude = Input_XmlReader.Value;
break;
case "longitude":
thisFeature.Longitude = Input_XmlReader.Value;
break;
}
}
break;
case "map:sheetref":
long x = -1;
long y = -1;
long sheetid = -1;
for (int i = 0; i < Input_XmlReader.AttributeCount; i++)
{
Input_XmlReader.MoveToAttribute(i);
switch (Input_XmlReader.Name)
{
case "x":
Int64.TryParse(Input_XmlReader.Value, out x);
break;
case "y":
Int64.TryParse(Input_XmlReader.Value, out y);
break;
case "sheetid":
Int64.TryParse(Input_XmlReader.Value.Replace("MS", "").Replace("SHEET", ""), out sheetid);
break;
}
}
if (sheetid > 0)
{
MapInfo.Add_Feature_Sheet_Link(thisFeature.FeatureID, sheetid, x, y);
}
break;
case "map:corpref":
if (Input_XmlReader.MoveToAttribute("corpid"))
{
long corpid;
if (Int64.TryParse(Input_XmlReader.Value.Replace("COR", "").Replace("P", ""), out corpid))
{
MapInfo.Add_Feature_Corp_Link(thisFeature.FeatureID, corpid);
}
}
break;
case "map:persid":
string reftype = String.Empty;
if (Input_XmlReader.MoveToAttribute("reftype"))
{
reftype = Input_XmlReader.Value;
}
if (Input_XmlReader.MoveToAttribute("persid"))
{
long persid;
if (Int64.TryParse(Input_XmlReader.Value.Replace("PER", "").Replace("S", "").Replace("O", "").Replace("N", ""), out persid))
{
MapInfo.Add_Feature_Person_Link(thisFeature.FeatureID, persid, reftype);
}
}
break;
}
}
}
}
private static void read_map_street(XmlReader Input_XmlReader, Map_Info MapInfo)
{
string id_string = String.Empty;
string name = String.Empty;
if (Input_XmlReader.MoveToAttribute("id"))
{
id_string = Input_XmlReader.Value;
}
if (Input_XmlReader.MoveToAttribute("name"))
{
name = Input_XmlReader.Value;
}
// Determine the street id
long streetid;
Int64.TryParse(id_string.Replace("STR", "").Replace("E", "").Replace("T", ""), out streetid);
while (Input_XmlReader.Read())
{
if ((Input_XmlReader.NodeType == XmlNodeType.EndElement) && (Input_XmlReader.Name == "map:street"))
{
return;
}
if ((Input_XmlReader.NodeType == XmlNodeType.Element) && (Input_XmlReader.Name == "map:segment"))
{
long sheetid = -1;
long start = -1;
long end = -1;
string direction = String.Empty;
string side = String.Empty;
string desc = String.Empty;
for (int i = 0; i < Input_XmlReader.AttributeCount; i++)
{
Input_XmlReader.MoveToAttribute(i);
switch (Input_XmlReader.Name)
{
case "sheetid":
Int64.TryParse(Input_XmlReader.Value.Replace("MS", "").Replace("SHEET", "").Trim(), out sheetid);
break;
case "side":
side = Input_XmlReader.Value;
break;
case "direction":
direction = Input_XmlReader.Value;
break;
case "start":
Int64.TryParse(Input_XmlReader.Value.Trim(), out start);
break;
case "end":
Int64.TryParse(Input_XmlReader.Value.Trim(), out end);
break;
}
}
Input_XmlReader.MoveToElement();
if (!Input_XmlReader.IsEmptyElement)
{
Input_XmlReader.Read();
desc = Input_XmlReader.Value;
}
// Add this street segment information
if (sheetid > 0)
{
MapInfo.Add_Street(streetid, sheetid, name, desc, direction, start, end, side);
}
}
}
}
private static void read_map_indexes(XmlReader Input_XmlReader, Map_Info MapInfo)
{
string title = String.Empty;
string file = String.Empty;
string html = String.Empty;
string type = String.Empty;
string id_string = String.Empty;
while (Input_XmlReader.Read())
{
if (Input_XmlReader.NodeType == XmlNodeType.EndElement)
{
switch (Input_XmlReader.Name)
{
case "map:indexes":
return;
case "map:image":
long id;
Int64.TryParse(id_string.ToUpper().Replace("INDE", "").Replace("X", ""), out id);
MapInfo.New_Index(id, title, file, html, type);
// Clear the variables
title = String.Empty;
file = String.Empty;
html = String.Empty;
type = String.Empty;
id_string = String.Empty;
break;
}
}
else if (Input_XmlReader.NodeType == XmlNodeType.Element)
{
switch (Input_XmlReader.Name)
{
case "map:image":
if (Input_XmlReader.MoveToAttribute("type"))
{
type = Input_XmlReader.Value;
}
if (Input_XmlReader.MoveToAttribute("id"))
{
id_string = Input_XmlReader.Value;
}
break;
case "map:title":
Input_XmlReader.Read();
if (Input_XmlReader.NodeType == XmlNodeType.Text)
{
title = Input_XmlReader.Value;
}
break;
case "map:file":
Input_XmlReader.Read();
if (Input_XmlReader.NodeType == XmlNodeType.Text)
{
file = Input_XmlReader.Value;
}
break;
case "map:html":
Input_XmlReader.Read();
if (Input_XmlReader.NodeType == XmlNodeType.Text)
{
html = Input_XmlReader.Value;
}
break;
}
}
}
}
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("&", "&").Replace("\"", """);
string code = iconRow[2].ToString();
string name = code.Replace("&", "&").Replace("\"", """);
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;
}
}
}
}
