public SystemView SetSystem(Models.System s)
{
SystemView newSystemView = s.GetSystemView();
HttpContext.Session.SetString(SessionKeySystem, JsonSerializer.Serialize(newSystemView));
return(newSystemView);
}
/// <summary>
/// Generates a report of a specific site's information
/// </summary>
/// <param name="siteId">The site to generate a report of</param>
/// <returns>Json value containing all information pertaining to specific site</returns>
private JsonResult SiteInfo(int siteId)
{
using (var context = new Data.ApplicationDbContext()) {
Models.Site dbSite = context.Sites.AsNoTracking().FirstOrDefault(s => s.SiteId == siteId);
if (dbSite == null)
{
return(Json(new { status_code = 1, status = "Site '" + siteId + "' does not exist." }));
}
//#if LOCAL
// using (MySqlConnection conn = new MySqlConnection(Startup.Configuration.GetConnectionString("LocalDatabase"))) {
//#else
// using (MySqlConnection conn = new MySqlConnection(Startup.Configuration.GetConnectionString("Database"))) {
//#endif
// conn.Open();
// MySqlCommand cmd = new MySqlCommand("");
// using (var reader = cmd.ExecuteReader()) {
// while (reader.Read()) {
// }
// }
// }
Models.Activation activation = context.Activations.AsNoTracking().FirstOrDefault(a => a.SiteId == siteId);;
Models.System system = context.Systems.AsNoTracking().FirstOrDefault(sys => sys.Id == dbSite.SystemId);
return(Json(new { status_code = 0, site = dbSite, activation, system }));
}
}
public Models.System AddSystem(Models.System system)
{
var s = _context.Systems.Add(system);
_context.SaveChanges();
return(s);
}
public MainForm(Models.System user)
{
InitializeComponent();
this.user = user;
LoadComponents();
LoadData();
}
private List <Link> GetLinkList(Models.System system)
{
List <Link> links = new List <Link>();
if (system.Dependants != null)
{
links.AddRange(
system.Dependants?
.Select(s =>
new Link()
{
Source = s.Name,
Target = system.Name,
Type = "Dependant"
})
);
}
if (system.Dependancies != null)
{
links.AddRange(
system.Dependancies?
.Select(s =>
new Link()
{
Source = system.Name,
Target = s.Name,
Type = "Dependancy"
})
);
}
return(links);
}
public SystemView Get([FromQuery] int?index)
{
WorldBuilder wb = new WorldBuilder();
Models.System s;
World world;
State initialState;
switch (index)
{
case 1:
world = wb.GetMuseumWorld();
initialState = new State(0, 0, world.Cameras);
s = new Models.System(world, initialState);
break;
case 2:
world = wb.GetEmptyWorld();
initialState = new State(0, 0, world.Cameras);
s = new Models.System(world, initialState);
break;
default:
world = wb.GetDefaultWorld();
initialState = new State(0, 0, world.Cameras);
s = new Models.System(world, initialState);
break;
}
return(SetSystem(s));
}
public async Task <ActionResult> Edit([Bind(Include = "ID,Name,Description,Tags")] Models.System system, int[] dependants, int[] dependancies)
{
if (ModelState.IsValid)
{
if (dependants != null)
{
system.Dependants = await db.Systems.Where(s => dependants.Contains(s.ID)).ToListAsync();
}
if (dependancies != null)
{
system.Dependancies = await db.Systems.Where(s => dependancies.Contains(s.ID)).ToListAsync();
}
db.Entry(system).State = EntityState.Modified;
await db.SaveChangesAsync();
if (dependants != null)
{
system.Dependants.RemoveAll(d => !dependants.Contains(d.ID));
}
if (dependancies != null)
{
system.Dependancies.RemoveAll(d => !dependancies.Contains(d.ID));
}
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
await SetSystemList(dependants, dependancies);
return(View(system));
}
public ViewResult Search(Models.System sys)
{
ViewBag.ControllerName = "System";
if (string.IsNullOrWhiteSpace(sys.Sys_Code))
{
return(View(repository.Systems));
}
return(View(repository.Systems.Where(r => r.Sys_Code.Contains(sys.Sys_Code))));
}
/// <summary>
/// Gets all activation forms submitted for a given site
/// </summary>
/// <param name="siteId">The site to look up the acitvation forms for</param>
/// <returns>The activation(s), if it exists</returns>
private JsonResult GetActivations(int siteId)
{
using (var context = new Data.ApplicationDbContext()) {
// Verify user exists & has permission
String authUserId = User.GetClaim(OpenIdConnectConstants.Claims.Subject);
Models.User authUser = context.Users.AsNoTracking().FirstOrDefault(u => u.Id.ToString().Equals(authUserId));
if (authUser == null)
{
return(Json(new { status_code = 2, status = "User '" + authUserId + "' does not exist" }));
}
if (!Helpers.PermissionChecker.IsTechOrAdmin(authUser) && !Helpers.PermissionChecker.IsBillingDepartment(authUser))
{
return(Json(new { status_code = 1, status = "User '" + authUser.UserName + "' does not have permission to view activations" }));
}
// Generate list of reports, ordered from newest to oldest
List <Object> report = new List <object>();
List <Models.Activation> activations = context.Activations.AsNoTracking().Where(a => a.SiteId == siteId).OrderByDescending(a => a.SubmissionDate).ToList();
if (activations.Count == 0)
{
return(Json(new { status_code = 2, status = "Site '" + siteId + "' does not have any activation forms from RP2.0+" }));
}
// Add activation, system, and extra site info to each activation object, then add all that info to report
foreach (Models.Activation activation in activations)
{
Models.System system = context.Systems.AsNoTracking().FirstOrDefault(s => s.Id == activation.SystemId);
Object approver = null, siteQuickInfo = null;
if (activation.ApprovedBy.HasValue)
{
Models.User approveUser = context.Users.AsNoTracking().FirstOrDefault(u => u.Id == (int)activation.ApprovedBy);
Models.Site site = context.Sites.AsNoTracking().FirstOrDefault(s => s.SiteId == activation.SiteId);
if (activation.ApprovedBy != -1)
{
approver = new { approveUser.FName, approveUser.LName, name = approveUser.FName + " " + approveUser.LName, approveUser.Id }
}
;
else
{
approver = new { FName = "PRE-APPROVED", LName = "AUTOMATICALLY", name = "PRE-APPROVED AUTOMATICALLY", Id = -1 }
};
siteQuickInfo = new { site.SiteLastPing, site.SiteLastIp };
}
report.Add(new {
activation,
system,
approver,
siteQuickInfo
});
}
return(Json(new { status_code = 0, report }));
}
}
public IActionResult Select(Models.System sys)
{
SetKeyField("Syr_Sys_Code", sys.Sys_Code);
return(View(nameof(Index),
new SystemRegistration
{
Syr_Cst_Code = GetKeyField("Syr_Cst_Code"),
Syr_Sys_Code = sys.Sys_Code
}));
}
public ViewResult Delete(Models.System sys)
{
if (ModelState.IsValid)
{
repository.DeleteSystem(sys.Sys_Code);
}
ModelState.Clear();
return(View("System"));
}
public static Processor.Model.System ToBusinessModel(this Models.System model)
{
if (model == null)
{
return(null);
}
return(new Processor.Model.System(model.SystemId, model.SystemName,
model.Component.Select(comp => comp.ToBusinessModel()).ToList(), model.SystemDescription));
}
public IActionResult Select(Models.System sys)
{
HttpContext.Session.Set("Sys_Code", Encoding.ASCII.GetBytes(sys.Sys_Code));
HttpContext.Session.TryGetValue("Cst_Code", out var Cst_Code);
return(View(nameof(Index),
new SystemRegistration
{
Syr_Cst_Code = Encoding.ASCII.GetString(Cst_Code, 0, Cst_Code.Length),
Syr_Sys_Code = sys.Sys_Code
}));
}
public IActionResult Select(Models.System sys)
{
SetKeyField("Syr_Sys_Code", sys.Sys_Code);
return(RedirectToAction(nameof(SystemRegistrationForm), new
{
cst_code = GetKeyField("Syr_Cst_Code"),
sys_code = GetKeyField("Syr_Sys_Code"),
ver_code = string.Empty
}));
}
public IActionResult AddSystem([FromBody] Models.System system)
{
try
{
systemLogic.AddSystem(system);
return(Ok());
}
catch (Exception ex)
{
return(StatusCode(500, $"Internal server error : {ex}"));
}
}
public IActionResult UpdateStar(string id, [FromBody] Models.System system)
{
try
{
systemLogic.UpdateSystem(id, system);
return(Ok());
}
catch (Exception ex)
{
return(StatusCode(500, $"Internal server error : {ex}"));
}
}
public async Task <IHttpActionResult> GetLinks(int id)
{
Models.System system = await GetSystem(id);
if (system == null)
{
return(NotFound());
}
var links = GetLinkList(system);
return(Ok(links));
}
public static Models.System ToDomainModel(this Processor.Model.System model)
{
if (model == null)
{
return(null);
}
var dto = new Models.System
{
SystemId = model.Id, SystemDescription = model.Description, SystemName = model.Name,
Component = model.Components?.Select(c => c.ToDomainModel()).ToArray()
};
return(dto);
}
// GET: Systems/Details/5
public async Task <ActionResult> Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Models.System system = await GetSystem(id.Value);
if (system == null)
{
return(HttpNotFound());
}
return(View(system));
}
//TODO index variable too to maintain position
public static void Condense(Models.System system, Stack <int> stack)
{
int size = stack.Count;
for (int i = 0; i < size; i++)
{
listData.RemoveAt(stack.Pop());
}
var replacementSystem = system;
replacementSystem.count = size;
replacementSystem.serialNumber = "NA";
listData.Add(replacementSystem);
}
public SystemView MoveTarget([FromQuery] int?dx,
[FromQuery] int?dy,
[FromQuery] int treeSamplesCount,
[FromQuery] int treeDepth,
[FromQuery] float gama,
[FromQuery] float c)
{
treeSamplesCount = Math.Clamp(treeSamplesCount, 10, 1000);
treeDepth = Math.Clamp(treeDepth, 1, 5);
gama = Math.Clamp(gama, 0, 1);
c = Math.Clamp(c, 0, 1);
Models.System s = GetSystem();
s.AdvanceSystem(dx, dy, treeSamplesCount, treeDepth, gama, c);
return(SetSystem(s));
}
public async Task <IActionResult> AddSystem(Models.System system, List <int> formIds)
{
system = _systemService.AddSystem(system);
if (formIds.Count > 0)
{
foreach (var formId in formIds)
{
system.Forms.Add(new SystemForm(system.SystemId, formId));
}
_systemService.SaveChanges();
}
var identity = (ClaimsIdentity)User.Identity;
await _auditLog.Append(identity.GetClaimAsInt("EmployeeId"), LogActionType.Create, LogResourceType.System, system.SystemId,
$"{identity.GetClaim(ClaimTypes.Name)} created system with id {system.SystemId}");
return(RedirectToAction(nameof(ViewSystem), new { id = system.SystemId }));
}
public async Task <IActionResult> EditSystem(int id, Models.System update)
{
var system = _systemService.GetSystem(id);
var oldValue = JsonConvert.SerializeObject(system, Formatting.Indented);
system.Name = update.Name;
system.Description = update.Description;
system.Owner = update.Owner;
system.SupportUnitId = update.SupportUnitId;
_systemService.SaveChanges();
var newValue = JsonConvert.SerializeObject(system, Formatting.Indented);
var identity = (ClaimsIdentity)User.Identity;
await _auditLog.Append(identity.GetClaimAsInt("EmployeeId"), LogActionType.Update, LogResourceType.System, system.SystemId,
$"{identity.GetClaim(ClaimTypes.Name)} updated system with id {system.SystemId}", oldValue, newValue);
return(RedirectToAction(nameof(ViewSystem), new { id }));
}
public JsonResult GetSystem(int id)
{
using (var context = new Data.ApplicationDbContext()) {
String authUserId = User.GetClaim(OpenIdConnectConstants.Claims.Subject);
Models.User authUser = context.Users.AsNoTracking().FirstOrDefault(u => u.Id.ToString().Equals(authUserId));
if (authUser == null)
{
return(Json(new { status_code = 2, status = "User '" + authUserId + "' does not exist" }));
}
Models.System system = context.Systems.AsNoTracking().FirstOrDefault(sys => sys.Id == id);
if (system == null)
{
return(Json(new { status_code = 2, status = "System with ID '" + id + "' does not exist" }));
}
return(Json(new { status_code = 0, system }));
}
}
public async Task <Models.System[]> GetSystemsTable()
{
var DatabaseManager = Shared.DBconnection.GetManager();
try
{
Query getHeadersQuery = new Query {
QueryString = "SELECT COLUMN_NAME FROM atlas.INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = 'systems'"
};
var headerTable = await DatabaseManager.ExecuteTableAsync(DatabaseManager.GetConnection(), getHeadersQuery.QueryString).ConfigureAwait(false);
var headers = new string[headerTable.Length];
for (int i = 0; i < headerTable.Length; i++)
{
headers[i] = (string)headerTable[i][0];
}
headers[headers.Length - 1] = "serializable";
Query getDataQuery = new Query {
QueryString = "SELECT * FROM systems"
};
var dataTable = await DatabaseManager.ExecuteTableAsync(DatabaseManager.GetConnection(), getDataQuery.QueryString).ConfigureAwait(false);
Models.System[] data = new Models.System[dataTable.Length];
for (int i = 0; i < data.Length; i++)
{
data[i] = new Models.System
{
itemID = (int)dataTable[i][0],
name = (string)dataTable[i][1],
SKU = (string)dataTable[i][2],
serialNumber = (string)dataTable[i][3],
systemTempateID = (int)dataTable[i][4],
};
}
return(data);
}
finally
{
DatabaseManager.GetConnection().Close();
}
}
// GET: Systems/Edit/5
public async Task <ActionResult> Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Models.System system = await GetSystem(id.Value);
if (system == null)
{
return(HttpNotFound());
}
await SetSystemList(
system.Dependants?.Select(d => d.ID).ToArray(),
system.Dependancies?.Select(d => d.ID).ToArray()
);
return(View(system));
}
public Models.System GetSystem()
{
Models.System s;
string systemString = HttpContext.Session.GetString(SessionKeySystem);
if (systemString != null)
{
SystemView systemView =
JsonSerializer.Deserialize <SystemView>(HttpContext.Session.GetString(SessionKeySystem));
s = new Models.System(systemView);
}
else
{
World world = new WorldBuilder().GetMuseumWorld();
State initialState = new State(0, 0, world.Cameras);
s = new Models.System(world, initialState);
}
return(s);
}
public async Task <ActionResult> Create([Bind(Include = "Name,Description,Tags")] Models.System system, int[] dependants, int[] dependancies)
{
if (ModelState.IsValid)
{
if (dependants != null)
{
system.Dependants = await db.Systems.Where(s => dependants.Contains(s.ID)).ToListAsync();
}
if (dependancies != null)
{
system.Dependancies = await db.Systems.Where(s => dependancies.Contains(s.ID)).ToListAsync();
}
db.Systems.Add(system);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
await SetSystemList(dependants, dependancies);
return(View(system));
}
private void PopulateCapitals()
{
Dictionary <int, Capital> capitalMap = new Dictionary <int, Capital>();
Dictionary <int, List <Models.System> > sysCapMap = new Dictionary <int, List <Models.System> >();
Dictionary <int, Models.System> systemMap = new Dictionary <int, Models.System>();
Dictionary <int, List <Planet> > planetSystemMap = new Dictionary <int, List <Planet> >();
Dictionary <int, List <Base> > baseSystemMap = new Dictionary <int, List <Base> >();
int id, hexId, capitalId, captureTurn, devestationTurn;
Factions faction, originalFaction;
PlanetType planetType;
string name;
IDbCommand dbcmd = _dbConn.CreateCommand();
string sqlQuery = "SELECT Id, HexId FROM Capital";
dbcmd.CommandText = sqlQuery;
IDataReader reader = dbcmd.ExecuteReader();
while (reader.Read())
{
id = reader.GetInt32(0);
hexId = reader.GetInt32(1);
int x = hexId / 100;
int y = hexId % 100;
capitalMap[id] = new Capital();
_mapNodes[x, y].Capital = capitalMap[id];
}
reader.Close();
dbcmd.Dispose();
dbcmd = _dbConn.CreateCommand();
sqlQuery = "SELECT Id, CapitalId, Name FROM System";
dbcmd.CommandText = sqlQuery;
reader = dbcmd.ExecuteReader();
while (reader.Read())
{
id = reader.GetInt32(0);
capitalId = reader.GetInt32(1);
name = reader.GetString(2);
Models.System sys = new Models.System
{
Name = name,
};
if (!sysCapMap.ContainsKey(capitalId))
{
sysCapMap[capitalId] = new List <Models.System>();
}
sysCapMap[capitalId].Add(sys);
systemMap[id] = sys;
}
reader.Close();
dbcmd.Dispose();
foreach (KeyValuePair <int, Capital> capital in capitalMap)
{
capital.Value.CapitalSystems = sysCapMap[capital.Key].ToArray();
}
dbcmd = _dbConn.CreateCommand();
sqlQuery = "SELECT Id, PlanetSize, OwningFactionId, CaptureTurn, DevestationTurn, OriginalFactionId, SystemId FROM Planet WHERE SystemId IS NOT NULL ORDER BY Id, SystemId";
dbcmd.CommandText = sqlQuery;
reader = dbcmd.ExecuteReader();
while (reader.Read())
{
planetType = (PlanetType)(reader.GetInt32(1));
faction = (Factions)(reader.GetInt32(2));
captureTurn = reader.GetInt32(3);
devestationTurn = reader.GetInt32(4);
originalFaction = (Factions)(reader.GetInt32(5));
int systemId = reader.GetInt32(6);
if (!planetSystemMap.ContainsKey(systemId))
{
planetSystemMap[systemId] = new List <Planet>();
}
planetSystemMap[systemId].Add(new Planet(planetType, faction, originalFaction, captureTurn, devestationTurn));
}
reader.Close();
dbcmd.Dispose();
foreach (KeyValuePair <int, List <Planet> > planetKeyValue in planetSystemMap)
{
systemMap[planetKeyValue.Key].Planets = planetKeyValue.Value.ToArray();
}
dbcmd = _dbConn.CreateCommand();
sqlQuery = "SELECT Id, FactionId, BaseType, SystemId FROM Base WHERE SystemId IS NOT NULL ORDER BY Id, SystemId";
dbcmd.CommandText = sqlQuery;
reader = dbcmd.ExecuteReader();
while (reader.Read())
{
faction = (Factions)(reader.GetInt32(1));
BaseType baseType = (BaseType)(reader.GetInt32(2));
int systemId = reader.GetInt32(3);
if (!baseSystemMap.ContainsKey(systemId))
{
baseSystemMap[systemId] = new List <Base>();
}
baseSystemMap[systemId].Add(new Base(baseType, faction, systemId / 100, systemId % 100));
}
reader.Close();
dbcmd.Dispose();
foreach (KeyValuePair <int, List <Base> > baseKeyValue in baseSystemMap)
{
systemMap[baseKeyValue.Key].Bases = baseKeyValue.Value.ToArray();
}
}
public Models.System AddSystem(Models.System system)
{
_dbContext.Systems.Add(system);
_dbContext.SaveChanges();
return(system);
}
