internal void CalcArea(TrackerProperties pprops, TrackerConfigures rconf)
{
if (_me.X > rconf.Const_GridVolumeWidth && _me.X < rconf.Const_GridWidth)
{
//GRID
if (_me.X < rconf.Const_GridVolumeWidth + rconf.Const_GridButtonWidth)
{
//Button
double cid = (_me.Y - rconf.Const_TitleHeight) / (double)(rconf.Const_TrackHeight / 2);
if (((int)cid) % 2 == 0)
{
_area = GridesAreaType.VerticalBtnsDec;
}
else
{
_area = GridesAreaType.VerticalBtnsAdd;
}
}
else
{
_area = GridesAreaType.NameArea;
}
}
else if (_me.X < rconf.Const_GridVolumeWidth && _me.X >= 0)
{
_area = GridesAreaType.VolumeArea;
}
else
{
_area = GridesAreaType.None;
//NAN
}
}
internal TrackerGridesDrawUtils(BalthasarLib.D2DPainter.D2DPaintEventArgs e, TrackerConfigures rconf, TrackerProperties pprops)
: base(e, rconf)
{
baseEvent = e;
this.rconf = rconf;
this.pprops = pprops;
}
private static void ListUsers(TrackerProperties trackerProperties)
{
using (var storage = new LiteDBStorage(trackerProperties))
{
foreach (User user in storage.GetUsers())
{
Console.WriteLine(
"[{0}][{1}] {2} - [{3}] {4} - [{5}] {6}",
user.LocalId,
user.CharacterId,
user.CharacterName,
user.CorporationId,
user.CorporationName,
user.AllianceId,
user.AllianceName);
if (user.RestrictedServers.Any())
{
foreach (var s in user.RestrictedServers)
{
Console.WriteLine(" - {0}", s);
}
}
}
}
}
internal void CalcAxis(TrackerProperties pprops, TrackerConfigures rconf)
{
if (_me.Y <= rconf.Const_TitleHeight && _me.Y >= 0)
{
_area = AreaType.Title;
}
else if (_me.X <= rconf.Const_GridWidth && _me.X >= 0)
{
_area = AreaType.Roll;
}
else
{
_area = AreaType.Track;
}
if (_area != AreaType.Title)
{
double drawed_noteSpt = (double)(_me.Y - rconf.Const_TitleHeight) / rconf.Const_TrackHeight;
_trackID = (int)Math.Floor(drawed_noteSpt) + (int)pprops.TopTrackId;
}
if (_area != AreaType.Roll)
{
long drawed_pixel = _me.X - rconf.Const_GridWidth;
_tick = (long)Math.Round((pprops.PianoStartTick + pprops.dertPixel2dertTick(drawed_pixel)), 0);
}
}
public LiteDBStorage(TrackerProperties trackerProperties)
{
_db = new LiteDatabase(Path.Combine(
trackerProperties.DataDirectory,
trackerProperties.InstanceName.ToLowerInvariant() + ".db"));
BsonMapper.Global.EmptyStringToNull = false;
InitPingStorage();
InitAuthStorage();
}
internal void CalcArea(TrackerProperties pprops, TrackerConfigures rconf, GridesMouseEventArgs cache)
{
if (cache != null && cache.MouseEventArgs.X == _me.X && cache.MouseEventArgs.Y == _me.Y)
{
_area = cache.Area;
}
else
{
CalcArea(pprops, rconf);
}
}
public AuthController(
ILogger <AuthController> logger,
TrackerProperties trackerProperties,
ESIClient esiClient,
IUserStorage userStorage)
{
_logger = logger;
_trackerProperties = trackerProperties;
_esiClient = esiClient;
_userStorage = userStorage;
}
public TokenAuthenticationHandler(
IOptionsMonitor <TokenAuthenticationOptions> options,
ILoggerFactory logger,
UrlEncoder encoder,
ISystemClock clock,
TrackerProperties trackerProperties,
IUserStorage storage)
: base(options, logger, encoder, clock)
{
_trackerProperties = trackerProperties;
_storage = storage;
}
internal void CalcAxis(TrackerProperties pprops, TrackerConfigures rconf, TrackerMouseEventArgs cache)
{
if (cache != null && cache.MouseEventArgs.X == _me.X && cache.MouseEventArgs.Y == _me.Y)
{
_tick = cache.Tick;
_trackID = cache._trackID;
_area = cache.Area;
}
else
{
CalcAxis(pprops, rconf);
}
}
private static void RemoveUser(TrackerProperties trackerProperties)
{
if (string.IsNullOrEmpty(trackerProperties.CharacterName))
{
throw new ArgumentException("Character name is not set");
}
using (var storage = new Data.LiteDBStorage(trackerProperties))
{
if (storage.DeleteUser(trackerProperties.CharacterName))
{
Console.WriteLine("Deleted user {0}", trackerProperties.CharacterName);
}
else
{
Console.WriteLine("Error: user {0} was not found", trackerProperties.CharacterName);
}
}
}
private TrackerProperties()
{
_singleton = this;
}
private TrackerProperties()
{
_singleton = this;
}
private static void AddUser(TrackerProperties trackerProperties)
{
if (string.IsNullOrEmpty(trackerProperties.CharacterName))
{
throw new ArgumentException("Character name is not set");
}
var client = new ESIClient();
var user = client.GetUserByCharacterName(trackerProperties.CharacterName).GetAwaiter().GetResult();
if (user == null)
{
Console.WriteLine("ERROR: unable to load EVE character {0}", trackerProperties.CharacterName);
return;
}
if (!string.IsNullOrEmpty(trackerProperties.ServerRestrictions))
{
var serverTokens = trackerProperties.ServerRestrictions
.Split(
new char[] { ';', ',' },
StringSplitOptions.RemoveEmptyEntries)
.Select(t => t.Trim());
user.RestrictedServers.Clear();
foreach (string token in serverTokens)
{
user.RestrictedServers.Add(token);
}
}
using (var storage = new LiteDBStorage(trackerProperties))
{
var storedUser = storage.GetUser(user.CharacterName);
if (storedUser != null)
{
user.LocalId = storedUser.LocalId;
if (storage.UpdateUser(user))
{
Console.WriteLine(
"Updated user [{0}][{1}] {2} - [{3}] {4} - [{5}] {6}",
user.LocalId,
user.CharacterId,
user.CharacterName,
user.CorporationId,
user.CorporationName,
user.AllianceId,
user.AllianceName);
if (user.RestrictedServers.Any())
{
Console.WriteLine("Server restrictions:");
foreach (var s in user.RestrictedServers)
{
Console.WriteLine(" - {0}", s);
}
}
else
{
Console.WriteLine("No server restrictions set");
}
}
else
{
Console.WriteLine("ERROR: user update failed");
}
}
else
{
var id = storage.AddUser(user);
if (id > 0)
{
Console.WriteLine(
"Added user [{0}][{1}] {2} - [{3}] {4} - [{5}] {6}",
id,
user.CharacterId,
user.CharacterName,
user.CorporationId,
user.CorporationName,
user.AllianceId,
user.AllianceName);
if (user.RestrictedServers.Any())
{
Console.WriteLine("Server restrictions:");
foreach (var s in user.RestrictedServers)
{
Console.WriteLine(" - {0}", s);
}
}
else
{
Console.WriteLine("No server restrictions set");
}
}
else
{
Console.WriteLine("ERROR: user creation failed");
}
}
}
}
public static void Main(string[] args)
{
try
{
if (args.Length == 0 || args[0] == "help")
{
Console.WriteLine("Expecting command");
Console.WriteLine("Available commands:");
Console.WriteLine(" * run <instanceName> <arguments>");
Console.WriteLine(" --pinger-token - pinger client token [string, MANDATORY]");
Console.WriteLine(" --eve-id - EVE application client id [string, default=none]");
Console.WriteLine(" --eve-secret - EVE application client secret [string, default=none]");
Console.WriteLine(" --data-directory - data storage location [string, default=./]");
Console.WriteLine(" --proxy-basepath - proxy subdirectory base path [string, default=none]");
Console.WriteLine(" --http-port - port to listen for HTTP requests [string, default=5000]");
Console.WriteLine(" --https-port - port to listen for HTTPS requests [string, default=5001]");
Console.WriteLine(" --disable-http - disable plain HTTP [switch, default unset]");
Console.WriteLine(" --disable-https - disable HTTPS [switch, default unset]");
Console.WriteLine(" --public-history - allow public history access [switch, default unset]");
Console.WriteLine(" * stop <instanceName>");
Console.WriteLine(" * add-user <instanceName> <arguments>");
Console.WriteLine(" --character - EVE character name [string, MANDATORY]");
Console.WriteLine(" --servers - allow browsing history only for specific servers [string, comma/semicolon separated, default=none]");
Console.WriteLine(" * remove-user <instanceName> <arguments>");
Console.WriteLine(" --character - EVE character name [string, MANDATORY]");
Console.WriteLine(" * list-users <instanceName>");
Console.WriteLine(" * generate-token");
return;
}
TrackerProperties trackerProperties = TrackerProperties.Parse(args);
_instanceName = trackerProperties.InstanceName;
NLog.LayoutRenderers.LayoutRenderer.Register("instance", (logevent) => _instanceName);
_logger = NLog.Web.NLogBuilder.ConfigureNLog("logger.config").GetCurrentClassLogger();
if (trackerProperties.Command == "generate-token")
{
GenerateToken();
}
else
{
if (string.IsNullOrEmpty(_instanceName))
{
throw new ArgumentException("Instance name is not set");
}
if (trackerProperties.Command == "run")
{
Run(trackerProperties);
}
else if (trackerProperties.Command == "stop")
{
Stop();
}
else if (trackerProperties.Command == "add-user")
{
AddUser(trackerProperties);
}
else if (trackerProperties.Command == "remove-user")
{
RemoveUser(trackerProperties);
}
else if (trackerProperties.Command == "list-users")
{
ListUsers(trackerProperties);
}
else
{
throw new ArgumentException("Unknown command '" + trackerProperties.Command + "'");
}
}
}
catch (Exception ex)
{
LogError(ex.ToString());
}
finally
{
NLog.LogManager.Shutdown();
}
}
private static void Run(TrackerProperties trackerProperties)
{
if (IsRunning())
{
throw new Exception("Instance '" + _instanceName + "' is already running");
}
LogInfo("Running instance '{0}'", _instanceName);
if (string.IsNullOrEmpty(trackerProperties.PingerToken))
{
throw new ArgumentException("Pinger token is not set");
}
if (!trackerProperties.AllowPublicHistoryAccess &&
(string.IsNullOrEmpty(trackerProperties.EveClientId) ||
string.IsNullOrEmpty(trackerProperties.EveClientSecret)))
{
LogWarning("Eve client parameters are not configured properly, history pages will be inaccessible");
}
if (trackerProperties.DisableHttp)
{
LogWarning("HTTP is disabled");
}
if (trackerProperties.DisableHttps)
{
LogWarning("HTTPS is disabled");
}
if (trackerProperties.DisableHttp && trackerProperties.DisableHttps)
{
throw new ArgumentException("Can't disable both HTTP and HTTPS");
}
IHost host = Host.CreateDefaultBuilder()
.ConfigureServices(services =>
{
services.AddSingleton(trackerProperties);
})
.ConfigureWebHostDefaults(webBuilder =>
{
if (trackerProperties.DisableHttp)
{
webBuilder.UseUrls(
string.Format("https://localhost:{0}", trackerProperties.HttpsPort));
}
else if (trackerProperties.DisableHttps)
{
webBuilder.UseUrls(
string.Format("http://localhost:{0}", trackerProperties.HttpPort));
}
else
{
webBuilder.UseUrls(
string.Format("http://localhost:{0}", trackerProperties.HttpPort),
string.Format("https://localhost:{0}", trackerProperties.HttpsPort));
}
webBuilder.UseStartup <Startup>();
})
.ConfigureLogging(logging =>
{
logging.ClearProviders();
})
.UseNLog()
.Build();
_hostStopperTask = Task.Run(() => SetupHostStopper(host));
host.Run();
}
