public IActionResult Put([FromBody] Hauler model)
{
try
{
if (!ModelState.IsValid)
{
return(InvalidModelStateResult());
}
if (!validateEntity(model))
{
return(InvalidModelStateResult());
}
if (repository.Get().Count(a => a.HaulerId.Equals(model.HaulerId)) == 0)
{
return(NotFound(Constants.ErrorMessages.NotFoundEntity));
}
return(Accepted(repository.Update(model)));
}
catch (Exception ex)
{
logger.LogError(ex.GetExceptionMessages());
return(StatusCode(StatusCodes.Status500InternalServerError, Constants.ErrorMessages.UpdateError));
}
}
public bool ValidateCode(Hauler model)
{
var existing = Get().FirstOrDefault(a => a.HaulerCode == model.HaulerCode);
if (existing == null)
{
return(true);
}
return(existing.HaulerId == model.HaulerId);
}
public IQueryable <Hauler> Get(Hauler parameters = null)
{
var sqlRawParams = GetSqlRawParameter(parameters);
if (sqlRawParams.SqlParameters.Count == 0)
{
return(dbContext.Haulers.AsNoTracking());
}
return(dbContext.Haulers.FromSqlRaw(sqlRawParams.SqlQuery, sqlRawParams.SqlParameters.ToArray()).AsNoTracking());
}
public IActionResult Get([FromQuery] Hauler parameters = null)
{
try
{
var model = repository.Get(parameters);
return(Ok(model));
}
catch (Exception ex)
{
logger.LogError(ex.GetExceptionMessages());
return(StatusCode(StatusCodes.Status500InternalServerError, Constants.ErrorMessages.FetchError));
}
}
private bool validateEntity(Hauler model)
{
var validCode = repository.ValidateCode(model);
if (!validCode)
{
ModelState.AddModelError(nameof(Hauler.HaulerCode), Constants.ErrorMessages.EntityExists("Code"));
}
var validName = repository.ValidateName(model);
if (!validName)
{
ModelState.AddModelError(nameof(Hauler.HaulerName), Constants.ErrorMessages.EntityExists("Name"));
}
return(ModelState.ErrorCount == 0);
}
public IActionResult Post([FromBody] Hauler model)
{
try
{
if (!ModelState.IsValid)
{
return(InvalidModelStateResult());
}
if (!validateEntity(model))
{
return(InvalidModelStateResult());
}
return(Accepted(repository.Create(model)));
}
catch (Exception ex)
{
logger.LogError(ex.GetExceptionMessages());
return(StatusCode(StatusCodes.Status500InternalServerError, Constants.ErrorMessages.CreateError));
}
}
public Hauler Update(Hauler model)
{
var entity = dbContext.Haulers.Find(model.HaulerId);
if (entity == null)
{
throw new Exception("Selected Record does not exists.");
}
entity.HaulerCode = model.HaulerCode;
entity.HaulerName = model.HaulerName;
entity.ContactPerson = model.ContactPerson;
entity.ContactNum = model.ContactNum;
entity.Location = model.Location;
entity.IsActive = model.IsActive;
dbContext.Haulers.Update(entity);
dbContext.SaveChanges();
return(entity);
}
public IActionResult ValidateName([FromBody] Hauler model)
{
if (model == null)
{
return(NotFound());
}
if (General.IsDevelopment)
{
logger.LogDebug(ModelState.ToJson());
}
var result = repository.ValidateName(model);
if (result)
{
return(Accepted(true));
}
else
{
return(UnprocessableEntity(Constants.ErrorMessages.EntityExists("Name")));
}
}
public void MigrateOldDb()
{
var oldHaulers = dbContext.HaulersOld.AsNoTracking().ToList();
foreach (var oldHauler in oldHaulers)
{
var hauler = new Hauler()
{
IsActive = oldHauler.Status,
ContactNum = oldHauler.ContactNo,
ContactPerson = oldHauler.ContactPerson,
HaulerCode = oldHauler.HaulerCode,
HaulerIdOld = oldHauler.HaulerID,
HaulerName = oldHauler.HaulerName,
Location = oldHauler.HaulerName,
};
dbContext.Haulers.Add(hauler);
dbContext.SaveChanges();
}
;
}
public SqlRawParameter GetSqlRawParameter(Hauler parameters)
{
if (parameters == null)
{
return(new SqlRawParameter());
}
var sqlQry = new StringBuilder();
sqlQry.AppendLine("SELECT * FROM Haulers");
var whereClauses = new List <string>();
var sqlParams = new List <SqlParameter>();
if (!parameters.HaulerCode.IsNull())
{
sqlParams.Add(new SqlParameter(nameof(parameters.HaulerCode).Parametarize(), parameters.HaulerCode));
whereClauses.Add($"{nameof(parameters.HaulerCode)} = {nameof(parameters.HaulerCode).Parametarize()}");
}
if (!parameters.HaulerName.IsNull())
{
sqlParams.Add(new SqlParameter(nameof(parameters.HaulerName).Parametarize(), parameters.HaulerName));
whereClauses.Add($"{nameof(parameters.HaulerName)} = {nameof(parameters.HaulerName).Parametarize()}");
}
if (!parameters.IsActive.IsNull())
{
sqlParams.Add(new SqlParameter(nameof(parameters.IsActive).Parametarize(), parameters.IsActive));
whereClauses.Add($"{nameof(parameters.IsActive)} = {nameof(parameters.IsActive).Parametarize()}");
}
if (whereClauses.Count > 0)
{
sqlQry.AppendLine(" WHERE ");
sqlQry.AppendLine(String.Join(" AND ", whereClauses.ToArray()));
}
return(new SqlRawParameter()
{
SqlParameters = sqlParams, SqlQuery = sqlQry.ToString()
});
}
public override bool Initialize()
{
IsCleanedUpOutOfFrame = false;
_isxeveProvider = new IsxeveProvider();
_eveWindowProvider = new EveWindowProvider();
#region Core object construction
//Background stuff
Logging = new Logging();
LogCallback = LogIsxeveMessage;
Tracing.AddCallback(LogCallback);
_mathUtility = new MathUtility();
Statistics = new Statistics();
EventCommunications = new EventCommunications(Logging);
FileManager = new FileManager();
//moduleManager and BehaviorManager
ModuleManager = new ModuleManager(_isxeveProvider, _eveWindowProvider);
//Me cache. Contains the other caches.
MeCache = new MeCache(_isxeveProvider, _eveWindowProvider);
//ConfigurationManager
Config = new Configuration();
ConfigurationManager = new ConfigurationManager(Config, MeCache);
Ship = new Ship(_isxeveProvider, _eveWindowProvider, MeCache, MeCache.Ship, Config.CargoConfig, Statistics, Config.MovementConfig);
//Entity Populator object
EntityProvider = new EntityProvider(_isxeveProvider);
//Other Cache and Data classes
MissionCache = new MissionCache(_isxeveProvider, _eveWindowProvider);
AgentCache = new AgentCache(FileManager, MeCache, Config, _eveWindowProvider);
BookMarkCache = new BookMarkCache(MeCache, EntityProvider, Logging, _isxeveProvider);
NpcBountyCache = new NpcBountyCache();
//EVEDB modules
PilotCache = new PilotCache();
AllianceCache = new AllianceCache(FileManager);
CorporationCache = new CorporationCache();
MissionDatabase = new MissionDatabase();
PossibleEwarNpcs = new PossibleEwarNpcs();
//Core Functionality Providers, not necessarily caches
TargetQueue = new TargetQueue(MeCache, EntityProvider, Config.MiningConfig, Config.MainConfig);
JetCan = new JettisonContainer(_eveWindowProvider);
Social = new Social(_isxeveProvider);
Station = new Station(_isxeveProvider, _eveWindowProvider);
AsteroidBelts = new AsteroidBelts(Config, MeCache, EntityProvider, BookMarkCache, Ship);
Bookmarks = new Bookmarks(MeCache, Station, Config, BookMarkCache, AsteroidBelts, _isxeveProvider);
Drones = new Drones(_isxeveProvider);
Fleet = new Fleet();
Alerts = new Alerts(Config, MeCache, Logging);
_anomalyProvider = new AnomalyProvider(MeCache.Ship);
_anomalyClaimTracker = new AnomalyClaimTracker(Logging, EventCommunications, MeCache);
_safespots = new Safespots(MeCache, BookMarkCache, Config.MovementConfig, MeCache.ToEntity, EntityProvider, _isxeveProvider, Ship, Social, _mathUtility, Logging);
Attackers = new Attackers(MeCache, Config, Ship, Drones, EntityProvider, Alerts, AsteroidBelts, PossibleEwarNpcs, TargetQueue, ModuleManager);
#endregion
#region ActionModule construction
//Action classes
Movement = new Movement(_isxeveProvider, EntityProvider, MeCache, _anomalyProvider, TargetQueue, Ship, Drones);
Targeting = new Targeting(Logging, Config.MaxRuntimeConfig, MeCache, Ship, Drones, Alerts, ModuleManager, TargetQueue, EntityProvider, Movement);
Offensive = new Offensive(Logging, TargetQueue, EntityProvider);
NonOffensive = new NonOffensive(MeCache, Config.MiningConfig, Config.DefenseConfig, EntityProvider, TargetQueue, Ship, Drones, Targeting, Movement);
Defense = new Defense(_isxeveProvider, EntityProvider, Ship, MeCache, Config.DefenseConfig, Social, Drones, Alerts, _safespots, Movement);
#endregion
#region Processor construction
MissionProcessor = new MissionProcessor(_eveWindowProvider, Movement);
#endregion
#region BehaviorModule construction
_moveToDropOffLocationPartialBehavior = new MoveToDropOffLocationPartialBehavior(Movement, EntityProvider, Config.CargoConfig, BookMarkCache, Bookmarks,
Config.MovementConfig, MeCache, _mathUtility, _isxeveProvider);
_dropOffCargoPartialBehavior = new DropOffCargoPartialBehavior(_eveWindowProvider, Config.CargoConfig, Config.MainConfig, Config.MiningConfig,
MeCache, Ship, Station, JetCan, EntityProvider, EventCommunications);
//Behavior classes
BehaviorManager = new BehaviorManager();
Mining = new Mining(Config.CargoConfig, Config.MainConfig, MeCache, Ship, EntityProvider,
_safespots, Movement, Social, Config.MovementConfig, AsteroidBelts, _moveToDropOffLocationPartialBehavior, _dropOffCargoPartialBehavior, Config.MiningConfig,
_isxeveProvider, BookMarkCache, TargetQueue);
Hauler = new Hauler(_eveWindowProvider, Config.CargoConfig, Config.MainConfig, Config.MiningConfig, MeCache, Ship, Station, JetCan, EntityProvider, EventCommunications,
_safespots, Movement, BookMarkCache, _moveToDropOffLocationPartialBehavior);
BoostCanOrca = new BoostCanOrca();
BoostOrca = new BoostOrca(BookMarkCache, Config.MiningConfig, Bookmarks, _safespots, Movement, Config.MainConfig, Ship, MeCache);
Freighter = new Freighter(_eveWindowProvider, Config.CargoConfig, Config.MainConfig,
Config.MiningConfig, MeCache, Ship, Station, JetCan, EntityProvider, EventCommunications, _moveToDropOffLocationPartialBehavior, _dropOffCargoPartialBehavior, Movement);
MissionRunner = new MissionRunner(Config, MissionCache, AgentCache, _eveWindowProvider);
JumpStabilityTest = new JumpStabilityTest();
Ratting = new Ratting(Social, MeCache, Bookmarks, Config.SalvageConfig, Config.RattingConfig, _anomalyProvider, EntityProvider, _anomalyClaimTracker, _safespots,
Movement, Ship, AsteroidBelts, Config.MovementConfig, Alerts, TargetQueue, Attackers);
#endregion
//StealthBotUI Interop construction
//SbUiCommunication = new SbUiCommunication();
#if DEBUG
LavishScript.ExecuteCommand("ISXEVE:Debug_SetHighPerfLogging[1]");
#endif
return(true);
}
public bool Delete(Hauler model)
{
dbContext.Haulers.Remove(model);
dbContext.SaveChanges();
return(true);
}
public Hauler Create(Hauler model)
{
dbContext.Haulers.Add(model);
dbContext.SaveChanges();
return(model);
}
public void Scan(long frame)
{
int prevNumSoldiers = (NumSoldiers.Count == 0) ? -1 : NumSoldiers[NumSoldiers.Count - 1].Val;
int prevNumMiners = (NumMiners.Count == 0) ? -1 : NumMiners[NumMiners.Count - 1].Val;
int prevNumDiggers = (NumDiggers.Count == 0) ? -1 : NumDiggers[NumDiggers.Count - 1].Val;
int prevNumHaulers = (NumHaulers.Count == 0) ? -1 : NumHaulers[NumHaulers.Count - 1].Val;
int prevNumDeployables = (NumDeployables.Count == 0) ? -1 : NumDeployables[NumDeployables.Count - 1].Val;
int prevNumCredit = (NumCredits.Count == 0) ? -1 : NumCredits[NumCredits.Count - 1].Val;
int curNumSoldiers = 0;
int curNumMiners = 0;
int curNumDiggers = 0;
int curNumHaulers = 0;
int curNumDeployables = 0;
int curNumCredit = faction.Credits;
for (int i = 0; i < faction.Entities.Length; i++)
{
if (faction.Entities[i] == null)
{
continue;
}
Soldier s = faction.Entities[i] as Soldier;
if (s != null)
{
curNumSoldiers++;
continue;
}
Miner m = faction.Entities[i] as Miner;
if (m != null)
{
curNumMiners++;
continue;
}
Hauler h = faction.Entities[i] as Hauler;
if (h != null)
{
curNumHaulers++;
continue;
}
Digger d = faction.Entities[i] as Digger;
if (d != null)
{
curNumDiggers++;
continue;
}
Deployable dep = faction.Entities[i] as Deployable;
if (dep != null)
{
curNumDeployables++;
continue;
}
}
if (prevNumSoldiers != curNumSoldiers)
{
NumSoldiers.Add(new TimeData <int>(frame, curNumSoldiers));
}
if (prevNumMiners != curNumMiners)
{
NumMiners.Add(new TimeData <int>(frame, curNumMiners));
}
if (prevNumHaulers != curNumHaulers)
{
NumHaulers.Add(new TimeData <int>(frame, curNumHaulers));
}
if (prevNumDiggers != curNumDiggers)
{
NumDiggers.Add(new TimeData <int>(frame, curNumDiggers));
}
if (prevNumDeployables != curNumDeployables)
{
NumSoldiers.Add(new TimeData <int>(frame, curNumDeployables));
}
if (prevNumCredit != curNumCredit)
{
NumSoldiers.Add(new TimeData <int>(frame, curNumCredit));
}
}
