/// <summary>
/// Imports data from a serialization object.
/// </summary>
/// <param name="serial"></param>
private void Import(SerializableCCPCharacter serial)
{
Import((SerializableSettingsCharacter)serial);
// Skill queue
SkillQueue.Import(serial.SkillQueue);
// Market orders
MarketOrdersImport(serial.MarketOrders);
// Contracts
ContractsImport(serial.Contracts);
// Industry jobs
IndustryJobsImport(serial.IndustryJobs);
// EVE mail messages IDs
EVEMailMessages.Import(serial.EveMailMessagesIDs);
// EVE notifications IDs
EVENotifications.Import(serial.EveNotificationsIDs);
// Kill Logs
KillLog.ImportFromCacheFile();
// Fire the global event
EveMonClient.OnCharacterUpdated(this);
}
/// <summary>
/// Constructor for CCP Characters.
/// </summary>
/// <param name="uri">URI of the character</param>
/// <param name="result">Serialized Result</param>
public UriCharacterEventArgs(Uri uri, SerializableCCPCharacter result)
{
m_uri = uri;
m_result = result;
HasError = false;
Error = String.Empty;
}
/// <summary>
/// Updates this character with the given informations
/// </summary>
/// <param name="identity"></param>
/// <param name="uri"></param>
/// <param name="result"></param>
internal void Update(CharacterIdentity identity, Uri uri, SerializableCCPCharacter result)
{
m_characterID = identity.CharacterID;
m_identity = identity;
m_uri = uri;
Import(result);
}
/// <summary>
/// Asynchronously adds a character from the given uri, adding a new identity when needed.
/// </summary>
/// <param name="uri">The uri to load the character sheet from</param>
/// <exception cref="System.ArgumentNullException">uri</exception>
public static async Task <UriCharacterEventArgs> TryAddOrUpdateFromUriAsync(Uri uri)
{
uri.ThrowIfNull(nameof(uri));
// It's a web address, let's do it in an async way
if (!uri.IsFile)
{
CCPAPIResult <SerializableAPICharacterSheet> result =
await
Util.DownloadAPIResultAsync <SerializableAPICharacterSheet>(uri, false, null, APIProvider.RowsetsTransform);
return(new UriCharacterEventArgs(uri, result));
}
// We have a file, let's just deserialize it synchronously
string xmlRootElement = Util.GetXmlRootElement(uri);
switch (xmlRootElement.ToLower(CultureConstants.DefaultCulture))
{
case "eveapi":
CCPAPIResult <SerializableAPICharacterSheet> apiResult =
Util.DeserializeAPIResultFromFile <SerializableAPICharacterSheet>(uri.LocalPath,
APIProvider.RowsetsTransform);
return(new UriCharacterEventArgs(uri, apiResult));
case "serializableccpcharacter":
try
{
SerializableCCPCharacter ccpResult =
Util.DeserializeXmlFromFile <SerializableCCPCharacter>(uri.LocalPath);
return(new UriCharacterEventArgs(uri, ccpResult));
}
catch (NullReferenceException ex)
{
return(new UriCharacterEventArgs(uri,
$"Unable to load file (SerializableCCPCharacter). ({ex.Message})"));
}
case "serializableuricharacter":
try
{
SerializableUriCharacter uriCharacterResult =
Util.DeserializeXmlFromFile <SerializableUriCharacter>(uri.LocalPath);
return(new UriCharacterEventArgs(uri, uriCharacterResult));
}
catch (NullReferenceException ex)
{
return(new UriCharacterEventArgs(uri,
$"Unable to load file (SerializableUriCharacter). ({ex.Message})"));
}
default:
return(new UriCharacterEventArgs(uri, "Format Not Recognized"));
}
}
/// <summary>
/// Updates the given character.
/// </summary>
/// <param name="character"></param>
/// <exception cref="System.ArgumentNullException">character</exception>
public void UpdateCharacter(UriCharacter character)
{
character.ThrowIfNull(nameof(character));
CharacterIdentity identity = GetIdentity(m_result);
// Updates
if (m_apiResult != null)
{
character.Update(identity, Uri, m_apiResult);
}
else
{
SerializableCCPCharacter ccpCharacter = m_result as SerializableCCPCharacter;
character.Update(identity, Uri, ccpCharacter);
}
}
internal SerializableCCPCharacter CreateCharacter()
{
var serial = new SerializableCCPCharacter()
{
ID = 9999999,
Name = tbCharacterName.Text,
Birthday = DateTime.UtcNow,
Race = m_race.ToString(),
BloodLine = m_bloodline.ToString().Replace("_", "-"),
Ancestry = m_ancestry.ToString().Replace("_", " "),
Gender = m_gender.ToString(),
CorporationName = "Blank Character's Corp",
CorporationID = 9999999,
CloneName = "Clone Grade Alpha",
CloneSkillPoints = 900000,
Balance = 0,
Attributes = new SerializableCharacterAttributes()
{
Intelligence = EveConstants.CharacterBaseAttributePoints + 3,
Memory = EveConstants.CharacterBaseAttributePoints + 3,
Perception = EveConstants.CharacterBaseAttributePoints + 3,
Willpower = EveConstants.CharacterBaseAttributePoints + 3,
Charisma = EveConstants.CharacterBaseAttributePoints + 2
},
ImplantSets = new SerializableImplantSetCollection()
{
API = new SerializableSettingsImplantSet()
{
Name = "Implants from API"
},
OldAPI = new SerializableSettingsImplantSet()
{
Name = "Previous implants from the API"
},
},
Skills = GetSkillsForRace(),
Certificates = new List <SerializableCharacterCertificate>(),
};
return(serial);
}
/// <summary>
/// Create a serializable character sheet for this character.
/// </summary>
/// <returns></returns>
public override SerializableSettingsCharacter Export()
{
SerializableCCPCharacter serial = new SerializableCCPCharacter();
Export(serial);
// Skill queue
serial.SkillQueue.AddRange(SkillQueue.Export());
// Market orders
serial.MarketOrders.AddRange(MarketOrdersExport());
// Contracts
serial.Contracts.AddRange(ContractsExport());
// Industry jobs
serial.IndustryJobs.AddRange(IndustryJobsExport());
// Eve mail messages IDs
serial.EveMailMessagesIDs = EVEMailMessages.Export();
// Eve notifications IDs
serial.EveNotificationsIDs = EVENotifications.Export();
// WalletTransactions to XML
WalletTransactions.ExportToCacheFile();
serial.LastWalletTransactionTime = WalletTransactions.Count == 0 ? DateTime.MinValue : WalletTransactions.Max(wt => wt.Date);
// Last API updates
if (QueryMonitors.Any())
{
m_lastAPIUpdates = QueryMonitors.Select(
monitor => new SerializableAPIUpdate
{
Method = monitor.Method.ToString(),
Time = monitor.LastUpdate
}).ToList();
}
serial.LastUpdates.AddRange(m_lastAPIUpdates);
return(serial);
}
/// <summary>
/// Deserializes a settings file from an old format.
/// </summary>
/// <param name="filename"></param>
/// <returns></returns>
private static SerializableSettings DeserializeOldFormat(string filename)
{
var oldSerial = Util.DeserializeXML <OldSettings>(filename, Util.LoadXSLT(Properties.Resources.SettingsAndPlanImport));
var serial = new SerializableSettings();
// Accounts
serial.Accounts.AddRange(oldSerial.Accounts);
// Characters
foreach (var oldCharacter in oldSerial.Characters)
{
// Adds the char both to the characters list and the monitored characters list.
var character = new SerializableCCPCharacter {
ID = oldCharacter.ID,
Name = oldCharacter.Name,
Guid = Guid.NewGuid()
};
serial.MonitoredCharacters.Add(new MonitoredCharacterSettings {
CharacterGuid = character.Guid
});
serial.Characters.Add(character);
}
// Plans
foreach (var oldPlan in oldSerial.Plans)
{
// Look for the owner by his name
var owner = serial.Characters.SingleOrDefault(x => x.Name == oldPlan.Owner);
if (owner == null)
{
continue;
}
// Imports the plan
var plan = new SerializablePlan {
Owner = owner.Guid, Name = oldPlan.Name
};
plan.Entries.AddRange(oldPlan.Entries);
serial.Plans.Add(plan);
}
return(serial);
}
/// <summary>
/// Create a serializable character sheet for this character.
/// </summary>
/// <returns></returns>
public override SerializableSettingsCharacter Export()
{
SerializableCCPCharacter serial = new SerializableCCPCharacter();
Export(serial);
// Skill queue
serial.SkillQueue.AddRange(SkillQueue.Export());
// Market orders
serial.MarketOrders.AddRange(MarketOrdersExport());
// Contracts
serial.Contracts.AddRange(ContractsExport());
// ContractBids
serial.ContractBids.AddRange(CharacterContractBids.Export());
// Industry jobs
serial.IndustryJobs.AddRange(IndustryJobsExport());
// Eve mail messages IDs
serial.EveMailMessagesIDs = EVEMailMessages.Export();
// Eve notifications IDs
serial.EveNotificationsIDs = EVENotifications.Export();
// Last API updates
if (QueryMonitors.Any())
{
m_lastAPIUpdates = QueryMonitors.Select(
monitor => new SerializableAPIUpdate
{
Method = monitor.Method.ToString(),
Time = monitor.LastUpdate
}).ToList();
}
serial.LastUpdates.AddRange(m_lastAPIUpdates);
return(serial);
}
/// <summary>
/// Create a serializable character sheet for this character
/// </summary>
/// <returns></returns>
public override SerializableSettingsCharacter Export()
{
var serial = new SerializableCCPCharacter();
Export(serial);
// Last API updates
foreach (var monitor in m_monitors)
{
var update = new SerializableAPIUpdate {
Method = monitor.Method, Time = monitor.LastUpdate
};
serial.LastUpdates.Add(update);
}
// Skill queue
serial.MarketOrders = m_marketOrders.Export();
serial.SkillQueue = m_queue.Export();
return(serial);
}
/// <summary>
/// Imports the character identities from a serialization object.
/// </summary>
/// <param name="serial"></param>
internal void Import(IEnumerable <SerializableSettingsCharacter> serial)
{
// Clear the API key on every identity
foreach (CharacterIdentity id in EveMonClient.CharacterIdentities)
{
id.APIKeys.Clear();
}
// Unsubscribe any event handlers in character
foreach (Character character in Items)
{
character.Dispose();
}
// Import the characters, their identies, etc
Items.Clear();
foreach (SerializableSettingsCharacter serialCharacter in serial)
{
// Gets the identity or create it
CharacterIdentity id = EveMonClient.CharacterIdentities[serialCharacter.ID] ??
EveMonClient.CharacterIdentities.Add(serialCharacter.ID, serialCharacter.Name,
serialCharacter.CorporationID, serialCharacter.CorporationName,
serialCharacter.AllianceID, serialCharacter.AllianceName,
serialCharacter.FactionID, serialCharacter.FactionName);
// Imports the character
SerializableCCPCharacter ccpCharacter = serialCharacter as SerializableCCPCharacter;
if (ccpCharacter != null)
{
Items.Add(new CCPCharacter(id, ccpCharacter));
}
else
{
SerializableUriCharacter uriCharacter = serialCharacter as SerializableUriCharacter;
Items.Add(new UriCharacter(id, uriCharacter));
}
}
// Notify the change
EveMonClient.OnCharacterCollectionChanged();
}
public SerializableCCPCharacter ToSerializableCCPCharacter()
{
var ccpCharacter = new SerializableCCPCharacter();
ccpCharacter.Name = Name;
ccpCharacter.ID = CharacterId;
ccpCharacter.Race = Race;
ccpCharacter.BloodLine = BloodLine;
ccpCharacter.Gender = Gender;
ccpCharacter.CorporationName = CorpName;
ccpCharacter.CorporationID = 0;
ccpCharacter.CloneName = CloneName;
ccpCharacter.CloneSkillPoints = CloneSkillPoints;
ccpCharacter.Balance = Balance;
ccpCharacter.Attributes = Attributes.ToSerializableAttributes();
ccpCharacter.ImplantSets.API = AttributeEnhancers.ToSerializableImplantSet();
ccpCharacter.Skills = CreateSerializableCharacterSkillList();
ccpCharacter.Certificates = CreateSerializableCharacterCertificateList();
return(ccpCharacter);
}
/// <summary>
/// Imports data from a serialization object
/// </summary>
/// <param name="serial"></param>
public void Import(SerializableCCPCharacter serial)
{
Import((SerializableSettingsCharacter)serial);
// Training queue
m_marketOrders.Import(serial.MarketOrders);
m_queue.Import(serial.SkillQueue);
m_queue.UpdateOnTimerTick();
// Last API updates
foreach (var lastUpdate in serial.LastUpdates)
{
var monitor = m_monitors[lastUpdate.Method] as IQueryMonitorEx;
if (monitor != null)
{
monitor.Reset(lastUpdate.Time);
}
}
// Fire the global event
EveClient.OnCharacterChanged(this);
}
/// <summary>
/// Creates the character.
/// </summary>
/// <returns></returns>
private static SerializableCCPCharacter CreateCharacter()
{
SerializableCCPCharacter serial = new SerializableCCPCharacter
{
ID = UriCharacter.BlankCharacterID,
Name = CharacterName,
Birthday = DateTime.UtcNow,
Race = Race.ToString(),
BloodLine = Bloodline.ToString().Replace("_", "-"),
Ancestry = Ancestry.ToString().Replace("_", " "),
Gender = Gender.ToString(),
CorporationName = "Blank Character's Corp",
CorporationID = 9999999,
Balance = 0,
Attributes = new SerializableCharacterAttributes
{
Intelligence =
EveConstants.CharacterBaseAttributePoints + 3,
Memory = EveConstants.CharacterBaseAttributePoints + 3,
Perception =
EveConstants.CharacterBaseAttributePoints + 3,
Willpower =
EveConstants.CharacterBaseAttributePoints + 3,
Charisma =
EveConstants.CharacterBaseAttributePoints + 2
},
ImplantSets = new SerializableImplantSetCollection
{
ActiveClone = new SerializableSettingsImplantSet
{
Name = "Active Clone"
},
},
};
serial.Skills.AddRange(GetSkillsForRace());
return(serial);
}
/// <summary>
/// Create a serializable character sheet for this character
/// </summary>
/// <returns></returns>
public override SerializableSettingsCharacter Export()
{
var serial = new SerializableCCPCharacter();
Export(serial);
// Skill queue
serial.SkillQueue = m_queue.Export();
// Market orders
serial.MarketOrders = m_marketOrders.Export();
// Industry jobs
serial.IndustryJobs = m_industryJobs.Export();
// Research points
serial.ResearchPoints = m_researchPoints.Export();
// Eve mail messages IDs
serial.EveMailMessagesIDs = m_eveMailMessages.Export();
// Eve notifications IDs
serial.EveNotificationsIDs = m_eveNotifications.Export();
// Last API updates
foreach (var monitor in m_monitors)
{
var update = new SerializableAPIUpdate
{
Method = monitor.Method,
Time = monitor.LastUpdate
};
serial.LastUpdates.Add(update);
}
return(serial);
}
/// <summary>
/// Saves the blank character.
/// </summary>
/// <param name="serial">The serial.</param>
private void Save(SerializableCCPCharacter serial)
{
using (SaveFileDialog fileDialog = new SaveFileDialog())
{
fileDialog.Title = "Save Blank Character";
fileDialog.Filter = "Blank Character CCPXML (*.xml) | *.xml";
fileDialog.FileName = String.Format(CultureConstants.DefaultCulture, "{0}.xml", serial.Name);
fileDialog.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.Personal);
DialogResult saveFile = fileDialog.ShowDialog();
if (saveFile == DialogResult.OK)
{
// Disabling control edit ability
blankCharacterControl.Enabled = false;
var xmlDoc = Util.SerializeToXmlDocument(serial.GetType(), serial);
string content = Util.GetXMLStringRepresentation(xmlDoc);
FileHelper.OverwriteOrWarnTheUser(fileDialog.FileName, fs =>
{
using (var writer = new StreamWriter(fs, Encoding.UTF8))
{
writer.Write(content);
writer.Flush();
writer.Close();
}
return(true);
});
m_filename = fileDialog.FileName;
m_fileSaved = true;
}
else
{
m_fileSaved = false;
}
}
}
/// <summary>
/// Saves the blank character.
/// </summary>
/// <param name="callback">The callback.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException">callback</exception>
public static async Task SaveAsync(Action callback)
{
callback.ThrowIfNull(nameof(callback));
SerializableCCPCharacter serial = CreateCharacter();
using (SaveFileDialog fileDialog = new SaveFileDialog())
{
fileDialog.Title = @"Save Blank Character";
fileDialog.Filter = @"Blank Character CCPXML (*.xml) | *.xml";
fileDialog.FileName = $"{serial.Name}.xml";
fileDialog.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.Personal);
DialogResult result = fileDialog.ShowDialog();
if (result != DialogResult.OK)
{
return;
}
XmlDocument xmlDoc = (XmlDocument)Util.SerializeToXmlDocument(serial);
string content = Util.GetXmlStringRepresentation(xmlDoc);
await FileHelper.OverwriteOrWarnTheUserAsync(fileDialog.FileName,
async fs =>
{
using (StreamWriter writer = new StreamWriter(fs, Encoding.UTF8))
{
await writer.WriteAsync(content);
await writer.FlushAsync();
await fs.FlushAsync();
}
return(true);
});
s_filename = fileDialog.FileName;
callback.Invoke();
}
}
/// <summary>
/// Imports data from a serialization object
/// </summary>
/// <param name="serial"></param>
public void Import(SerializableCCPCharacter serial)
{
Import((SerializableSettingsCharacter)serial);
// Skill queue
m_queue.Import(serial.SkillQueue);
m_queue.UpdateOnTimerTick();
// Market orders
m_marketOrders.Import(serial.MarketOrders);
// Industry jobs
m_industryJobs.Import(serial.IndustryJobs);
// Research points
m_researchPoints.Import(serial.ResearchPoints);
// EVE mail messages IDs
m_eveMailMessages.Import(serial.EveMailMessagesIDs);
// EVE notifications IDs
m_eveNotifications.Import(serial.EveNotificationsIDs);
// Last API updates
foreach (var lastUpdate in serial.LastUpdates)
{
var monitor = m_monitors[lastUpdate.Method] as IQueryMonitorEx;
if (monitor != null)
{
monitor.Reset(lastUpdate.Time);
}
}
// Fire the global event
EveClient.OnCharacterChanged(this);
}
/// <summary>
/// Deserialization constructor
/// </summary>
/// <param name="identity">The identitiy for this character</param>
/// <param name="serial">A deserialization object for characters</param>
internal CCPCharacter(CharacterIdentity identity, SerializableCCPCharacter serial)
: this(identity, serial.Guid)
{
Import(serial);
}
/// <summary>
/// Exported character constructor
/// </summary>
/// <param name="identity">The identitiy for this character</param>
/// <param name="uri">The uri the provided deserialization object was acquired from</param>
/// <param name="source">A deserialization object for CcpCharacters</param>
internal UriCharacter(CharacterIdentity identity, Uri uri, SerializableCCPCharacter serial)
: base(identity, Guid.NewGuid())
{
m_uri = uri;
Import(serial);
}
/// <summary>
/// Adds a character from a deserialization object
/// </summary>
/// <param name="ccpCharacter"></param>
internal void Add(SerializableCCPCharacter ccpCharacter)
{
m_ccp = new CCPCharacter(m_characterID, ccpCharacter);
}
/// <summary>
/// Deserialization constructor.
/// </summary>
/// <param name="identity">The identity for this character</param>
/// <param name="serial">A deserialization object for characters</param>
internal CCPCharacter(CharacterIdentity identity, SerializableCCPCharacter serial)
: this(identity, serial.Guid)
{
Import(serial);
m_lastAPIUpdates = serial.LastUpdates.ToList();
}
