public static string GetDataXML(TransferItem[] array)
{
XmlSerializer ser = new XmlSerializer(typeof(TransferItem[]));
StringWriter writer = new StringWriter();
ser.Serialize(writer, array);
return writer.ToString();
}
internal static string GetDataBodyCode(string systemName, TransferItem[] array)
{
string[] systemParts = systemName.Split(new char[] { ' ' });
foreach (TransferItem ti in array)
{
if (ti.Name != WellKnownItems.Headline)
{
continue;
}
string[] headlineParts = ti.Values[0].Text.Split(new char[] { ' ' });
string value = "";
for (int i = systemParts.Length; i < headlineParts.Length; i++)
{
value += headlineParts[i] + " ";
}
for (int i = 0; i+1 < value.Length; i++)
{
if (char.IsLetter(value[i]) && char.IsLetter(value[i + 1]))
{
value = value.Substring(0, i + 1) + " " + value.Substring(i + 1);
}
}
return value.Trim();
}
return "";
}
public static string GetDataText(TransferItem[] array)
{
string output = "";
foreach (TransferItem ti in array)
{
if (ti == null)
{
output += "??????" + Environment.NewLine;
continue;
}
if (ti.Name == "DELIMITER" || ti.Name == WellKnownItems.ArchiveName)
{
continue;
}
if (ti.Name == WellKnownItems.CustomDescription || ti.Name == WellKnownItems.CustomCategory)
{
continue;
}
if (ti.Name == WellKnownItems.ScanDate)
{
continue;
}
output += ti.Name;
bool first = true;
foreach (TransferItemValue tv in ti.Values)
{
string offset = first ? ti.Name : "";
first = false;
if (ti.Name == WellKnownItems.Description)
{
output += GetSpaces(offset) + LookupShortDescription(tv.Text) + Environment.NewLine;
continue;
}
if (double.IsNaN(tv.Value))
{
output += GetSpaces(offset) + tv.Text.ToString() + Environment.NewLine;
}
else
{
string format = tv.Value > 1e10 ? tv.Value.ToString("e") : tv.Value.ToString();
output += GetSpaces(offset) + "[" + format + "]";
if (!string.IsNullOrEmpty(tv.Unit) && itemConfig.LookupUnit(tv.Unit) != null)
{
output += " " + itemConfig.LookupUnit(tv.Unit);
}
if (!string.IsNullOrEmpty(tv.Text))
{
output += " " + tv.Text;
}
output += Environment.NewLine;
}
}
}
return output;
}
private bool RequireNumericalValue(string name, TransferItem[] items, int count)
{
TransferItem ti = TransferItem.FindItem(name, items);
if (ti == null || ti.Values == null || ti.Values.Count == 0 || double.IsNaN(ti.Values[0].Value))
{
errorString += "Numerical value required: " + name + Environment.NewLine;
return false;
}
else
{
return true;
}
}
private bool RequireValueExists(string name, TransferItem[] items, int count)
{
TransferItem ti = TransferItem.FindItem(name, items);
if (ti == null || ti.Values == null || ti.Values.Count == 0)
{
errorString += "Value required: " + name + Environment.NewLine;
return false;
}
else
{
return true;
}
}
private bool RequireValueExists(string name, TransferItem[] items)
{
return RequireValueExists(name, items, 1);
}
private void AddOrbitInformation(TransferItem[] items, Dictionary<string, string> requestValues)
{
RequireNumericalValue("ORBIT_PERIOD", items);
RequireNumericalValue("ORBIT_MAJOR", items);
RequireNumericalValue("ORBIT_ECCENTRICITY", items);
RequireNumericalValue("ORBIT_INCLINATION", items);
RequireNumericalValue("ORBIT_PERIAPSIS", items);
requestValues[field_id["orbital_period"]] = TransferItem.FindItem("ORBIT_PERIOD", items).Values[0].Value.ToString();
requestValues[field_id["semi_major_axis"]] = TransferItem.FindItem("ORBIT_MAJOR", items).Values[0].Value.ToString();
requestValues[field_id["orbital_eccentricity"]] = TransferItem.FindItem("ORBIT_ECCENTRICITY", items).Values[0].Value.ToString();
requestValues[field_id["orbital_inclination"]] = TransferItem.FindItem("ORBIT_INCLINATION", items).Values[0].Value.ToString();
requestValues[field_id["arg_of_periapsis"]] = TransferItem.FindItem("ORBIT_PERIAPSIS", items).Values[0].Value.ToString();
}
private void AddCompositionInformation(TransferItem[] items, Dictionary<string, string> requestValues)
{
foreach (string s in compositionOrder)
{
requestValues[field_id[s.ToLower()]] = "";
}
RequireNumericalValue("COMPOSITION", items);
foreach (TransferItemValue tiv in TransferItem.FindItem("COMPOSITION", items).Values)
{
if (compositionOrder.IndexOf(tiv.Text) < 0)
{
continue;
}
requestValues[field_id["terrestrial_planet_composition"] + "_" + (1 + compositionOrder.IndexOf(tiv.Text)).ToString()] = CapitalizeWords(tiv.Text);
requestValues[field_id[tiv.Text.ToLower()]] = tiv.Value.ToString();
}
}
private void CreateRequestStar(TransferItem[] items, Dictionary<string, string> requestValues)
{
bool multi = TransferItem.FindItem("ORBIT_MAJOR", items) != null;
bool rings = TransferItem.FindItem("RING_TYPE", items) != null;
RequireTextValue("DESCRPTION", items);
RequireNumericalValue("AGE", items);
RequireNumericalValue("SOLAR_MASSES", items);
RequireNumericalValue("SOLAR_RADIUS", items);
RequireNumericalValue("SURFACE_TEMP", items);
requestValues[field_id["object_type_group"]] = "Star";
requestValues[field_id["is_multi_star"]] = multi ? "Yes" : "No";
requestValues[field_id["is_ringed_star"]] = rings ? "Yes" : "No";
requestValues[field_id["star_type"]] = starTypes[TransferItem.FindItem("DESCRIPTION", items).Values[0].Text];
requestValues[field_id["age"]] = TransferItem.FindItem("AGE", items).Values[0].Value.ToString();
requestValues[field_id["solar_mass"]] = TransferItem.FindItem("SOLAR_MASSES", items).Values[0].Value.ToString();
requestValues[field_id["solar_radius"]] = TransferItem.FindItem("SOLAR_RADIUS", items).Values[0].Value.ToString();
requestValues[field_id["surface_temp_star"]] = TransferItem.FindItem("SURFACE_TEMP", items).Values[0].Value.ToString();
if (TransferItem.FindItem("ID_HIPP", items) != null)
{
requestValues[field_id["star_cat_id_hipp"]] = TransferItem.FindItem("ID_HIPP", items).Values[0].Value.ToString();
}
if (TransferItem.FindItem("ID_HD", items) != null)
{
requestValues[field_id["star_cat_id_hd"]] = TransferItem.FindItem("ID_HD", items).Values[0].Value.ToString();
}
if (TransferItem.FindItem("ID_GLIESE", items) != null)
{
requestValues[field_id["star_cat_id_gliese"]] = TransferItem.FindItem("ID_GLIESE", items).Values[0].Value.ToString();
}
if (multi)
{
AddOrbitInformation(items, requestValues);
}
if (rings)
{
AddRingInformation(items, requestValues);
}
}
private TransferItem GetMultiValueItem(string name, string[] nameContent, double[] valueContent)
{
TransferItem ti = new TransferItem();
ti.Name = name;
for (int i = 0; i < nameContent.Length; i++)
{
if (nameContent[i] != null && !double.IsNaN(valueContent[i]))
{
ti.Values.Add(new TransferItemValue(nameContent[i], valueContent[i], "PERCENT"));
}
}
if (ti.Values.Count > 0)
{
return ti;
}
else
{
return null;
}
}
private void AddItemToGrid(TransferItem item)
{
if (item.Name == "ATMOSPHERE" || item.Name == "COMPOSITION")
{
for (int i = 0; i < item.Values.Count; i++)
{
dataGridEdit.Rows.Add(new object[] { item.Name + "_" + (i + 1).ToString() + "_NAME", 0, item.Values[i].Text });
dataGridEdit.Rows.Add(new object[] { item.Name + "_" + (i + 1).ToString() + "_PERCENT", 0, item.Values[i].Value.ToString() });
}
}
else if(item.Values.Count == 1)
{
if (IsAllTextProperty(item.Name))
{
dataGridEdit.Rows.Add(new object[] { item.Name, 0, item.Values[0].Text });
}
else
{
dataGridEdit.Rows.Add(new object[] { item.Name, 0, item.Values[0].Value.ToString() });
}
}
}
internal void SetData(TransferItem[][] dataContainer, int index)
{
dataGridEdit.Rows.Clear();
if (dataContainer == null)
{
textSystem.Text = "";
textBody.Text = "";
textCoords.Text = "";
textCategories.Text = "";
textDescription.Text = "";
}
else
{
ResetControls(dataContainer[index]);
}
editData = dataContainer;
editIndex = index;
HasChanges = false;
UpdateUI();
}
internal void SaveEditState()
{
string[] compositionNames = new string[3];
double[] compositionValues = new double[3] { double.NaN, double.NaN, double.NaN };
string[] atmosphereNames = new string[3];
double[] atmosphereValues = new double[3] { double.NaN, double.NaN, double.NaN };
SystemCoordinates sc = LibExplOCR.ParseCoordinateValues(textCoords.Text);
bool error = false; ;
List<TransferItem> items = new List<TransferItem>();
TransferItem ti;
ti = new TransferItem(WellKnownItems.System);
ti.Values.Add(new TransferItemValue(textSystem.Text));
items.Add(ti);
ti = new TransferItem(WellKnownItems.BodyCode);
ti.Values.Add(new TransferItemValue(textBody.Text));
items.Add(ti);
ti = new TransferItem(WellKnownItems.GalCoordX);
ti.Values.Add(new TransferItemValue(""));
ti.Values[0].Value = sc.X;
items.Add(ti);
ti = new TransferItem(WellKnownItems.GalCoordY);
ti.Values.Add(new TransferItemValue(""));
ti.Values[0].Value = sc.Y;
items.Add(ti);
ti = new TransferItem(WellKnownItems.GalCoordZ);
ti.Values.Add(new TransferItemValue(""));
ti.Values[0].Value = sc.Z;
items.Add(ti);
ti = new TransferItem(WellKnownItems.CustomCategory);
ti.Values.Add(new TransferItemValue(textCategories.Text.Replace(Environment.NewLine, ";")));
items.Add(ti);
ti = new TransferItem(WellKnownItems.CustomDescription);
ti.Values.Add(new TransferItemValue(textDescription.Text));
items.Add(ti);
ti = new TransferItem(WellKnownItems.Headline);
ti.Values.Add(new TransferItemValue(textSystem.Text+" "+textBody.Text));
items.Add(ti);
ti = new TransferItem(WellKnownItems.Description);
ti.Values.Add(new TransferItemValue(descriptionConfig[comboType.SelectedIndex].Name));
items.Add(ti);
foreach (DataGridViewRow row in dataGridEdit.Rows)
{
if (row.IsNewRow)
{
continue;
}
foreach (DataGridViewCell cell in row.Cells)
{
cell.ErrorText = "";
}
if (TryReadAtmosphere(0, atmosphereNames, atmosphereValues, row, ref error)
|| TryReadAtmosphere(1, atmosphereNames, atmosphereValues, row, ref error)
|| TryReadAtmosphere(2, atmosphereNames, atmosphereValues, row, ref error))
{
continue;
}
if (TryReadComposition(0, compositionNames, compositionValues, row, ref error)
|| TryReadComposition(1, compositionNames, compositionValues, row, ref error)
|| TryReadComposition(2, compositionNames, compositionValues, row, ref error))
{
continue;
}
string name = row.Cells[columnEditName.Index].Value as string;
string value = row.Cells[columnEditValue.Index].Value as string;
if (IsStandardProperty(name))
{
if (IsAllTextProperty(name))
{
ti = new TransferItem(name);
ti.Values.Add(new TransferItemValue(value, double.NaN, GetDataUnit(name)));
items.Add(ti);
}
else
{
double d;
if (!double.TryParse(value, out d))
{
error = true;
row.Cells[columnEditValue.Index].ErrorText = "Not a number!";
continue;
}
ti = new TransferItem(name);
ti.Values.Add(new TransferItemValue("", d, GetDataUnit(name)));
items.Add(ti);
}
}
if (name == WellKnownItems.Headline)
{
ti = new TransferItem(name);
ti.Name = name;
ti.Values.Add(new TransferItemValue(value));
items.Add(ti);
}
}
ti = GetMultiValueItem("ATMOSPHERE", atmosphereNames, atmosphereValues);
if (ti != null)
{
items.Add(ti);
}
ti = GetMultiValueItem("COMPOSITION", compositionNames, compositionValues);
if (ti != null)
{
items.Add(ti);
}
foreach (TransferItem other in editData[editIndex])
{
if (IsStandardProperty(other.Name))
{
continue;
}
bool exists = false;
foreach (TransferItem present in items)
{
if (present.Name == other.Name)
{
exists = true;
}
}
if (exists)
{
continue;
}
items.Add(other);
}
if (!error)
{
SortAlike(editData[editIndex], items);
editData[editIndex] = items.ToArray();
HasChanges = false;
}
}
internal void ResetControls(TransferItem[] data)
{
SystemCoordinates sc = new SystemCoordinates();
dataGridEdit.Rows.Clear();
bool skippedHeadline = false;
for (int i = 0; i < data.Length; i++)
{
if (IsStandardProperty(data[i].Name))
{
AddItemToGrid(data[i]);
}
else if (data[i].Name == WellKnownItems.Headline && skippedHeadline)
{
AddItemToGrid(data[i]);
}
else if (data[i].Name == WellKnownItems.Headline)
{
skippedHeadline = true;
}
else if (data[i].Name == WellKnownItems.System && data[i].Values.Count > 0)
{
textSystem.Text = data[i].Values[0].Text;
}
else if (data[i].Name == WellKnownItems.BodyCode && data[i].Values.Count > 0)
{
textBody.Text = data[i].Values[0].Text;
}
else if (data[i].Name == WellKnownItems.GalCoordX && data[i].Values.Count > 0)
{
sc.X = data[i].Values[0].Value;
}
else if (data[i].Name == WellKnownItems.GalCoordY && data[i].Values.Count > 0)
{
sc.Y = data[i].Values[0].Value;
}
else if (data[i].Name == WellKnownItems.GalCoordZ && data[i].Values.Count > 0)
{
sc.Z = data[i].Values[0].Value;
}
else if (data[i].Name == WellKnownItems.CustomCategory && data[i].Values.Count > 0)
{
textCategories.Text = data[i].Values[0].Text.Replace(";", Environment.NewLine);
}
else if (data[i].Name == WellKnownItems.CustomDescription && data[i].Values.Count > 0)
{
textDescription.Text = data[i].Values[0].Text;
}
else if (data[i].Name == WellKnownItems.Description && data[i].Values.Count > 0)
{
for (int j = 0; j < comboType.Items.Count; j++)
{
if (descriptionConfig[j].Name.ToLower() == data[i].Values[0].Text.ToLower())
{
comboType.SelectedIndex = j;
break;
}
}
}
}
textCoords.Text = sc.ToString();
}
public void WebTransferItems(TransferItem[] items)
{
if (field_id == null)
{
GetInfoFieldID();
}
errorString = "";
Dictionary<string, string> requestValues = new Dictionary<string, string>();
try
{
// Build dictionary of POST request items
CreateRequestValues(items, requestValues);
}
catch (Exception ex)
{
if (errorString != "")
{
MessageBox.Show(errorString);
return;
}
else
{
MessageBox.Show(ex.Message);
return;
}
}
// Build string for the API POST request from the dictionary.
string content = "{" + Environment.NewLine +
"\"input_values\":{" + Environment.NewLine;
foreach(string key in requestValues.Keys)
{
content += "\""+key + "\":\"" + requestValues[key]+"\","+Environment.NewLine;
}
content = content.Substring(0, content.Length - (1+Environment.NewLine.Length));
content += "}"+Environment.NewLine+"}";
string response = "";
try
{
// Network interaction
HttpClient client = new HttpClient();
Task<HttpResponseMessage> task = client.PostAsync(Properties.Settings.Default.APIServer, new StringContent(content));
task.Wait();
HttpResponseMessage message = task.Result;
Task<string> task2 = message.Content.ReadAsStringAsync();
response = task2.Result;
}
catch(Exception ex)
{
MessageBox.Show("Server response was not processed: "+ex.Message);
}
try
{
// Parse the server response string.
PrimitiveJSONObject json = new PrimitiveJSONObject(response, 0);
string feedback = "";
if (json.Content["status"].Value != "200")
{
feedback = "Something went wrong with the network. HTTP says: "+json.Content["status"].Value;
}
else if (json.Content["response"].Content["is_valid"].Value != "true")
{
feedback = "Not a valid submission. Error messages: " + Environment.NewLine;
foreach (PrimitiveJSONObject err in json.Content["response"].Content["validation_messages"].Content.Values)
{
feedback += err.Value + Environment.NewLine;
}
}
else
{
feedback = "Success.";
}
MessageBox.Show(feedback);
}
catch
{
MessageBox.Show("Unable to parse server response:"+Environment.NewLine+response);
}
}
// For easier testing.
private void SortAlike(TransferItem[] transferItem, List<TransferItem> items)
{
List<TransferItem> sorted = new List<TransferItem>();
for (int i = 0; i < transferItem.Length; i++)
{
for (int j = 0; j < items.Count; j++)
{
if (transferItem[i].Name == items[j].Name)
{
sorted.Add(items[j]);
items.RemoveAt(j);
break;
}
}
}
sorted.AddRange(items);
items.Clear();
items.AddRange(sorted);
}
private void CreateRequestGiant(TransferItem[] items, Dictionary<string, string> requestValues)
{
bool rings = TransferItem.FindItem("RING_TYPE", items) != null;
RequireTextValue("DESCRIPTION", items);
RequireNumericalValue("EARTH_MASSES", items);
RequireNumericalValue("RADIUS", items);
RequireNumericalValue("SURFACE_TEMP", items);
requestValues[field_id["object_type_group"]] = "Gas Giant \\/ Water Giant";
requestValues[field_id["gas_giant_type"]] = giantTypes[TransferItem.FindItem("DESCRIPTION", items).Values[0].Text];
requestValues[field_id["earth_mass_gas_giant"]] = TransferItem.FindItem("EARTH_MASSES", items).Values[0].Value.ToString();
requestValues[field_id["radius_gas_giant"]] = TransferItem.FindItem("RADIUS", items).Values[0].Value.ToString();
requestValues[field_id["surface_temp_gas_giant"]] = TransferItem.FindItem("SURFACE_TEMP", items).Values[0].Value.ToString();
requestValues[field_id["is_ringed_gas_giant"]] = rings ? "Yes" : "No";
AddAtmosphereInformation(items, requestValues);
AddOrbitInformation(items, requestValues);
AddRotationInformation(items, requestValues);
if (rings)
{
AddRingInformation(items, requestValues);
}
}
public static void SaveInfo(string xml, string system, string body, string custom, string category, string coords, List<string> archiveNames)
{
if (!Directory.Exists(PathHelpers.BuildUserSaveDirectory()))
{
Directory.CreateDirectory(PathHelpers.BuildUserSaveDirectory());
}
TransferItem[] items = BuildInfoArray(xml, system, body, custom, category, coords, archiveNames);
TransferItem[][] array;
XmlSerializer ser = new XmlSerializer(typeof(TransferItem[][]));
try
{
using (FileStream fs = File.OpenRead(PathHelpers.BuildUserSaveFilename()))
{
array = ser.Deserialize(fs) as TransferItem[][];
}
}
catch
{
array = new TransferItem[0][];
}
List<TransferItem[]> list = new List<TransferItem[]>(array);
list.Add(items);
using (FileStream fs = new FileStream(PathHelpers.BuildUserSaveFilename(), FileMode.Create, FileAccess.Write))
{
ser.Serialize(fs, list.ToArray());
}
}
private void AddRingInformation(TransferItem[] items, Dictionary<string, string> requestValues)
{
int count = 0;
for (int i = 0; i < 5; i++)
{
if (TransferItem.FindItem("RING_TYPE", items, i+1) != null)
{
count++;
}
}
RequireTextValue("RING_TYPE", items, 1);
RequireNumericalValue("RING_MASS", items, count);
RequireNumericalValue("ORBIT_MAJOR", items, count+1);
RequireNumericalValue("RING_INNER", items, count);
RequireNumericalValue("RING_OUTER", items, count);
requestValues[field_id["ring_reserves_types"]] = TransferItem.FindItem("MINING_RESERVES", items).Values[0].Text;
requestValues[field_id["number_of_rings"]] = count.ToString();
for (int i = 0; i < count; i++)
{
requestValues[field_id["ring_name_" + (i + 1).ToString()]] = (i + 1).ToString();
requestValues[field_id["ring_type_" + (i + 1).ToString()]] = TransferItem.FindItem("RING_TYPE", items,i+1).Values[0].Text;
requestValues[field_id["ring_mass_" + (i + 1).ToString()]] = TransferItem.FindItem("RING_MASS", items,i+1).Values[0].Value.ToString();
requestValues[field_id["ring_semi_major_axis_" + (i + 1).ToString()]] = TransferItem.FindItem("ORBIT_MAJOR", items, i + 1).Values[0].Value.ToString();
requestValues[field_id["ring_inner_radius_" + (i + 1).ToString()]] = TransferItem.FindItem("RING_INNER", items, i + 1).Values[0].Value.ToString();
requestValues[field_id["ring_outer_radius_" + (i + 1).ToString()]] = TransferItem.FindItem("RING_OUTER", items, i + 1).Values[0].Value.ToString();
}
}
public static TransferItem[] BuildInfoArray(string xml, string system, string body, string custom, string category, string coords, List<string> archiveNames)
{
XmlSerializer ser = new XmlSerializer(typeof(TransferItem[]));
StringReader reader = new StringReader(xml);
TransferItem[] items = ser.Deserialize(reader) as TransferItem[];
SystemCoordinates sc = ParseCoordinateValues(coords);
foreach (TransferItem item in items)
{
if (item.Name == WellKnownItems.Headline && item.Values.Count > 0)
{
item.Values[0].Text = system + " " + body;
item.Values[0].Value = double.NaN;
break;
}
}
List<TransferItem> info = new List<TransferItem>();
TransferItem ti = new TransferItem();
ti.Name = WellKnownItems.System;
ti.Values = new List<TransferItemValue>(new TransferItemValue[] { new TransferItemValue() });
ti.Values[0].Text = system;
ti.Values[0].Value = double.NaN;
info.Add(ti);
ti = new TransferItem();
ti.Name = WellKnownItems.BodyCode;
ti.Values = new List<TransferItemValue>(new TransferItemValue[] { new TransferItemValue() });
ti.Values[0].Text = body;
ti.Values[0].Value = double.NaN;
info.Add(ti);
ti = new TransferItem();
ti.Name = WellKnownItems.GalCoordX;
ti.Values = new List<TransferItemValue>(new TransferItemValue[] { new TransferItemValue() });
ti.Values[0].Text = "";
ti.Values[0].Value = sc.X;
info.Add(ti);
ti = new TransferItem();
ti.Name = WellKnownItems.GalCoordY;
ti.Values = new List<TransferItemValue>(new TransferItemValue[] { new TransferItemValue() });
ti.Values[0].Text = "";
ti.Values[0].Value = sc.Y;
info.Add(ti);
ti = new TransferItem();
ti.Name = WellKnownItems.GalCoordZ;
ti.Values = new List<TransferItemValue>(new TransferItemValue[] { new TransferItemValue() });
ti.Values[0].Text = "";
ti.Values[0].Value = sc.Z;
info.Add(ti);
ti = new TransferItem();
ti.Name = WellKnownItems.CustomCategory;
ti.Values = new List<TransferItemValue>(new TransferItemValue[] { new TransferItemValue() });
ti.Values[0].Text = category.Replace(Environment.NewLine, ";");
ti.Values[0].Value = double.NaN;
info.Add(ti);
ti = new TransferItem();
ti.Name = WellKnownItems.CustomDescription;
ti.Values = new List<TransferItemValue>(new TransferItemValue[] { new TransferItemValue() });
ti.Values[0].Text = custom;
ti.Values[0].Value = double.NaN;
info.Add(ti);
if (archiveNames.Count > 0)
{
ti = new TransferItem();
ti.Name = WellKnownItems.ArchiveName;
ti.Values = new List<TransferItemValue>();
foreach (string name in archiveNames)
{
TransferItemValue tiv = new TransferItemValue();
tiv.Text = name;
tiv.Value = double.NaN;
ti.Values.Add(tiv);
}
info.Add(ti);
}
foreach (TransferItem item in items)
{
if (item == null)
{
continue;
}
if (item.Name != "DELIMITER")
{
info.Add(item);
}
}
return info.ToArray();
}
private void AddAtmosphereInformation(TransferItem[] items, Dictionary<string, string> requestValues)
{
TransferItem type = TransferItem.FindItem("ATMOSPHERE_TYPE", items);
TransferItem composition = TransferItem.FindItem("ATMOSPHERE", items);
TransferItem pressure = TransferItem.FindItem("SURFACE_PRESSURE", items);
if (pressure != null)
{
requestValues[field_id["surface_pressure"]] = pressure.Values[0].Value.ToString();
}
if (type != null)
{
if (atmosphereTypes.ContainsKey(type.Values[0].Text))
{
requestValues[field_id["atmosphere_type"]] = atmosphereTypes[type.Values[0].Text];
}
else if (type.Values[0].Text.StartsWith("SUITABLE FOR WATER"))
{
requestValues[field_id["atmosphere_type"]] = atmosphereTypes["SUITABLE FOR WATER BASED LIFE"];
}
}
if(composition != null)
{
foreach (TransferItemValue tiv in composition.Values)
{
if (atmosphereOrder.IndexOf(tiv.Text) < 0)
{
continue;
}
requestValues[field_id["atmospheric_composition"]+"_"+(1+atmosphereOrder.IndexOf(tiv.Text)).ToString()] = tiv.Text;
requestValues[field_id[atmosphereElements[tiv.Text]]] = tiv.Value.ToString();
}
}
}
string[] GetArchiveFiles(TransferItem[] data)
{
List<string> files = new List<string>();
foreach (TransferItem item in data)
{
if (item.Name == WellKnownItems.ArchiveName)
{
foreach (TransferItemValue value in item.Values)
{
files.Add(value.Text);
}
}
}
return files.ToArray();
}
private void AddRotationInformation(TransferItem[] items, Dictionary<string, string> requestValues)
{
RequireNumericalValue("ROTATION_PERIOD", items);
RequireNumericalValue("ROTATION_TILT", items);
RequireTextValue("ROTATION_LOCKED", items);
requestValues[field_id["rotational_period"]] = TransferItem.FindItem("ROTATION_PERIOD", items).Values[0].Value.ToString();
requestValues[field_id["axial_tilt"]] = TransferItem.FindItem("ROTATION_TILT", items).Values[0].Value.ToString();
requestValues[field_id["is_tidally_locked"]] = CapitalizeWords(TransferItem.FindItem("ROTATION_LOCKED", items).Values[0].Text);
}
private void LoadData()
{
TransferItem[][] array;
XmlSerializer ser = new XmlSerializer(typeof(TransferItem[][]));
try
{
using (FileStream fs = File.OpenRead(PathHelpers.BuildUserSaveFilename()))
{
array = ser.Deserialize(fs) as TransferItem[][];
}
}
catch
{
array = new TransferItem[0][];
}
dataItems = array;
dataTable.Rows.Clear();
PopulateTable(array);
}
private bool RequireTextValue(string name, TransferItem[] items)
{
return RequireTextValue(name, items, 1);
}
public void PopulateTable(TransferItem[][] items)
{
foreach (TransferItem[] body in items)
{
foreach (TransferItem item in body)
{
if (item == null) continue;
if (item.Values.Count != 1)
{
if (item.Name == "ATMOSPHERE" || item.Name == "COMPOSITION")
{
for (int i = 0; i < 3; i++)
{
if (dataTable.Columns.Contains(item.Name + "_" + (i + 1).ToString() + "_NAME"))
{
continue;
}
dataTable.Columns.Add(new DataColumn(item.Name + "_" + (i + 1).ToString() + "_NAME", typeof(string)));
dataTable.Columns.Add(new DataColumn(item.Name + "_" + (i + 1).ToString() + "_PERCENT", typeof(double)));
}
}
else
{
continue;
}
continue;
}
if (dataTable.Columns.Contains(item.Name))
{
continue;
}
Type dataType;
if (double.IsNaN(item.Values[0].Value))
{
dataType = typeof(string);
}
else
{
dataType = typeof(double);
}
dataTable.Columns.Add(new DataColumn(item.Name, dataType));
}
}
for (int index = 0; index < items.Length; index++)
{
TransferItem[] body = items[index];
DataRow row = dataTable.NewRow();
dataTable.Rows.Add(row);
row[HiddenIndexName] = index;
foreach (TransferItem item in body)
{
if (item == null) continue;
if (item.Name == "ATMOSPHERE" || item.Name == "COMPOSITION")
{
for (int i = 0; i < item.Values.Count; i++)
{
if (!dataTable.Columns.Contains(item.Name + "_" + (i + 1).ToString() + "_NAME"))
{
continue;
}
row[item.Name + "_" + (i + 1).ToString() + "_NAME"] = item.Values[i].Text;
row[item.Name + "_" + (i + 1).ToString() + "_PERCENT"] = item.Values[i].Value;
}
}
else if (item.Name == WellKnownItems.ArchiveName)
{
row[item.Name] = item.Values[0].Text;
}
else if (dataTable.Columns.Contains(item.Name) && item.Values.Count == 1)
{
if (double.IsNaN(item.Values[0].Value) && dataTable.Columns[item.Name].DataType == typeof(double))
{
continue;
}
if (double.IsNaN(item.Values[0].Value))
{
row[item.Name] = item.Values[0].Text;
}
else
{
row[item.Name] = item.Values[0].Value;
}
}
}
}
foreach (DataGridViewColumn col in dataGrid.Columns)
{
col.ReadOnly = true;
}
}
private bool RequireTextValue(string name, TransferItem[] items, int count)
{
TransferItem ti = TransferItem.FindItem(name, items);
if (ti == null || ti.Values == null || ti.Values.Count == 0 || string.IsNullOrEmpty(ti.Values[0].Text))
{
errorString += "Text value required: " + name + Environment.NewLine;
return false;
}
else
{
return true;
}
}
private void CreateRequestPlanet(TransferItem[] items, Dictionary<string, string> requestValues)
{
RequireTextValue("DESCRIPTION", items);
RequireNumericalValue("EARTH_MASSES", items);
RequireNumericalValue("RADIUS", items);
RequireNumericalValue("SURFACE_TEMP", items);
bool volcanism = TransferItem.FindItem("VOLCANISM_TYPE", items) != null;
bool rings = TransferItem.FindItem("RING_TYPE", items) != null;
bool terraform = TransferItem.FindItem("TERRAFORMING", items) != null;
requestValues[field_id["object_type_group"]] = "Terrestrial Planet";
requestValues[field_id["terrestrial_planet_type"]] = planetTypes[TransferItem.FindItem("DESCRIPTION", items).Values[0].Text];
requestValues[field_id["earth_mass_terrestrial_planet"]] = TransferItem.FindItem("EARTH_MASSES", items).Values[0].Value.ToString();
requestValues[field_id["radius_terrestrial_planet"]] = TransferItem.FindItem("RADIUS", items).Values[0].Value.ToString();
requestValues[field_id["surface_temp_terrestrial_planet"]] = TransferItem.FindItem("SURFACE_TEMP", items).Values[0].Value.ToString();
if (volcanism)
{
requestValues[field_id["volcanism_type"]] = CapitalizeWords(TransferItem.FindItem("VOLCANISM_TYPE", items).Values[0].Text);
if (!volcanismTypes.ContainsKey(TransferItem.FindItem("VOLCANISM_TYPE", items).Values[0].Text))
{
errorString += "Volcanism type " + TransferItem.FindItem("VOLCANISM_TYPE", items).Values[0].Text + " is not valid." + Environment.NewLine;
}
}
requestValues[field_id["is_ringed_terrestrial_planet"]] = rings ? "Yes" : "No";
if (terraform)
{
requestValues[field_id["terraform_status"]] = TransferItem.FindItem("TERRAFORMING", items).Values[0].Text.TrimEnd(new char[] { '.' });
}
else
{
requestValues[field_id["terraform_status"]] = "None";
}
AddAtmosphereInformation(items, requestValues);
AddCompositionInformation(items, requestValues);
AddOrbitInformation(items, requestValues);
AddRotationInformation(items, requestValues);
if (rings)
{
AddRingInformation(items, requestValues);
}
}
private void CreateRequestValues(TransferItem[] items, Dictionary<string, string> requestValues)
{
RequireTextValue("SYSTEM", items);
RequireValueExists("BODY", items);
RequireValueExists("CUSTOM_CATEGORY", items);
RequireValueExists("CUSTOM_DESCRIPTION", items);
requestValues[field_id["user_login"]] = Properties.Settings.Default.IdentityName;
requestValues[field_id["user_api_key"]] = Properties.Settings.Default.IdentityKey;
requestValues[field_id["object_name"]] = TransferItem.FindItem("BODY", items).Values[0].Text;
requestValues[field_id["system_name"]] = TransferItem.FindItem("SYSTEM", items).Values[0].Text;
requestValues[field_id["first_discovered"]] = "";
requestValues[field_id["system_description"]] = TransferItem.FindItem("CUSTOM_CATEGORY", items).Values[0].Text;
requestValues[field_id["object_description"]] = TransferItem.FindItem("CUSTOM_DESCRIPTION", items).Values[0].Text;
if (TransferItem.FindItem("EARTH_MASSES", items) == null)
{
CreateRequestStar(items, requestValues);
}
else if (TransferItem.FindItem("DESCRIPTION", items).Values[0].Text.StartsWith("Giant"))
{
CreateRequestGiant(items, requestValues);
}
else
{
CreateRequestPlanet(items, requestValues);
}
}
public static string GetDataTextClassic(TransferItem[] array)
{
string output = "";
foreach (TransferItem ti in array)
{
if (ti == null)
{
continue;
}
if (ti.Name == WellKnownItems.Description && ti.Values.Count > 0)
{
output += ti.Values[0].Text + Environment.NewLine;
}
}
foreach (TransferItem ti in array)
{
if (ti == null)
{
output += "??????" + Environment.NewLine;
continue;
}
if (ti.Name == WellKnownItems.Description)
{
continue;
}
if (ti.Name == "DELIMITER")
{
output += "DELIMITER" + Environment.NewLine;
continue;
}
if (ti.Name == WellKnownItems.ScanDate)
{
continue;
}
output += ti.Name;
foreach (TransferItemValue tv in ti.Values)
{
if (double.IsNaN(tv.Value))
{
output += " " + tv.Text.ToString() + Environment.NewLine;
}
else
{
string format = tv.Value > 1e10 ? tv.Value.ToString("e") : tv.Value.ToString();
output += " " + "[" + format + "]";
if (!string.IsNullOrEmpty(tv.Unit) && itemConfig.LookupUnit(tv.Unit) != null)
{
output += " " + itemConfig.LookupUnit(tv.Unit);
}
if (!string.IsNullOrEmpty(tv.Text))
{
output += " " + tv.Text;
}
output += Environment.NewLine;
}
}
}
return output;
}
