/// <summary>
/// Refresh the packaged volume for a ship fit.
/// </summary>
/// <param name="shipFit">A doctrine ships ship fit.</param>
internal void RefreshShipFitPackagedVolume(ShipFit shipFit)
{
shipFit.FitPackagedVolume = 0;
// Ensure that there are ship fit components to be refreshed.
if (shipFit.ShipFitComponents != null && shipFit.ShipFitComponents.Any() != false)
{
foreach (var item in shipFit.ShipFitComponents)
{
// Add the value to the shipfit's total volume.
shipFit.FitPackagedVolume += item.Component.Volume * item.Quantity;
}
// Update the ship fit in the database.
this.doctrineShipsRepository.UpdateShipFit(shipFit);
// Commit changes to the database.
this.doctrineShipsRepository.Save();
}
}
/// <summary>
/// Generate and refresh the EVE IGB fitting string for a ship fit.
/// </summary>
/// <param name="shipFit">A doctrine ships ship fit.</param>
internal void RefreshFittingString(ShipFit shipFit)
{
string fittingString = string.Empty;
// Generate the fitting string.
fittingString += shipFit.HullId + ":";
foreach (var item in shipFit.ShipFitComponents)
{
fittingString += item.ComponentId + ";" + item.Quantity + ":";
}
fittingString += ":";
// Update the fitting string and ship fit in the database.
shipFit.FittingString = fittingString;
this.doctrineShipsRepository.UpdateShipFit(shipFit);
// Commit changes to the database.
this.doctrineShipsRepository.Save();
}
/// <summary>
/// Generate and returns an EFT fitting string for a ship fit.
/// </summary>
/// <param name="shipFitId">The id of a doctrine ships ship fit.</param>
/// <param name="accountId">The currently logged-in account id for security checking.</param>
/// <returns>Returns a string containing an EFT fitting or an empty string if an error occurs.</returns>
internal string GetEftFittingString(int shipFitId, int accountId)
{
string eftFitting = string.Empty;
ShipFit shipFit = this.doctrineShipsRepository.GetShipFit(shipFitId);
if (shipFit != null)
{
if (accountId == shipFit.AccountId)
{
// Generate the fitting string.
eftFitting += "[" + shipFit.Hull + ", " + shipFit.Name + "]" + Environment.NewLine;
List <SlotType> expectedSlotTypes = new List <SlotType>();
expectedSlotTypes.Add(SlotType.Low);
expectedSlotTypes.Add(SlotType.Medium);
expectedSlotTypes.Add(SlotType.High);
expectedSlotTypes.Add(SlotType.Rig);
expectedSlotTypes.Add(SlotType.Subsystem);
expectedSlotTypes.Add(SlotType.Drone);
expectedSlotTypes.Add(SlotType.Cargo);
foreach (SlotType slot in expectedSlotTypes)
{
var itemsInSlot = shipFit.ShipFitComponents.Where(component => component.SlotType == slot);
foreach (var item in itemsInSlot)
{
eftFitting += GenerateModuleEFTLine(item);
}
if (itemsInSlot.Count() > 0)
{
eftFitting += Environment.NewLine;
}
}
}
}
return(eftFitting);
}
/// <summary>
/// Updates the state of a ship fit's contract availability monitoring.
/// </summary>
/// <param name="accountId">The account Id of the requestor. The account Id should own the sales agent being changed.</param>
/// <param name="shipFitId">The id of the ship fit to be changed.</param>
/// <param name="isActive">The required boolean state.</param>
/// <returns>Returns true if the change was successful or false if not.</returns>
internal bool UpdateShipFitMonitoringState(int accountId, int shipFitId, bool isActive)
{
ShipFit shipFit = this.doctrineShipsRepository.GetShipFit(shipFitId);
if (shipFit != null)
{
// If the account Id matches the account Id of the ship fit being changed, continue.
if (accountId == shipFit.AccountId)
{
// Change the state of the ship fit and log the event.
if (isActive == true)
{
shipFit.IsMonitored = true;
}
else
{
shipFit.IsMonitored = false;
}
this.doctrineShipsRepository.UpdateShipFit(shipFit);
this.doctrineShipsRepository.Save();
if (isActive == true)
{
logger.LogMessage("Contract Availability Monitoring For Ship Fit '" + shipFit.Name + "' Successfully Enabled. Account Id: " + shipFit.AccountId, 2, "Message", MethodBase.GetCurrentMethod().Name);
}
else
{
logger.LogMessage("Contract Availability Monitoring For Ship Fit '" + shipFit.Name + "' Successfully Disabled. Account Id: " + shipFit.AccountId, 2, "Message", MethodBase.GetCurrentMethod().Name);
}
return(true);
}
}
return(false);
}
/// <summary>
/// Generate and refresh the fitting hash, unique to an account.
/// </summary>
/// <param name="shipFit">A doctrine ships ship fit.</param>
/// <param name="accountId">The account Id for which a fitting hash should be generated.</param>
internal void RefreshFittingHash(ShipFit shipFit, int accountId)
{
string concatComponents = string.Empty;
IEnumerable <ShipFitComponent> compressedShipFitComponents = new List <ShipFitComponent>();
if (shipFit.ShipFitComponents != null && shipFit.ShipFitComponents.Any() == true)
{
// Compress the ship fit components list, removing duplicates but adding the quantities.
compressedShipFitComponents = shipFit.ShipFitComponents
.OrderBy(o => o.ComponentId)
.GroupBy(u => u.ComponentId)
.Select(x => new ShipFitComponent()
{
ComponentId = x.Key,
Quantity = x.Sum(p => p.Quantity)
});
// Concatenate all components and their quantities into a single string.
foreach (var item in compressedShipFitComponents)
{
concatComponents += item.ComponentId + item.Quantity;
}
// Generate a hash for the fitting and salt it with the account id. This permits identical fits across accounts.
shipFit.FittingHash = Security.GenerateHash(concatComponents, accountId.ToString());
}
else
{
// There are no components so generate a random hash.
shipFit.FittingHash = Security.GenerateHash(Security.GenerateRandomString(32), Security.GenerateSalt(6));
}
// Commit changes to the database.
this.doctrineShipsRepository.UpdateShipFit(shipFit);
this.doctrineShipsRepository.Save();
}
public IEnumerable <IBotTask> GetTasks(Bot bot)
{
//yield return new BotTask { Component = EnumerateConfigDiagnostics() };
yield return(new EnableInfoPanelCurrentSystem {
MemoryMeasurement = bot.MemoryMeasurementAtTime?.Value
});
var saveShipTask = new SaveShipTask {
Bot = bot
};
yield return(saveShipTask);
var shipFit = new ShipFit(bot.MemoryMeasurementAccu?.ShipUiModule,
new[]
{
new[]
{
new ShipFit.ModuleInfo(ShipFit.ModuleType.Etc),
},
new[]
{
new ShipFit.ModuleInfo(ShipFit.ModuleType.Hardener),
new ShipFit.ModuleInfo(ShipFit.ModuleType.Hardener),
new ShipFit.ModuleInfo(ShipFit.ModuleType.Hardener),
},
new[]
{
new ShipFit.ModuleInfo(ShipFit.ModuleType.Etc),
new ShipFit.ModuleInfo(ShipFit.ModuleType.Etc)
}
});
yield return(bot.EnsureIsActive(shipFit.GetAlwaysActiveModules().Select(m => m.UiModule)));
//var moduleUnknown = MemoryMeasurementAccu?.ShipUiModule?.FirstOrDefault(module => null == module?.TooltipLast?.Value);
//yield return new BotTask { ClientActions = new[] { moduleUnknown?.MouseMove() } };
if (!saveShipTask.AllowRoam)
{
yield break;
}
var combatTask = new CombatTask {
bot = bot
};
yield return(combatTask);
if (!saveShipTask.AllowAnomalyEnter)
{
yield break;
}
yield return(new UndockTask(bot.MemoryMeasurementAtTime?.Value));
if (combatTask.Completed)
{
if (!currentAnomalyLooted)
{
var lootTask = new LootTask(bot);
yield return(lootTask);
if (!lootTask.HasWreckToLoot)
{
currentAnomalyLooted = true;
}
}
yield return(new AnomalyEnter {
bot = bot
});
}
}
/// <summary>
/// Updates a ship fit for a particular account.
/// </summary>
/// <param name="shipFit">A partially populated ship fit object to be updated.</param>
/// <returns>Returns a validation result object.</returns>
public IValidationResult UpdateShipFit(ShipFit shipFit)
{
return(ShipFitManager.UpdateShipFit(shipFit));
}
public IValidationResult ShipFit(ShipFit shipFit)
{
return(ShipFitCheck.ShipFit(shipFit));
}
public ShipFit CreateShipFit(ShipFit shipFit)
{
return(ShipFitOperations.CreateShipFit(shipFit));
}
/// <summary>
/// Imports a Doctrine Ships ship fit from a string formatted in the standard CCP Xml format.
/// </summary>
/// <param name="toParse">A ship fitting string formatted in the standard CCP Xml format.</param>
/// <param name="accountId">The account for which the ship fit should be imported.</param>
/// <returns>Returns a list of populated ship fit objects or an empty list if the process fails.</returns>
internal IEnumerable <ShipFit> ImportShipFitEveXml(string toParse, int accountId)
{
ICollection <ShipFit> shipFits = new List <ShipFit>();
XDocument xmlDoc;
// Does the account exist?
if (this.doctrineShipsRepository.GetAccount(accountId) != null)
{
try
{
using (StringReader stringReader = new StringReader(toParse))
{
xmlDoc = XDocument.Load(stringReader);
}
foreach (XElement fitting in xmlDoc.Root.Elements("fitting"))
{
// Read and cleanse the initial xml elements containing the fitting name, description and ship type.
string shipFitName = String.Empty;
string shipFitHull = String.Empty;
string shipFitRole = String.Empty;
shipFitName = Conversion.StringToSafeString((string)fitting.Attribute("name") ?? String.Empty);
if (fitting.Element("shipType") != null)
{
shipFitHull = Conversion.StringToSafeString((string)fitting.Element("shipType").Attribute("value") ?? String.Empty);
}
if (fitting.Element("description") != null)
{
shipFitRole = Conversion.StringToSafeString((string)fitting.Element("description").Attribute("value") ?? String.Empty);
}
// Attempt to populate, validate and add a new ship fit to the database.
ShipFit newShipFit = this.AddShipFit(shipFitName, shipFitRole, shipFitHull, accountId);
// If the ship fit addition was successful, continue with the parse.
if (newShipFit != null)
{
// Add the ship fit to the list of successfully imported ship fits.
shipFits.Add(newShipFit);
// Instantiate a new list of ShipFitComponents.
ICollection <ShipFitComponent> shipFitComponents = new List <ShipFitComponent>();
// Add the ship hull itself to the list of ShipFitComponents.
this.AddComponent(newShipFit.Hull);
shipFitComponents.Add(new ShipFitComponent
{
ComponentId = newShipFit.HullId,
ShipFitId = newShipFit.ShipFitId,
SlotType = SlotType.Hull,
Quantity = 1
});
// Iterate through the 'hardware' xml elements containing the ship fitting components.
foreach (XElement component in fitting.Elements("hardware"))
{
// Attempt to add this parsed component to the database.
Component newComponent = this.AddComponent((string)component.Attribute("type") ?? String.Empty);
// Unless the component was not recognised, continue with the parse.
if (newComponent != null)
{
ShipFitComponent newShipFitComponent = new ShipFitComponent();
newShipFitComponent.ComponentId = newComponent.ComponentId;
newShipFitComponent.ShipFitId = newShipFit.ShipFitId;
switch (component.Attribute("slot").Value.Split(' ').FirstOrDefault())
{
case "hi":
newShipFitComponent.SlotType = SlotType.High;
break;
case "med":
newShipFitComponent.SlotType = SlotType.Medium;
break;
case "low":
newShipFitComponent.SlotType = SlotType.Low;
break;
case "rig":
newShipFitComponent.SlotType = SlotType.Rig;
break;
case "subsystem":
newShipFitComponent.SlotType = SlotType.Subsystem;
break;
case "drone":
newShipFitComponent.SlotType = SlotType.Drone;
break;
case "cargo":
newShipFitComponent.SlotType = SlotType.Cargo;
break;
default:
newShipFitComponent.SlotType = SlotType.Other;
break;
}
if (component.Attribute("qty") != null)
{
newShipFitComponent.Quantity = Conversion.StringToLong(component.Attribute("qty").Value);
}
else
{
newShipFitComponent.Quantity = 1;
}
// Add this component to the list.
shipFitComponents.Add(newShipFitComponent);
}
}
// Add the full list of components to the ship fit.
this.AddShipFitComponents(shipFitComponents);
// Now that all of the ship fit components have been added, refresh the total volume of the fit.
this.RefreshShipFitPackagedVolume(newShipFit);
// Generate and refresh the fitting string for the ship fit.
this.RefreshFittingString(newShipFit);
// Generate a fitting hash unique to this account.
this.RefreshFittingHash(newShipFit, accountId);
}
}
}
catch (System.FormatException e)
{
this.logger.LogMessage("An error occured while parsing the fitting Xml. Is the Xml format correct?", 0, "Message", MethodBase.GetCurrentMethod().Name);
this.logger.LogMessage(e.ToString(), 0, "Exception", MethodBase.GetCurrentMethod().Name);
}
catch (System.ArgumentException e)
{
this.logger.LogMessage("An error occured while parsing the fitting Xml. Is the Xml format correct?", 0, "Message", MethodBase.GetCurrentMethod().Name);
this.logger.LogMessage(e.ToString(), 0, "Exception", MethodBase.GetCurrentMethod().Name);
}
catch (System.Xml.XmlException e)
{
this.logger.LogMessage("An error occured while parsing the fitting Xml. Is the Xml format correct?", 0, "Message", MethodBase.GetCurrentMethod().Name);
this.logger.LogMessage(e.ToString(), 0, "Exception", MethodBase.GetCurrentMethod().Name);
}
catch (Exception)
{
throw;
}
}
return(shipFits);
}
public ShipFit AddShipFit(ShipFit shipFit)
{
return(ShipFitOperations.AddShipFit(shipFit));
}
public void UpdateShipFit(ShipFit shipFit)
{
ShipFitOperations.UpdateShipFit(shipFit);
}
internal ShipFit CreateShipFit(ShipFit shipFit)
{
shipFit.ObjectState = ObjectState.Added;
this.unitOfWork.Repository <ShipFit>().Insert(shipFit);
return(shipFit);
}
internal ShipFit AddShipFit(ShipFit shipFit)
{
this.unitOfWork.Repository <ShipFit>().Insert(shipFit);
return(shipFit);
}
internal void UpdateShipFit(ShipFit shipFit)
{
shipFit.ObjectState = ObjectState.Modified;
this.unitOfWork.Repository <ShipFit>().Update(shipFit);
}
