private async Task <bool> OnDisplayTimers(HttpListenerRequestEventArgs context)
{
if (!Settings.Config.ModuleTimers)
{
return(false);
}
var request = context.Request;
var response = context.Response;
try
{
var extPort = Settings.WebServerModule.WebExternalPort;
var port = Settings.WebServerModule.WebExternalPort;
if (request.HttpMethod == HttpMethod.Get.ToString())
{
if (request.Url.LocalPath == "/callback.php" || request.Url.LocalPath == $"{extPort}/callback.php" || request.Url.LocalPath == $"{port}/callback.php")
{
var clientID = Settings.WebServerModule.CcpAppClientId;
var secret = Settings.WebServerModule.CcpAppSecret;
var prms = request.Url.Query.TrimStart('?').Split('&');
var code = prms[0].Split('=')[1];
var state = prms.Length > 1 ? prms[1].Split('=')[1] : null;
if (state != "11")
{
return(false);
}
//state = 11 && have code
var result = await WebAuthModule.GetCharacterIdFromCode(code, clientID, secret);
if (result == null)
{
//TODO invalid auth
await response.RedirectAsync(new Uri(WebServerModule.GetWebSiteUrl()));
return(true);
}
var characterId = Convert.ToInt64(result[0]);
await SQLHelper.UpdateTimersAuth(characterId);
//redirect to timers
var iid = Convert.ToBase64String(Encoding.UTF8.GetBytes(characterId.ToString()));
iid = HttpUtility.UrlEncode(iid);
var url = $"{WebServerModule.GetTimersURL()}?data=0&id={iid}&state=11";
await response.RedirectAsync(new Uri(url));
return(true);
}
if (request.Url.LocalPath == "/timers.php" || request.Url.LocalPath == $"{extPort}/timers.php" || request.Url.LocalPath == $"{port}/timers.php")
{
if (string.IsNullOrWhiteSpace(request.Url.Query))
{
//redirect to auth
await response.RedirectAsync(new Uri(WebServerModule.GetTimersAuthURL()));
return(true);
}
var prms = request.Url.Query.TrimStart('?').Split('&');
if (prms.Length != 3)
{
await response.RedirectAsync(new Uri(WebServerModule.GetWebSiteUrl()));
return(true);
}
var data = prms[0].Split('=')[1];
var inputId = prms[1].Split('=')[1];
var state = prms[2].Split('=')[1];
if (state != "11")
{
await response.RedirectAsync(new Uri(WebServerModule.GetWebSiteUrl()));
return(true);
}
var characterId = Convert.ToInt64(Encoding.UTF8.GetString(Convert.FromBase64String(HttpUtility.UrlDecode(inputId))));
var rChar = await APIHelper.ESIAPI.GetCharacterData(Reason, characterId, true);
if (rChar == null)
{
await response.RedirectAsync(new Uri(WebServerModule.GetWebSiteUrl()));
return(true);
}
//have charId - had to check it
//check in db
var timeout = Settings.TimersModule.AuthTimeoutInMinutes;
if (timeout != 0)
{
var result = await SQLHelper.GetTimersAuthTime(characterId);
if (result == null || (DateTime.Now - DateTime.Parse(result)).TotalMinutes > timeout)
{
//redirect to auth
await response.RedirectAsync(new Uri(WebServerModule.GetTimersAuthURL()));
return(true);
}
}
var checkResult = await CheckAccess(characterId, rChar);
if (!checkResult[0])
{
await WebServerModule.WriteResponce(WebServerModule.GetAccessDeniedPage("Timers Module", LM.Get("accessDenied"), WebServerModule.GetWebSiteUrl()), response);
return(true);
}
if (checkResult[1] && data.StartsWith("delete"))
{
data = data.Substring(6, data.Length - 6);
await SQLHelper.DeleteTimer(Convert.ToInt64(data));
var x = HttpUtility.ParseQueryString(request.Url.Query);
x.Set("data", "0");
await response.RedirectAsync(new Uri($"{request.Url.ToString().Split('?')[0]}?{x}"));
return(true);
}
await WriteCorrectResponce(response, checkResult[1], characterId);
return(true);
}
}
else if (request.HttpMethod == HttpMethod.Post.ToString())
{
var prms = request.Url.Query.TrimStart('?').Split('&');
if (prms.Length != 3)
{
//await response.RedirectAsync(new Uri(WebServerModule.GetWebSiteUrl()));
return(false);
}
var inputId = prms[1].Split('=')[1];
var state = prms[2].Split('=')[1];
if (state != "11")
{
// await response.RedirectAsync(new Uri(WebServerModule.GetWebSiteUrl()));
return(false);
}
var characterId = Convert.ToInt64(Encoding.UTF8.GetString(Convert.FromBase64String(HttpUtility.UrlDecode(inputId))));
var rChar = await APIHelper.ESIAPI.GetCharacterData(Reason, characterId, true);
if (rChar == null)
{
// await response.RedirectAsync(new Uri(WebServerModule.GetWebSiteUrl()));
return(false);
}
var checkResult = await CheckAccess(characterId, rChar);
if (!checkResult[0])
{
return(true);
}
var data = await request.ReadContentAsStringAsync();
if (checkResult[1] && data != null)
{
if (data.StartsWith("delete"))
{
data = data.Substring(6, data.Length - 6);
await SQLHelper.DeleteTimer(Convert.ToInt64(data));
}
else
{
TimerItem entry = null;
try
{
entry = JsonConvert.DeserializeObject <TimerItem>(data);
}
catch
{
//ignore
}
if (entry == null)
{
await response.WriteContentAsync(LM.Get("invalidInputData"));
return(true);
}
var iDate = entry.GetDateTime();
if (iDate == null)
{
await response.WriteContentAsync(LM.Get("invalidTimeFormat"));
return(true);
}
if (iDate < DateTime.Now)
{
await response.WriteContentAsync(LM.Get("passedTimeValue"));
return(true);
}
//save
entry.timerChar = rChar.name;
await SQLHelper.UpdateTimer(entry);
}
return(true);
}
}
}
catch (Exception ex)
{
await LogHelper.LogEx(ex.Message, ex, Category);
}
return(false);
}
public static async Task Stats(ICommandContext context, string commandText)
{
if (!SettingsManager.Settings.Config.ModuleStats)
{
return;
}
try
{
var now = DateTime.Now;
var today = DateTime.Today;
var comms = commandText.Split(' ').ToList();
var isSingle = comms.Count == 1;
var command = string.IsNullOrEmpty(commandText) ? "t" : comms[0].ToLower();
string entity = null;
if (!isSingle)
{
comms.RemoveAt(0);
entity = string.Join(' ', comms);
}
var requestHandler = new ZkbRequestHandler(new JsonSerializer("yyyy-MM-dd HH:mm:ss"));
//TODO introduce own variables and may be even settings section
var allyId = SettingsManager.Settings.ContinousCheckModule.DailyStatsDefaultAlliance;
if (!string.IsNullOrEmpty(entity))
{
allyId = (await APIHelper.ESIAPI.SearchAllianceId("Stats", entity))?.alliance?.FirstOrDefault() ?? 0;
}
var corpId = SettingsManager.Settings.ContinousCheckModule.DailyStatsDefaultCorp;
if (!string.IsNullOrEmpty(entity) && allyId == 0)
{
corpId = (await APIHelper.ESIAPI.SearchCorporationId("Stats", entity))?.corporation.FirstOrDefault() ?? 0;
}
if (allyId == 0 && corpId == 0)
{
return;
}
bool isAlliance = corpId == 0;
var id = isAlliance ? allyId : corpId;
entity = string.IsNullOrEmpty(entity) ? (isAlliance ? (await APIHelper.ESIAPI.GetAllianceData("Stats", id))?.name :(await APIHelper.ESIAPI.GetCorporationData("Stats", id))?.name) : entity;
if (command == "d" || command == "t" || command == "today" || command == "newday")
{
var isNewDay = command == "newday";
var channel = SettingsManager.Settings.ContinousCheckModule.DailyStatsChannel;
if (isNewDay && channel == 0)
{
return;
}
var to = now.Add(TimeSpan.FromHours(1));
to = to.Subtract(TimeSpan.FromMinutes(to.Minute));
var startTime = isNewDay ? today.Subtract(TimeSpan.FromDays(1)) : today;
var endTime = isNewDay ? startTime.AddHours(24) : to;
var options = new ZKillboardOptions
{
StartTime = startTime,
EndTime = endTime,
};
if (isAlliance)
{
options.AllianceId = new List <long> {
id
}
}
;
else
{
options.CorporationId = new List <long> {
id
}
};
string relPath = "/api/losses";
relPath = options.GetQueryString(relPath);
var losses = await RequestAsync <List <ZkbResponse.ZkbKill> >(requestHandler, new Uri(new Uri("https://zkillboard.com"), relPath)) ??
new List <ZkbResponse.ZkbKill>();
relPath = "/api/kills";
relPath = options.GetQueryString(relPath);
var kills = await RequestAsync <List <ZkbResponse.ZkbKill> >(requestHandler, new Uri(new Uri("https://zkillboard.com"), relPath)) ??
new List <ZkbResponse.ZkbKill>();
var shipsDestroyed = kills.Count;
var shipsLost = losses.Count;
var iskDestroyed = kills.Sum(a => a.Stats.TotalValue);
var iskLost = losses.Sum(a => a.Stats.TotalValue);
var date = today;
if (isNewDay)
{
date = today.Subtract(TimeSpan.FromDays(1));
var msg =
$"**{LM.Get("dailyStats", date, entity)}**\n{LM.Get("Killed")}:\t**{shipsDestroyed}** ({iskDestroyed:n0} ISK)\n{LM.Get("Lost")}:\t**{shipsLost}** ({iskLost:n0} ISK)";
await APIHelper.DiscordAPI.SendMessageAsync(APIHelper.DiscordAPI.GetChannel(channel), msg).ConfigureAwait(false);
}
else
{
var msg =
$"**{LM.Get("dailyStats", date, entity)}**\n{LM.Get("Killed")}:\t**{shipsDestroyed}** ({iskDestroyed:n0} ISK)\n{LM.Get("Lost")}:\t**{shipsLost}** ({iskLost:n0} ISK)";
await APIHelper.DiscordAPI.ReplyMessageAsync(context, msg, true).ConfigureAwait(false);
}
}
else
{
var t = isAlliance ? "allianceID" : "corporationID";
var relPath = $"/api/stats/{t}/{id}/";
var result = await RequestAsync <ZkbStatResponse>(requestHandler, new Uri(new Uri("https://zkillboard.com"), relPath));
if (command == "month" || command == "m")
{
var data = result.Months.FirstOrDefault(a => a.Value.Year == now.Year && a.Value.Month == now.Month).Value;
if (data == null)
{
return;
}
await APIHelper.DiscordAPI.ReplyMessageAsync(context,
$"**{LM.Get("monthlyStats", result.Info.Name)}**\n{LM.Get("Killed")}:\t**{data.ShipsDestroyed}** ({data.IskDestroyed:n0} ISK)\n{LM.Get("Lost")}:\t**{data.ShipsLost}** ({data.IskLost:n0} ISK)");
}
else if (command.All(char.IsDigit))
{
var list = result.Months.Where(a => a.Value.Year.ToString() == command).ToList();
if (!list.Any())
{
return;
}
var shipsDestroyed = list.Sum(a => a.Value.ShipsDestroyed);
var shipsLost = list.Sum(a => a.Value.ShipsLost);
var iskDestroyed = list.Sum(a => a.Value.IskDestroyed);
var iskLost = list.Sum(a => a.Value.IskLost);
await APIHelper.DiscordAPI.ReplyMessageAsync(context,
$"**{LM.Get("yearlyStats", result.Info.Name, command)}**\n{LM.Get("Killed")}:\t**{shipsDestroyed}** ({iskDestroyed:n0} ISK)\n{LM.Get("Lost")}:\t**{shipsLost}** ({iskLost:n0} ISK)");
}
else if (command.Contains("/"))
{
var tmp = command.Split("/");
if (!tmp[0].All(char.IsDigit) || tmp[0].Length != 4)
{
return;
}
if (!tmp[1].All(char.IsDigit) || tmp[1].Length < 1 || tmp[1].Length > 2)
{
return;
}
var m = int.Parse(tmp[1]);
var list = result.Months.Where(a => a.Value.Year.ToString() == tmp[0] && a.Value.Month == m).ToList();
if (!list.Any())
{
return;
}
var shipsDestroyed = list.Sum(a => a.Value.ShipsDestroyed);
var shipsLost = list.Sum(a => a.Value.ShipsLost);
var iskDestroyed = list.Sum(a => a.Value.IskDestroyed);
var iskLost = list.Sum(a => a.Value.IskLost);
await APIHelper.DiscordAPI.ReplyMessageAsync(context,
$"**{LM.Get("monthlyCustomStats", result.Info.Name, command)}**\n{LM.Get("Killed")}:\t**{shipsDestroyed}** ({iskDestroyed:n0} ISK)\n{LM.Get("Lost")}:\t**{shipsLost}** ({iskLost:n0} ISK)");
}
}
}
catch (Exception ex)
{
await LogHelper.LogEx(ex.Message, ex, LogCat.Stats);
}
}
public async Task <string> GenerateTimersHtml(bool isEditor, string baseCharId)
{
var timers = await SQLHelper.SelectTimers();
int counter = 1;
var sb = new StringBuilder();
sb.AppendLine("<thead>");
sb.AppendLine("<tr>");
sb.AppendLine($"<th scope=\"col-md-auto\">#</th>");
sb.AppendLine($"<th scope=\"col-md-auto\">{LM.Get("timersType")}</th>");
sb.AppendLine($"<th scope=\"col-md-auto\">{LM.Get("timersStage")}</th>");
sb.AppendLine($"<th scope=\"col\">{LM.Get("timersLocation")}</th>");
sb.AppendLine($"<th scope=\"col\">{LM.Get("timersOwner")}</th>");
sb.AppendLine($"<th scope=\"col\" class=\"fixed150\">{LM.Get("timersET")}</th>");
sb.AppendLine($"<th scope=\"col\" class=\"fixed150\">{LM.Get("timersRemaining")}</th>");
sb.AppendLine($"<th scope=\"col\">{LM.Get("timersNotes")}</th>");
sb.AppendLine($"<th scope=\"col\">{LM.Get("timersUser")}</th>");
sb.AppendLine($"<th scope=\"col-md-auto\" class=\"{(isEditor ? null : "d-none")}\"></th");
sb.AppendLine("</tr>");
sb.AppendLine("</thead>");
sb.AppendLine("<tbody>");
var timeFormat = Settings.Config.ShortTimeFormat;
timers.OrderBy(a => a.GetDateTime()).ToList().ForEach(timer =>
{
sb.AppendLine("<tr>");
sb.AppendLine($" <th scope=\"row\">{counter++}</th>");
sb.AppendLine($" <td>{timer.GetModeName()}</td>");
sb.AppendLine($" <td>{timer.GetStageName()}</td>");
sb.AppendLine($" <td>{HttpUtility.HtmlEncode(timer.timerLocation)}</td>");
sb.AppendLine($" <td>{HttpUtility.HtmlEncode(timer.timerOwner)}</td>");
sb.AppendLine($" <td>{timer.GetDateTime()?.ToString(timeFormat)}</td>");
sb.AppendLine($" <td>{timer.GetRemains()}</td>");
sb.AppendLine($" <td>{HttpUtility.HtmlEncode(timer.timerNotes)}</td>");
sb.AppendLine($" <td>{HttpUtility.HtmlEncode(timer.timerChar)}</td>");
if (isEditor)
{
sb.AppendLine($"<td><a class=\"btn btn-danger\" href=\"{WebServerModule.GetTimersURL()}?data=delete{timer.id}&id={HttpUtility.UrlEncode(baseCharId)}&state=11\" role=\"button\" data-toggle=\"confirmation\" data-title=\"{LM.Get("ConfirmDelete")}?\">X</a></td>");
}
sb.AppendLine("</tr>");
});
sb.AppendLine("</tbody>");
return(sb.ToString());
}
private async Task <bool> OnAuthRequest(HttpListenerRequestEventArgs context)
{
if (!Settings.Config.ModuleIndustrialJobs)
{
return(false);
}
var request = context.Request;
var response = context.Response;
try
{
RunningRequestCount++;
var port = Settings.WebServerModule.WebExternalPort;
if (request.HttpMethod == HttpMethod.Get.ToString())
{
if (request.Url.LocalPath == "/callback" || request.Url.LocalPath == $"{port}/callback")
{
var clientID = Settings.WebServerModule.CcpAppClientId;
var secret = Settings.WebServerModule.CcpAppSecret;
var prms = request.Url.Query.TrimStart('?').Split('&');
var code = prms[0].Split('=')[1];
var state = prms.Length > 1 ? prms[1].Split('=')[1] : null;
if (string.IsNullOrEmpty(state))
{
return(false);
}
if (!state.StartsWith("ijobsauth"))
{
return(false);
}
//var groupName = HttpUtility.UrlDecode(state.Replace("ijobsauth", ""));
var result = await WebAuthModule.GetCharacterIdFromCode(code, clientID, secret);
if (result == null)
{
await WebServerModule.WriteResponce(
WebServerModule.GetAccessDeniedPage("Industry Jobs Module", LM.Get("accessDenied"),
WebServerModule.GetAuthPageUrl()), response);
return(true);
}
var lCharId = Convert.ToInt64(result[0]);
//var group = Settings.IndustrialJobsModule.Groups[groupName];
var allowedCharacters = GetAllParsedCharactersWithGroups();
string allowedGroup = null;
foreach (var(group, allowedCharacterIds) in allowedCharacters)
{
if (allowedCharacterIds.Contains(lCharId))
{
allowedGroup = group;
break;
}
}
if (string.IsNullOrEmpty(allowedGroup))
{
await WebServerModule.WriteResponce(
WebServerModule.GetAccessDeniedPage("Industry Jobs Module", LM.Get("accessDenied"),
WebServerModule.GetAuthPageUrl()), response);
return(true);
}
await SQLHelper.InsertOrUpdateTokens("", result[0], null, null, result[1]);
await WebServerModule.WriteResponce(File
.ReadAllText(SettingsManager.FileTemplateMailAuthSuccess)
.Replace("{headerContent}", WebServerModule.GetHtmlResourceDefault(false))
.Replace("{header}", "authTemplateHeader")
.Replace("{body}", LM.Get("industryJobsAuthSuccessHeader"))
.Replace("{body2}", LM.Get("industryJobsAuthSuccessBody"))
.Replace("{backText}", LM.Get("backText")), response
);
return(true);
}
}
}
catch (Exception ex)
{
await LogHelper.LogEx(ex.Message, ex, Category);
}
finally
{
RunningRequestCount--;
}
return(false);
}
public override async Task Run(object prm)
{
if (IsRunning)
{
return;
}
IsRunning = true;
await ProcessExistingCampaigns();
try
{
if (DateTime.Now <= _nextNotificationCheck)
{
return;
}
_nextNotificationCheck = DateTime.Now.AddMinutes(Settings.NullCampaignModule.CheckIntervalInMinutes);
var etag = _tags.GetOrNull(0);
var result = await APIHelper.ESIAPI.GetNullCampaigns(Reason, etag);
_tags.AddOrUpdateEx(0, result.Data.ETag);
if (result.Data.IsNotModified)
{
return;
}
var allCampaigns = result.Result;
if (allCampaigns == null)
{
return;
}
foreach (var pair in Settings.NullCampaignModule.GetEnabledGroups())
{
var groupName = pair.Key;
var group = pair.Value;
var systems = new List <JsonClasses.SystemName>();
foreach (var regionId in @group.Regions)
{
systems.AddRange(await SQLHelper.GetSystemsByRegion(regionId));
}
foreach (var cId in @group.Constellations)
{
systems.AddRange(await SQLHelper.GetSystemsByConstellation(cId));
}
var systemIds = systems.Select(a => a.system_id);
var campaigns = allCampaigns.Where(a => systemIds.Contains(a.solar_system_id));
var existIds = await SQLHelper.GetNullsecCampaignIdList(groupName);
campaigns = campaigns.Where(a => !existIds.Contains(a.campaign_id));
foreach (var campaign in campaigns)
{
if (await SQLHelper.IsNullsecCampaignExists(groupName, campaign.campaign_id))
{
continue;
}
var startTime = campaign.Time;
var totalMinutes = DateTime.UtcNow >= startTime ? 0 : (int)(startTime - DateTime.UtcNow).TotalMinutes;
if (totalMinutes == 0)
{
continue;
}
await SQLHelper.UpdateNullCampaign(groupName, campaign.campaign_id, startTime, campaign.ToJson());
if (group.ReportNewCampaign)
{
await PrepareMessage(campaign, pair.Value, LM.Get("NC_NewCampaign"), 0x00FF00);
}
await LogHelper.LogInfo($"Nullsec Campaign {campaign.campaign_id} has been registered! [{groupName} - {campaign.campaign_id}]", Category, true, false);
}
}
}
catch (Exception ex)
{
await LogHelper.LogEx(ex.Message, ex, Category);
}
finally
{
IsRunning = false;
}
}
public async Task Auth3(string command, string data)
{
if (SettingsManager.Settings.Config.ModuleAuthWeb)
{
try
{
string code;
int characterId;
if (!data.All(char.IsDigit))
{
code = data;
characterId = 0;
}
else
{
code = null;
characterId = Convert.ToInt32(data);
}
code = code ?? await SQLHelper.PendingUsersGetCode(characterId);
//check if entry exists
if (await SQLHelper.UserTokensExists(code) == false)
{
await APIHelper.DiscordAPI.ReplyMessageAsync(Context, LM.Get("entryNotFound"));
return;
}
var name = await SQLHelper.UserTokensGetName(code);
switch (command)
{
case "accept":
{
//check if pending users have valid entry
if (await SQLHelper.PendingUsersIsEntryActive(code) == false)
{
await APIHelper.DiscordAPI.ReplyMessageAsync(Context, LM.Get("entryNotFound"));
return;
}
//check if user confirmed application
if (await SQLHelper.UserTokensIsConfirmed(code) == false)
{
await APIHelper.DiscordAPI.ReplyMessageAsync(Context, LM.Get("authUserNotConfirmed", name));
return;
}
var userGroupName = await SQLHelper.UserTokensGetGroupName(code);
var groupRoles = SettingsManager.Settings.WebAuthModule.AuthGroups.FirstOrDefault(a => a.Key == userGroupName).Value?.AuthRoles;
//check if group exists
if (string.IsNullOrEmpty(userGroupName) || groupRoles == null)
{
await APIHelper.DiscordAPI.ReplyMessageAsync(Context, LM.Get("authGroupNameNotFound", userGroupName));
return;
}
//check auth rights
if (!APIHelper.DiscordAPI.GetUserRoleNames(Context.Message.Author.Id).Any(a => groupRoles.Contains(a)))
{
await APIHelper.DiscordAPI.ReplyMessageAsync(Context, LM.Get("authNoAccessRights"));
return;
}
//authed for action!
// code = code ?? await SQLHelper.PendingUsersGetCode(characterId);
var discordUserId = await SQLHelper.PendingUsersGetDiscordId(code);
await WebAuthModule.AuthUser(Context, code, discordUserId);
await SQLHelper.UserTokensSetAuthState(code, 2);
return;
}
case "decline":
{
//check if pending users have valid entry
if (await SQLHelper.PendingUsersIsEntryActive(code) == false)
{
await APIHelper.DiscordAPI.ReplyMessageAsync(Context, LM.Get("entryNotFound"));
return;
}
characterId = characterId == 0 ? await SQLHelper.PendingUsersGetCharacterId(code) : characterId;
await SQLHelper.SQLiteDataDelete("pendingUsers", "characterID", characterId.ToString());
await SQLHelper.SQLiteDataDelete("userTokens", "characterID", characterId.ToString());
await APIHelper.DiscordAPI.ReplyMessageAsync(Context, LM.Get("authDiscordUserDeclined", name));
return;
}
case "confirm":
code = code ?? data;
if (await SQLHelper.UserTokensExists(code) == false || await SQLHelper.PendingUsersIsEntryActive(code) == false || await SQLHelper.UserTokensHasDiscordId(code))
{
await APIHelper.DiscordAPI.ReplyMessageAsync(Context, LM.Get("entryNotFound"));
return;
}
await SQLHelper.UserTokensSetDiscordId(code, Context.Message.Author.Id);
await SQLHelper.PendingUsersSetCode(code, Context.Message.Author.Id);
await SQLHelper.UserTokensSetAuthState(code, 1);
await APIHelper.DiscordAPI.ReplyMessageAsync(Context, LM.Get("authDiscordUserConfirmed", name));
return;
default:
await APIHelper.DiscordAPI.ReplyMessageAsync(Context, LM.Get("invalidCommandSyntax"));
return;
}
}
catch (Exception ex)
{
await LogHelper.LogEx($"!auth {command} {data}", ex, LogCat.AuthWeb);
await APIHelper.DiscordAPI.ReplyMessageAsync(Context, LM.Get("WebRequestUnexpected"));
}
}
await APIHelper.DiscordAPI.ReplyMessageAsync(Context, $"{LM.Get("webServerOffline")}");
}
public override async Task Run(object prm)
{
if (!Settings.Config.ModuleWebServer)
{
return;
}
if (Settings.WebServerModule.ServerStatusPort > 0 && (_statusListener == null || !_statusListener.IsListening))
{
await LogHelper.LogInfo("Starting Web Server - Status Reporter", Category);
try
{
_statusListener?.Dispose();
}
catch
{
// ignored
}
var ip = "0.0.0.0";
_statusListener = new HttpListener(IPAddress.Parse(ip), Settings.WebServerModule.ServerStatusPort);
_statusListener.Request += async(sender, context) =>
{
try
{
if (_statusQueries.Count > 10)
{
return;
}
_statusQueries.Enqueue(DateTime.Now);
// var request = context.Request;
var response = context.Response;
//OK, NO_ESI, NO_CONNECTION, NO_DISCORD
var value = "OK";
if (TickManager.IsESIUnreachable)
{
value = "NO_ESI";
}
if (TickManager.IsNoConnection)
{
value = "NO_CONNECTION";
}
if (!APIHelper.DiscordAPI.IsAvailable)
{
if (Settings.WebServerModule.NoStatusResponseOnDiscordDisconnection)
{
return;
}
value = "NO_DISCORD";
}
await response.WriteContentAsync(value);
}
catch (Exception ex)
{
await LogHelper.LogEx(ex.Message, ex, Category);
}
finally
{
try
{
context.Response.Close();
}
catch
{
//ignore
}
}
};
_statusListener.Start();
}
if (_listener == null || !_listener.IsListening)
{
await LogHelper.LogInfo("Starting Web Server", Category);
try
{
_listener?.Dispose();
}
catch
{
// ignored
}
//TODO cleanup all occurences in modules in some of the following releases
var extPort = Settings.WebServerModule.WebExternalPort;
var ip = "0.0.0.0";
_listener = new System.Net.Http.HttpListener(IPAddress.Parse(ip), extPort);
_listener.Request += async(sender, context) =>
{
try
{
var request = context.Request;
var response = context.Response;
if (request.Url.LocalPath.EndsWith(".js") || request.Url.LocalPath.EndsWith(".less") || request.Url.LocalPath.EndsWith(".css"))
{
var path = Path.Combine(SettingsManager.RootDirectory, "Content", "scripts", Path.GetFileName(request.Url.LocalPath));
if (request.Url.LocalPath.Contains("moments"))
{
path = Path.Combine(SettingsManager.RootDirectory, "Content", "scripts", "moments", Path.GetFileName(request.Url.LocalPath));
}
if (!File.Exists(path))
{
return;
}
if (request.Url.LocalPath.EndsWith(".less") || request.Url.LocalPath.EndsWith(".css"))
{
response.Headers.ContentType.Add("text/css");
}
if (request.Url.LocalPath.EndsWith(".js"))
{
response.Headers.ContentType.Add("text/javascript");
}
await response.WriteContentAsync(File.ReadAllText(path));
return;
}
if (request.Url.LocalPath == "/favicon.ico")
{
var path = Path.Combine(SettingsManager.RootDirectory, Path.GetFileName(request.Url.LocalPath));
if (!File.Exists(path))
{
return;
}
await response.WriteContentAsync(File.ReadAllText(path));
return;
}
if (request.Url.LocalPath == "/" || request.Url.LocalPath == $"{extPort}/")
{
// var extIp = Settings.WebServerModule.WebExternalIP;
var text = File.ReadAllText(SettingsManager.FileTemplateMain)
.Replace("{headerContent}", GetHtmlResourceDefault(false))
.Replace("{header}", LM.Get("authTemplateHeader"))
.Replace("{webWelcomeHeader}", LM.Get("webWelcomeHeader"))
.Replace("{authButtonText}", LM.Get("butGeneralAuthPage"));
//managecontrols
var manageText = new StringBuilder();
//timers
if (Settings.Config.ModuleTimers)
{
var authNurl = GetTimersURL();
manageText.Append($"\n<a href=\"{authNurl}\" class=\"btn btn-info btn-block\" role=\"button\">{LM.Get("authButtonTimersText")}</a>");
}
if (Settings.Config.ModuleHRM)
{
var authNurl = GetHRMAuthURL();
manageText.Append($"\n<a href=\"{authNurl}\" class=\"btn btn-info btn-block\" role=\"button\">{LM.Get("authButtonHRMText")}</a>");
}
if (Settings.Config.ModuleWebConfigEditor)
{
var authNurl = GetWebConfigAuthURL();
manageText.Append($"\n<a href=\"{authNurl}\" class=\"btn btn-info btn-block\" role=\"button\">{LM.Get("buttonSettingsText")}</a>");
}
text = text.Replace("{manageControls}", manageText.ToString());
await WriteResponce(text, response);
return;
}
if (request.Url.LocalPath == "/authPage.html" || request.Url.LocalPath == $"{extPort}/authPage.html")
{
var extIp = Settings.WebServerModule.WebExternalIP;
var authUrl = $"{GetWebSiteUrl()}/auth";
var text = File.ReadAllText(SettingsManager.FileTemplateAuthPage)
.Replace("{headerContent}", GetHtmlResourceDefault(false))
.Replace("{header}", LM.Get("authTemplateHeader"))
.Replace("{backText}", LM.Get("backText"));
//auth controls
var authText = new StringBuilder();
var grps = Settings.WebAuthModule.GetEnabledAuthGroups();
if (Settings.Config.ModuleAuthWeb && grps.Count > 0)
{
authText.Append($"<h2>{LM.Get("authWebDiscordHeader")}</h4>{LM.Get("authPageGeneralAuthHeader")}");
}
var groupsForCycle = Settings.WebAuthModule.UseOneAuthButton
? grps.Where(a => a.Value.ExcludeFromOneButtonMode || a.Value.BindToMainCharacter)
: grps;
if (Settings.WebAuthModule.UseOneAuthButton)
{
if (Settings.Config.ModuleAuthWeb)
{
var url = $"{authUrl}?group={HttpUtility.UrlEncode(WebAuthModule.DEF_NOGROUP_NAME)}";
authText.Append($"\n<a href=\"{url}\" class=\"btn btn-info btn-block\" role=\"button\">{LM.Get("authButtonDiscordText")}</a>");
}
}
//stands auth
if (Settings.Config.ModuleAuthWeb)
{
foreach (var groupPair in groupsForCycle.Where(a => a.Value.StandingsAuth != null))
{
var group = groupPair.Value;
if (group.Hidden)
{
continue;
}
var url = $"{authUrl}?group={HttpUtility.UrlEncode(groupPair.Key)}";
authText.Append($"\n<a href=\"{url}\" class=\"btn btn-info btn-block\" role=\"button\">{group.CustomButtonText}</a>");
}
}
//auth
if (Settings.Config.ModuleAuthWeb)
{
foreach (var @group in groupsForCycle.Where(a => a.Value.StandingsAuth == null))
{
if (group.Value.Hidden)
{
continue;
}
var url = $"{authUrl}?group={HttpUtility.UrlEncode(group.Value.BindToMainCharacter ? WebAuthModule.DEF_ALTREGGROUP_NAME : group.Key)}";
var bText = group.Value.CustomButtonText ?? $"{LM.Get("authButtonDiscordText")} - {group.Key}";
authText.Append($"<a href=\"{url}\" class=\"btn btn-info btn-block\" role=\"button\">{bText}</a>");
}
}
var len = authText.Length;
var smth = false;
//stands auth
if (Settings.Config.ModuleAuthWeb)
{
foreach (var groupPair in grps.Where(a => a.Value.StandingsAuth != null))
{
var group = groupPair.Value;
if (group.Hidden)
{
continue;
}
var url = GetStandsAuthURL();
authText.Append($"\n<a href=\"{url}\" class=\"btn btn-info btn-block\" role=\"button\">{group.StandingsAuth.WebAdminButtonText}</a>");
}
smth = true;
}
//notifications
if (Settings.Config.ModuleNotificationFeed)
{
var authNurl = GetAuthNotifyURL();
authText.Append($"\n<a href=\"{authNurl}\" class=\"btn btn-info btn-block\" role=\"button\">{LM.Get("authButtonNotifyText")}</a>");
smth = true;
}
//mail
if (Settings.Config.ModuleMail)
{
var authNurl = GetMailAuthURL();
authText.Append($"\n<a href=\"{authNurl}\" class=\"btn btn-info btn-block\" role=\"button\">{LM.Get("authButtonMailText")}</a>");
smth = true;
}
if (Settings.Config.ModuleContractNotifications)
{
foreach (var notifyGroup in Settings.ContractNotificationsModule.GetEnabledGroups())
{
var group = notifyGroup.Value;
var authNurl = GetContractsAuthURL(group.FeedPersonalContracts, group.FeedCorporateContracts, notifyGroup.Key);
authText.Append($"\n<a href=\"{authNurl}\" class=\"btn btn-info btn-block\" role=\"button\">{group.ButtonText}</a>");
}
smth = true;
}
if (Settings.Config.ModuleIndustrialJobs)
{
foreach (var(key, group) in Settings.IndustrialJobsModule.GetEnabledGroups())
{
var authNurl = GetIndustryJobsAuthURL(group.Filters.Any(a => a.Value.FeedPersonalJobs), group.Filters.Any(a => a.Value.FeedCorporateJobs), key);
authText.Append($"\n<a href=\"{authNurl}\" class=\"btn btn-info btn-block\" role=\"button\">{group.ButtonText ?? key}</a>");
}
smth = true;
}
if (smth)
{
authText.Insert(len, $"<h2>{LM.Get("authWebSystemHeader")}</h2>{LM.Get("authPageSystemAuthHeader")}");
}
text = text.Replace("{authControls}", authText.ToString()).Replace("{authHeaderText}", LM.Get("authPageHeaderText"));
await WriteResponce(text, response);
return;
}
var result = false;
foreach (var method in ModuleConnectors.Values)
{
try
{
result = await method(context);
if (result)
{
break;
}
}
catch (Exception ex)
{
await LogHelper.LogEx($"Module method {method.Method.Name} throws ex!", ex, Category);
}
}
if (!result)
{
await WriteResponce(Get404Page(), response);
}
}
catch (Exception ex)
{
await LogHelper.LogEx(ex.Message, ex, Category);
}
finally
{
try
{
context.Response.Close();
}
catch
{
//ignore
}
}
};
_listener.Start();
}
}
public async Task <bool> Auth(HttpListenerRequestEventArgs context)
{
var esiFailure = false;
var request = context.Request;
var response = context.Response;
var extIp = SettingsManager.Get("webServerModule", "webExternalIP");
var extPort = SettingsManager.Get("webServerModule", "webExternalPort");
var port = SettingsManager.Get("webServerModule", "webListenPort");
var callbackurl = $"http://{extIp}:{extPort}/callback.php";
if (request.HttpMethod != HttpMethod.Get.ToString())
{
return(false);
}
try
{
if (request.Url.LocalPath == "/auth.php" || request.Url.LocalPath == $"{extPort}/auth.php" || request.Url.LocalPath == $"{port}/auth.php")
{
response.Headers.ContentEncoding.Add("utf-8");
response.Headers.ContentType.Add("text/html;charset=utf-8");
var text = File.ReadAllText(SettingsManager.FileTemplateAuth).Replace("{callbackurl}", callbackurl).Replace("{client_id}", Settings.Core.CcpAppClientId)
.Replace("{header}", LM.Get("authTemplateHeader")).Replace("{body}", LM.Get("authTemplateInv")).Replace("{backText}", LM.Get("backText"));
await response.WriteContentAsync(text);
return(true);
}
if (request.Url.LocalPath == "/callback.php" || request.Url.LocalPath == $"{extPort}/callback.php" || request.Url.LocalPath == $"{port}/callback.php" &&
!request.Url.Query.Contains("&state=11"))
{
var assembly = Assembly.GetEntryAssembly();
// var temp = assembly.GetManifestResourceNames();
var resource = assembly.GetManifestResourceStream($"{assembly.GetName().Name}.Discord-01.png");
var buffer = new byte[resource.Length];
resource.Read(buffer, 0, Convert.ToInt32(resource.Length));
var image = Convert.ToBase64String(buffer);
var uid = GetUniqID();
var add = false;
if (!string.IsNullOrWhiteSpace(request.Url.Query))
{
var prms = request.Url.Query.TrimStart('?').Split('&');
var code = prms[0].Split('=')[1];
var state = prms.Length > 1 ? prms[1].Split('=')[1] : null;
var result = await GetCHaracterIdFromCode(code, Settings.Core.CcpAppClientId, Settings.Core.CcpAppSecret);
if (result == null)
{
esiFailure = true;
}
var characterID = result?[0];
var numericCharId = Convert.ToInt32(characterID);
var rChar = await APIHelper.ESIAPI.GetCharacterData(Reason, characterID, true);
if (state == "9") //refresh token fetch ops
{
response.Headers.ContentEncoding.Add("utf-8");
response.Headers.ContentType.Add("text/html;charset=utf-8");
if (string.IsNullOrEmpty(characterID))
{
await LogHelper.LogWarning("Bad or outdated notify feed request!");
await response.WriteContentAsync(File.ReadAllText(SettingsManager.FileTemplateAuthNotifyFail)
.Replace("{message}", LM.Get("authTokenBadRequest"))
.Replace("{header}", LM.Get("authTokenHeader")).Replace("{body}", LM.Get("authTokenBodyFail")).Replace("{backText}", LM.Get("backText")));
return(true);
}
if (TickManager.GetModule <NotificationModule>().Settings.Core.Groups.Values.All(g => g.CharacterID != numericCharId))
{
await LogHelper.LogWarning($"Unathorized notify feed request from {characterID}");
await response.WriteContentAsync(File.ReadAllText(SettingsManager.FileTemplateAuthNotifyFail)
.Replace("{message}", LM.Get("authTokenInvalid"))
.Replace("{header}", LM.Get("authTokenHeader")).Replace("{body}", LM.Get("authTokenBodyFail")).Replace("{backText}", LM.Get("backText")));
return(true);
}
await SQLHelper.SQLiteDataInsertOrUpdateTokens(result[1] ?? "", characterID, null);
await LogHelper.LogInfo($"Notification feed added for character: {characterID}", LogCat.AuthWeb);
await response.WriteContentAsync(File.ReadAllText(SettingsManager.FileTemplateAuthNotifySuccess)
.Replace("{body2}", string.Format(LM.Get("authTokenRcv2"), rChar.name))
.Replace("{body}", LM.Get("authTokenRcv")).Replace("{header}", LM.Get("authTokenHeader")).Replace("{backText}", LM.Get("backText")));
return(true);
}
var foundList = new List <int>();
foreach (var group in Settings.Core.AuthGroups.Values)
{
if (group.CorpID != 0)
{
foundList.Add(group.CorpID);
}
if (group.AllianceID != 0)
{
foundList.Add(group.AllianceID);
}
}
if (rChar == null)
{
esiFailure = true;
}
var corpID = rChar?.corporation_id ?? 0;
var rCorp = await APIHelper.ESIAPI.GetCorporationData(Reason, rChar?.corporation_id, true);
if (rCorp == null)
{
esiFailure = true;
}
var allianceID = rCorp?.alliance_id ?? 0;
if (corpID != 0 && foundList.Contains(corpID) || allianceID != 0 && foundList.Contains(allianceID) || foundList.Count == 0)
{
add = true;
}
if (!esiFailure && add)
{
await SQLHelper.SQLiteDataInsertOrUpdate("pendingUsers", new Dictionary <string, object>
{
{ "characterID", characterID },
{ "corporationID", corpID.ToString() },
{ "allianceID", allianceID.ToString() },
{ "authString", uid },
{ "active", "1" },
{ "groups", "[]" },
{ "dateCreated", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") }
});
response.Headers.ContentEncoding.Add("utf-8");
response.Headers.ContentType.Add("text/html;charset=utf-8");
await response.WriteContentAsync(File.ReadAllText(SettingsManager.FileTemplateAuth2).Replace("{url}", Settings.Core.DiscordUrl).Replace("{image}", image)
.Replace("{uid}", uid).Replace("{header}", LM.Get("authTemplateHeader"))
.Replace("{body}", string.Format(LM.Get("authTemplateSucc1"), rChar.name))
.Replace("{body2}", LM.Get("authTemplateSucc2")).Replace("{body3}", LM.Get("authTemplateSucc3")).Replace("{backText}", LM.Get("backText")));
}
else if (!esiFailure)
{
var message = "ERROR";
if (!add)
{
message = LM.Get("authNonAlly");
}
response.Headers.ContentEncoding.Add("utf-8");
response.Headers.ContentType.Add("text/html;charset=utf-8");
await response.WriteContentAsync(File.ReadAllText(SettingsManager.FileTemplateAuth3).Replace("{message}", message)
.Replace("{header}", LM.Get("authTemplateHeader")).Replace("{backText}", LM.Get("backText")));
}
else
{
var message = LM.Get("ESIFailure");
response.Headers.ContentEncoding.Add("utf-8");
response.Headers.ContentType.Add("text/html;charset=utf-8");
await response.WriteContentAsync(File.ReadAllText(SettingsManager.FileTemplateAuth3).Replace("{message}", message)
.Replace("{header}", LM.Get("authTemplateHeader")).Replace("{backText}", LM.Get("backText")));
}
return(true);
}
}
}
catch (Exception ex)
{
await LogHelper.LogEx($"Error: {ex.Message}", ex, Category);
}
return(false);
}
public override async Task Run(object prm)
{
if (IsRunning)
{
return;
}
IsRunning = true;
try
{
if ((DateTime.Now - _lastCheckTime).TotalMinutes < _checkInterval)
{
return;
}
_lastCheckTime = DateTime.Now;
await LogHelper.LogModule("Running Mail module check...", Category);
foreach (var(groupName, group) in Settings.MailModule.GetEnabledGroups())
{
if (group.DefaultChannel == 0)
{
continue;
}
var defaultChannel = group.DefaultChannel;
var chars = GetParsedCharacters(groupName) ?? new List <long>();
foreach (var charId in chars)
{
if (charId == 0)
{
continue;
}
var rToken = await SQLHelper.GetRefreshTokenMail(charId);
if (string.IsNullOrEmpty(rToken))
{
await SendOneTimeWarning(charId, $"Mail feed token for character {charId} not found! User is not authenticated.");
continue;
}
var tq = await APIHelper.ESIAPI.RefreshToken(rToken, Settings.WebServerModule.CcpAppClientId, Settings.WebServerModule.CcpAppSecret
, $"From {Category} | Char ID: {charId}");
var token = tq.Result;
if (string.IsNullOrEmpty(token))
{
await LogHelper.LogWarning($"Unable to get contracts token for character {charId}. Refresh token might be outdated or no more valid {tq.Data.ErrorCode}({tq.Data.Message})", Category);
continue;
}
var includePrivate = group.IncludePrivateMail;
if (group.Filters.Values.All(a => a.FilterSenders.Count == 0 && a.FilterLabels.Count == 0 && a.FilterMailList.Count == 0))
{
await LogHelper.LogWarning($"Mail feed for user {charId} has no labels, lists or senders configured!", Category);
continue;
}
var labelsData = await APIHelper.ESIAPI.GetMailLabels(Reason, charId.ToString(), token);
var searchLabels = labelsData?.labels.Where(a => a.name?.ToLower() != "sent" && a.name?.ToLower() != "received").ToList() ??
new List <JsonClasses.MailLabel>();
var mailLists = await APIHelper.ESIAPI.GetMailLists(Reason, charId, token);
var etag = _tags.GetOrNull(charId);
var result = await APIHelper.ESIAPI.GetMailHeaders(Reason, charId.ToString(), token, 0, etag);
_tags.AddOrUpdateEx(charId, result.Data.ETag);
if (result.Data.IsNotModified)
{
continue;
}
var mailsHeaders = result.Result;
var lastMailId = await SQLHelper.GetLastMailId(charId);
var prevMailId = lastMailId;
if (lastMailId > 0)
{
mailsHeaders = mailsHeaders.Where(a => a.mail_id > lastMailId).OrderBy(a => a.mail_id).ToList();
}
else
{
lastMailId = mailsHeaders.OrderBy(a => a.mail_id).LastOrDefault()?.mail_id ?? 0;
mailsHeaders.Clear();
}
foreach (var mailHeader in mailsHeaders)
{
try
{
if (mailHeader.mail_id <= lastMailId)
{
continue;
}
lastMailId = mailHeader.mail_id;
if (!includePrivate && (mailHeader.recipients.Count(a => a.recipient_id == charId) > 0))
{
continue;
}
foreach (var filter in group.Filters.Values)
{
//filter by senders
if (filter.FilterSenders.Count > 0 && !filter.FilterSenders.Contains(mailHeader.from))
{
continue;
}
//filter by labels
var labelIds = searchLabels.Where(a => filter.FilterLabels.Contains(a.name)).Select(a => a.label_id).ToList();
if (labelIds.Count > 0 && !mailHeader.labels.Any(a => labelIds.Contains(a)))
{
continue;
}
//filter by mail lists
var mailListIds = filter.FilterMailList.Count > 0
? mailLists.Where(a => filter.FilterMailList.Any(b => a.name.Equals(b, StringComparison.OrdinalIgnoreCase))).Select(a => a.mailing_list_id)
.ToList()
: new List <long>();
if (mailListIds.Count > 0 && !mailHeader.recipients.Where(a => a.recipient_type == "mailing_list")
.Any(a => mailListIds.Contains(a.recipient_id)))
{
continue;
}
var mail = await APIHelper.ESIAPI.GetMail(Reason, charId.ToString(), token, mailHeader.mail_id);
// var labelNames = string.Join(",", mail.labels.Select(a => searchLabels.FirstOrDefault(l => l.label_id == a)?.name)).Trim(',');
var sender = await APIHelper.ESIAPI.GetCharacterData(Reason, mail.from);
var from = sender?.name;
var ml = mailHeader.recipients.FirstOrDefault(a => a.recipient_type == "mailing_list" && mailListIds.Contains(a.recipient_id));
if (ml != null)
{
from = $"{sender?.name}[{mailLists.First(a => a.mailing_list_id == ml.recipient_id).name}]";
}
var channel = filter.FeedChannel > 0 ? filter.FeedChannel : defaultChannel;
await SendMailNotification(channel, mail, LM.Get("mailMsgTitle", from), group.DefaultMention, filter.DisplayDetailsSummary);
break;
}
}
catch (Exception ex)
{
await LogHelper.LogEx($"MailCheck: {mailHeader?.mail_id} {mailHeader?.subject}", ex);
}
}
if (prevMailId != lastMailId || lastMailId == 0)
{
await SQLHelper.UpdateMail(charId, lastMailId);
}
}
}
// await LogHelper.LogModule("Completed", Category);
}
catch (Exception ex)
{
await LogHelper.LogEx(ex.Message, ex, Category);
// await LogHelper.LogModule("Completed", Category);
}
finally
{
IsRunning = false;
}
}
internal static async Task AuthUser(ICommandContext context, string remainder)
{
try
{
var esiFailed = false;
var responce = await SQLHelper.GetPendingUser(remainder);
if (!responce.Any())
{
await APIHelper.DiscordAPI.ReplyMessageAsync(context, context.Channel, LM.Get("authHasInvalidKey"), true).ConfigureAwait(false);
}
else
{
switch (responce[0]["active"].ToString())
{
case "0":
await APIHelper.DiscordAPI.ReplyMessageAsync(context, context.Channel, LM.Get("authHasInactiveKey"), true).ConfigureAwait(false);
break;
case "1":
// var authgroups = SettingsManager.GetSubList("auth", "authgroups");
// var corps = new Dictionary<string, string>();
// var alliance = new Dictionary<string, string>();
var foundList = new Dictionary <int, List <string> >();
foreach (var group in TickManager.GetModule <WebAuthModule>().Settings.Core.AuthGroups.Values)
{
if (group.CorpID != 0)
{
foundList.Add(group.CorpID, group.MemberRoles);
}
if (group.AllianceID != 0)
{
foundList.Add(group.AllianceID, group.MemberRoles);
}
}
var characterID = responce[0]["characterID"].ToString();
var characterData = await APIHelper.ESIAPI.GetCharacterData("WebAuth", characterID, true);
if (characterData == null)
{
esiFailed = true;
}
var corporationData = await APIHelper.ESIAPI.GetCorporationData("WebAuth", characterData.corporation_id);
if (corporationData == null)
{
esiFailed = true;
}
var allianceID = characterData.alliance_id ?? 0;
var corpID = characterData.corporation_id;
bool enable = foundList.ContainsKey(corpID) || characterData.alliance_id != null && foundList.ContainsKey(allianceID) || foundList.Count == 0;
if (enable && !esiFailed)
{
await AuthGrantRoles(context, characterID, foundList, characterData, corporationData, remainder);
}
else
{
await APIHelper.DiscordAPI.SendMessageAsync(context.Channel, LM.Get("ESIFailure")).ConfigureAwait(false);
await LogHelper.LogError("ESI Failure", LogCat.AuthWeb).ConfigureAwait(false);
}
break;
}
}
}
catch (Exception ex)
{
await LogHelper.LogEx($"Error: {ex.Message}", ex, LogCat.AuthWeb).ConfigureAwait(false);
}
}
private static async Task AuthGrantRoles(ICommandContext context, string characterID, Dictionary <int, List <string> > foundList, JsonClasses.CharacterData characterData, JsonClasses.CorporationData corporationData, string remainder)
{
var rolesToAdd = new List <SocketRole>();
var allianceID = characterData.alliance_id ?? 0;
var corpID = characterData.corporation_id;
var authSettings = TickManager.GetModule <WebAuthModule>()?.Settings.Core;
try
{
//Check for Corp roles
if (foundList.ContainsKey(corpID))
{
var cRoles = foundList[corpID];
cRoles.ForEach(a =>
{
var f = APIHelper.DiscordAPI.GetGuildRole(a);
if (f != null && !rolesToAdd.Contains(f))
{
rolesToAdd.Add(f);
}
});
}
//Check for Alliance roles
if (foundList.ContainsKey(allianceID))
{
var cRoles = foundList[allianceID];
cRoles.ForEach(a =>
{
var f = APIHelper.DiscordAPI.GetGuildRole(a);
if (f != null && !rolesToAdd.Contains(f))
{
rolesToAdd.Add(f);
}
});
}
var discordUser = APIHelper.DiscordAPI.GetUser(context.Message.Author.Id);
if (authSettings.AuthReportChannel != 0)
{
await APIHelper.DiscordAPI.SendMessageAsync(authSettings.AuthReportChannel, string.Format(LM.Get("grantRolesMessage"), characterData.name))
.ConfigureAwait(false);
}
await APIHelper.DiscordAPI.AssignRolesToUser(discordUser, rolesToAdd);
var rolesString = new StringBuilder();
foreach (var role in discordUser.Roles)
{
if (role.Name.StartsWith("@everyone"))
{
continue;
}
rolesString.Append(role.Name.Replace("\"", "&br;"));
rolesString.Append(",");
}
if (rolesString.Length > 0)
{
rolesString.Remove(rolesString.Length - 1, 1);
}
await SQLHelper.SQLiteDataUpdate("pendingUsers", "active", "0", "authString", remainder);
await APIHelper.DiscordAPI.SendMessageAsync(context.Channel, string.Format(LM.Get("msgAuthSuccess"), context.Message.Author.Mention, characterData.name));
var eveName = characterData.name;
var discordID = discordUser.Id;
var addedOn = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
await SQLHelper.SQLiteDataInsertOrUpdate("authUsers", new Dictionary <string, object>
{
{ "eveName", eveName },
{ "characterID", characterID },
{ "discordID", discordID.ToString() },
{ "role", rolesString.ToString() },
{ "active", "yes" },
{ "addedOn", addedOn }
});
if (authSettings.EnforceCorpTickers || authSettings.EnforceCharName)
{
var nickname = "";
if (authSettings.EnforceCorpTickers)
{
nickname = $"[{corporationData.ticker}] ";
}
if (authSettings.EnforceCharName)
{
nickname += $"{eveName}";
}
else
{
nickname += $"{discordUser.Username}";
}
try
{
//will throw ex on admins
await discordUser.ModifyAsync(x => x.Nickname = nickname);
}
catch
{
//ignore
}
await APIHelper.DiscordAPI.Dupes(discordUser);
}
}
catch (Exception ex)
{
await LogHelper.LogEx($"Failed adding Roles to User {characterData.name}, Reason: {ex.Message}", ex, LogCat.Discord);
}
}
public override void SearchingObjectivesToAttack()
{
myCurrentObjective = null;
myCurrentObjectiveTile = null;
pathToObjective.Clear();
if (isDead || hasAttacked)
{
myCurrentEnemyState = enemyState.Ended;
return;
}
if (!haveIBeenAlerted)
{
//Comprobar las unidades que hay en mi rango de acción
unitsInRange = LM.TM.GetAllUnitsInRangeWithoutPathfinding(rangeOfAction, GetComponent <UnitBase>());
//Si hay personajes del jugador en mi rango de acción paso a attacking donde me alerto y hago mi accion
for (int i = 0; i < unitsInRange.Count; i++)
{
if (unitsInRange[i].GetComponent <PlayerUnit>())
{
myCurrentEnemyState = enemyState.Attacking;
return;
}
}
//Si llega hasta aqui significa que no había personajes en rango y termina
myCurrentEnemyState = enemyState.Ended;
}
else
{
//Determinamos el enemigo más cercano.
currentUnitsAvailableToAttack = LM.CheckEnemyPathfinding(GetComponent <EnemyUnit>());
//Si esta oculto lo quito de la lista de objetivos
for (int i = 0; i < currentUnitsAvailableToAttack.Count; i++)
{
if (currentUnitsAvailableToAttack[i].isHidden)
{
currentUnitsAvailableToAttack.RemoveAt(i);
i--;
}
}
//Si no hay enemigos termina su turno
if (currentUnitsAvailableToAttack.Count == 0)
{
myCurrentEnemyState = enemyState.Ended;
}
else if (currentUnitsAvailableToAttack.Count > 0)
{
if (currentUnitsAvailableToAttack.Count == 1)
{
//Añado esto para eliminar a los personajes ocultos
base.SearchingObjectivesToAttack();
if (currentUnitsAvailableToAttack.Count == 1)
{
myCurrentObjective = currentUnitsAvailableToAttack[0];
myCurrentObjectiveTile = myCurrentObjective.myCurrentTile;
}
}
//Si hay varios enemigos a la misma distancia, se queda con el que tenga más unidades adyacentes
else if (currentUnitsAvailableToAttack.Count > 1)
{
//Ordeno la lista de posibles objetivos según el número de unidades dyacentes
currentUnitsAvailableToAttack.Sort(delegate(UnitBase a, UnitBase b)
{
return((b.myCurrentTile.neighboursOcuppied).CompareTo(a.myCurrentTile.neighboursOcuppied));
});
//Elimino a todos los objetivos de la lista que no tengan el mayor número de enemigos adyacentes
for (int i = currentUnitsAvailableToAttack.Count - 1; i > 0; i--)
{
if (currentUnitsAvailableToAttack[0].myCurrentTile.neighboursOcuppied > currentUnitsAvailableToAttack[i].myCurrentTile.neighboursOcuppied)
{
currentUnitsAvailableToAttack.RemoveAt(i);
}
}
//Si sigue habiendo varios enemigos los ordeno segun la vida
if (currentUnitsAvailableToAttack.Count > 1)
{
//Añado esto para eliminar a los personajes ocultos
base.SearchingObjectivesToAttack();
//Ordeno la lista de posibles objetivos de menor a mayor vida actual
currentUnitsAvailableToAttack.Sort(delegate(UnitBase a, UnitBase b)
{
return((a.currentHealth).CompareTo(b.currentHealth));
});
}
myCurrentObjective = currentUnitsAvailableToAttack[0];
myCurrentObjectiveTile = myCurrentObjective.myCurrentTile;
}
//CAMBIAR ESTO (lm.tm)
LM.TM.CalculatePathForMovementCost(myCurrentObjectiveTile.tileX, myCurrentObjectiveTile.tileZ, false);
//No vale con igualar pathToObjective= LM.TM.currentPath porque entonces toma una referencia de la variable no de los valores.
//Esto significa que si LM.TM.currentPath cambia de valor también lo hace pathToObjective
for (int i = 0; i < LM.TM.currentPath.Count; i++)
{
pathToObjective.Add(LM.TM.currentPath[i]);
}
myCurrentEnemyState = enemyState.Attacking;
}
}
}
public static async Task <bool> Download(string installMode, ObservableCollection <SModel.Ivsu> ivsuList,
SModel.SRegion selectedRegion, string selectedRelease, string selectedMapVersion, string driveLetter, USBHelper.Drive selectedDrive)
{
if (await SetIvsuList(installMode, ivsuList, selectedRegion, selectedRelease, selectedMapVersion, driveLetter) == false)
{
await Application.Current.Dispatcher.BeginInvoke(() => UIHelper.ShowErrorDialog(LM.GetValue("MessageBox.NoPackagesSelected")));
return(false);
}
bool canceldownload = false;
//Install Mode is reformat or downgrade My20 warning
if ((installMode == "reformat" || installMode == "downgrade") && !AppMan.App.DownloadOnly && AppMan.App.Settings.My20v2 == null)
{
if (await Application.Current.Dispatcher.Invoke(() => UIHelper.ShowDialog(string.Format(LM.GetValue("MessageBox.My20Check")), LM.GetValue("String.Warning") + "!", LM.GetValue("String.No"),
LM.GetValue("String.Yes"), null, ContentDialogButton.None, Brushes.DarkRed)) == ContentDialogResult.Primary)
{
await USBHelper.LogPrepareUSBAction(selectedDrive, driveLetter, "logutilitymy20");
return(true);
}
}
//Warn is users region is different to new selection
if (selectedRegion.Code != AppMan.App.Settings.CurrentRegion)
{
if (await Application.Current.Dispatcher.Invoke(() => UIHelper.ShowWarningDialog(string.Format(LM.GetValue("MessageBox.CancelRegionMismatch")), LM.GetValue("String.Warning") + "!", LM.GetValue("String.No"),
LM.GetValue("String.Yes"))) != ContentDialogResult.Primary)
{
canceldownload = true;
}
}
//Cancel no apps package selected
if (!AppMan.App.AppsSelected && (installMode == "reformat" || installMode == "downgrade"))
{
await Application.Current.Dispatcher.BeginInvoke(() => UIHelper.ShowErrorDialog(LM.GetValue("MessageBox.CancelNoApps")));
canceldownload = true;
}
if (!canceldownload && (AppMan.App.DownloadOnly || !await SanityCheckHelper.CancelDownloadCheck(selectedDrive)))
{
if (AppMan.App.DownloadOnly)
{
AppMan.Logger.Info($"Starting download only of ({selectedRelease} - {selectedRegion?.Code} - {selectedMapVersion})");
}
else
{
AppMan.App.DriveNumber = selectedDrive.Path.Replace("Win32_DiskDrive.DeviceID=\"\\\\\\\\.\\\\PHYSICALDRIVE", "").Replace("\"", "");
AppMan.App.DriveLetter = driveLetter;
AppMan.Logger.Info($"Starting process ({selectedRelease} - {selectedRegion?.Code} - {selectedMapVersion})");
}
AppMan.App.IsDownloading = true;
AppMan.App.FireDownloadsTabEvent();
return(true);
}
return(false);
}
internal static async void OnMessage(object sender, MessageEventArgs e)
{
if (!APIHelper.IsDiscordAvailable)
{
return;
}
var filtered = false;
if (e.Message.Chatstate != Chatstate.Composing && !string.IsNullOrWhiteSpace(e.Message.Value))
{
if (SettingsManager.Settings.JabberModule.Filter)
{
foreach (var filter in SettingsManager.Settings.JabberModule.Filters)
{
if (e.Message.Value.ToLower().Contains(filter.Key.ToLower()))
{
var prepend = SettingsManager.Settings.JabberModule.Prepend;
var channelId = Convert.ToUInt64(filter.Value);
filtered = true;
await APIHelper.DiscordAPI.SendMessageAsync(channelId, $"{prepend + Environment.NewLine}{LM.Get("From")}: {e.Message.From.User} {Environment.NewLine} {LM.Get("Message")}: ```{e.Message.Value}```").ConfigureAwait(false);
}
}
}
if (!string.IsNullOrWhiteSpace(e.Message.Value) && !filtered)
{
var prepend = SettingsManager.Settings.JabberModule.Prepend;
if (SettingsManager.Settings.JabberModule.DefChan > 0)
{
await APIHelper.DiscordAPI.SendMessageAsync(SettingsManager.Settings.JabberModule.DefChan, $"{prepend + Environment.NewLine}{LM.Get("From")}: {e.Message.From.User} {Environment.NewLine} {LM.Get("Message")}: ```{e.Message.Value}```").ConfigureAwait(false);
}
}
}
}
public async Task Help()
{
await APIHelper.DiscordAPI.ReplyMessageAsync(Context, $"{LM.Get("helpText")}");
}
public static async Task FeedSpyMail(IEnumerable <AuthUserEntity> users, ulong feedChannel)
{
var reason = LogCat.HRM.ToString();
//preload initial mail IDs to suppress possible dupes on start
foreach (var user in users.Where(a => a.Data.LastSpyMailId > 0))
{
if (!LastSpyMailIds.Contains(user.Data.LastSpyMailId))
{
LastSpyMailIds.Add(user.Data.LastSpyMailId);
}
}
//processing
foreach (var user in users)
{
var corp = user.Data.CorporationId;
var ally = user.Data.AllianceId;
var filter = SettingsManager.Settings.HRMModule.SpyFilters.FirstOrDefault(a => a.Value.CorpIds.ContainsValue(corp)).Value;
if (filter != null)
{
feedChannel = filter.MailFeedChannelId;
}
else
{
if (ally > 0)
{
filter = SettingsManager.Settings.HRMModule.SpyFilters.FirstOrDefault(a => a.Value.AllianceIds.ContainsValue(ally)).Value;
if (filter != null)
{
feedChannel = filter.MailFeedChannelId;
}
}
}
if (feedChannel == 0)
{
continue;
}
var displaySummary = filter?.DisplayMailDetailsSummary ?? true;
try
{
if (!SettingsManager.HasReadMailScope(user.Data.PermissionsList))
{
continue;
}
var token = (await APIHelper.ESIAPI.RefreshToken(user.RefreshToken, SettingsManager.Settings.WebServerModule.CcpAppClientId,
SettingsManager.Settings.WebServerModule.CcpAppSecret, $"From Mail | Char ID: {user.CharacterId} | Char name: {user.Data.CharacterName}"))?.Result;
if (string.IsNullOrEmpty(token))
{
continue;
}
var mailHeaders = (await APIHelper.ESIAPI.GetMailHeaders(reason, user.CharacterId.ToString(), token, 0, null))?.Result;
if (mailHeaders == null || !mailHeaders.Any())
{
continue;
}
if (user.Data.LastSpyMailId > 0)
{
foreach (var mailHeader in mailHeaders.Where(a => a.mail_id > user.Data.LastSpyMailId))
{
if (LastSpyMailIds.Contains(mailHeader.mail_id))
{
continue;
}
LastSpyMailIds.Add(mailHeader.mail_id);
if (LastSpyMailIds.Count > 100)
{
LastSpyMailIds.RemoveRange(0, 20);
}
var mail = await APIHelper.ESIAPI.GetMail(reason, user.CharacterId, token, mailHeader.mail_id);
var sender = await APIHelper.ESIAPI.GetCharacterData(reason, mail.from);
mailHeader.ToName = await GetRecepientNames(reason, mailHeader.recipients, user.CharacterId, token);
var from = $"{user.Data.CharacterName}[{user.Data.AllianceTicker ?? user.Data.CorporationTicker}]";
await SendMailNotification(feedChannel, mail, $"**{LM.Get("hrmSpyFeedFrom")} {from}**\n__{LM.Get("hrmSpyMsgFrom",sender?.name, mailHeader.ToName)}__", " ", displaySummary);
}
}
user.Data.LastSpyMailId = mailHeaders.Max(a => a.mail_id);
await SQLHelper.SaveAuthUser(user);
}
catch (Exception ex)
{
await LogHelper.LogEx(ex.Message, ex, LogCat.HRM);
}
}
}
public async Task TQStatus()
{
var tq = await APIHelper.ESIAPI.GetServerStatus("ESIAPI");
await APIHelper.DiscordAPI.ReplyMessageAsync(Context, LM.Get("tqStatusText", tq.players > 20 ? LM.Get("online") : LM.Get("offline"), tq.players), true);
}
public static async Task <string> SearchRelated(long searchCharId, HRMModule.SearchMailItem item, string authCode)
{
var isGlobal = searchCharId == 0;
var users = new List <AuthUserEntity>();
if (isGlobal)
{
//users = await SQLHelper.GetAuthUsersWithPerms();
switch (item.smAuthType)
{
case 1:
users = (await SQLHelper.GetAuthUsersWithPerms((int)UserStatusEnum.Authed)).ToList();
break;
case 2:
users = (await SQLHelper.GetAuthUsersWithPerms((int)UserStatusEnum.Awaiting)).ToList();
break;
default:
return(null);
}
}
else
{
var u = await SQLHelper.GetAuthUserByCharacterId(searchCharId);
if (u == null)
{
return(LM.Get("hrmSearchMailErrorSourceNotFound"));
}
users.Add(u);
}
if (users.Count == 0)
{
return(LM.Get("hrmSearchMailNoUsersToCheck"));
}
var Reason = "HRM";
long charId = 0;
long corpId = 0;
long allyId = 0;
//JsonClasses.CharacterData rChar = null;
switch (item.smSearchType)
{
case 1:
var charIdLookup = await APIHelper.ESIAPI.SearchCharacterId(Reason, item.smText);
charId = charIdLookup?.character?.FirstOrDefault() ?? 0;
// rChar = charIdLookup?.character == null || charIdLookup.character.Length == 0 ? null : await APIHelper.ESIAPI.GetCharacterData(Reason, charIdLookup.character.FirstOrDefault());
if (charId == 0)
{
return(LM.Get("hrmSearchMailErrorCharNotFound"));
}
break;
case 2:
var corpIdLookup = await APIHelper.ESIAPI.SearchCorporationId(Reason, item.smText);
corpId = corpIdLookup?.corporation == null || corpIdLookup.corporation.Length == 0 ? 0 : corpIdLookup.corporation.FirstOrDefault();
if (corpId == 0)
{
return(LM.Get("hrmSearchMailErrorCorpNotFound"));
}
break;
case 3:
var allyIdLookup = await APIHelper.ESIAPI.SearchAllianceId(Reason, item.smText);
allyId = allyIdLookup?.alliance == null || allyIdLookup.alliance.Length == 0 ? 0 : allyIdLookup.alliance.FirstOrDefault();
if (allyId == 0)
{
return(LM.Get("hrmSearchMailErrorAllianceNotFound"));
}
break;
}
/* JsonClasses.CorporationData sCorp = null;
* if (!isGlobal && corpId > 0)
* sCorp = await APIHelper.ESIAPI.GetCorporationData(Reason, corpId);
* JsonClasses.AllianceData sAlly = null;
* if (!isGlobal && allyId > 0)
* sAlly = await APIHelper.ESIAPI.GetAllianceData(Reason, allyId);
*/
var sb = new StringBuilder();
foreach (var user in users)
{
if (!SettingsManager.HasReadMailScope(user.Data.PermissionsList))
{
continue;
}
var token = (await APIHelper.ESIAPI.RefreshToken(user.RefreshToken, SettingsManager.Settings.WebServerModule.CcpAppClientId,
SettingsManager.Settings.WebServerModule.CcpAppSecret, $"From Mail | Char ID: {user.CharacterId} | Char name: {user.Data.CharacterName}"))?.Result;
var mailHeaders = (await APIHelper.ESIAPI.GetMailHeaders(Reason, user.CharacterId.ToString(), token, 0, null))?.Result;
//filter
switch (item.smSearchType)
{
case 1:
{
var newList = new List <JsonClasses.MailHeader>();
newList.AddRange(mailHeaders.Where(a => a.@from == charId).ToList());
foreach (var header in newList)
{
header.ToName = isGlobal ? user.Data.CharacterName : (await GetRecepientNames(Reason, header.recipients, user.CharacterId, token));
header.FromName = item.smText;
}
var tmp = mailHeaders.Where(a => a.recipients.Any(b => b.recipient_id == charId)).ToList();
foreach (var header in tmp)
{
header.ToName = isGlobal ? item.smText : (await GetRecepientNames(Reason, header.recipients, user.CharacterId, token));
header.FromName = user.Data.CharacterName;
}
mailHeaders = newList;
mailHeaders.AddRange(tmp);
}
break;
case 2: //corp
{
var newList = new List <JsonClasses.MailHeader>();
foreach (var header in mailHeaders)
{
var ch = await APIHelper.ESIAPI.GetCharacterData(Reason, header.@from);
if (ch == null)
{
continue;
}
if (ch.corporation_id == corpId)
{
header.ToName = isGlobal ? user.Data.CharacterName : (await GetRecepientNames(Reason, header.recipients, user.CharacterId, token));
header.FromName = item.smText;
newList.Add(header);
continue;
}
if (isGlobal)
{
if (header.recipients.Any(b => b.recipient_id == corpId))
{
header.ToName = item.smText;
header.FromName = user.Data.CharacterName;
newList.Add(header);
continue;
}
}
else //detailed personal search
{
foreach (var recipient in header.recipients)
{
if (recipient.recipient_type == "character")
{
var r = await APIHelper.ESIAPI.GetCharacterData(Reason, recipient.recipient_id);
if (r == null)
{
continue;
}
if (r.corporation_id == corpId)
{
header.ToName = await GetRecepientNames(Reason, header.recipients, user.CharacterId, token);
header.FromName = user.Data.CharacterName;
newList.Add(header);
break;
}
}
else if (recipient.recipient_type == "corporation")
{
if (recipient.recipient_id == corpId)
{
header.ToName = await GetRecepientNames(Reason, header.recipients, user.CharacterId, token);
header.FromName = user.Data.CharacterName;
newList.Add(header);
break;
}
}
}
}
}
mailHeaders = newList.ToList();
}
break;
case 3: //ally
{
var newList = new List <JsonClasses.MailHeader>();
foreach (var header in mailHeaders)
{
var ch = await APIHelper.ESIAPI.GetCharacterData(Reason, header.@from);
if (ch?.alliance_id != null && (ch.alliance_id == allyId || header.@from == allyId))
{
header.ToName = isGlobal ? user.Data.CharacterName : (await GetRecepientNames(Reason, header.recipients, user.CharacterId, token));
header.FromName = item.smText;
newList.Add(header);
continue;
}
if (isGlobal)
{
if (ch?.alliance_id != null && header.recipients.Any(b => b.recipient_id == allyId))
{
header.ToName = item.smText;
header.FromName = user.Data.CharacterName;
newList.Add(header);
continue;
}
}
else
{
foreach (var recipient in header.recipients)
{
if (recipient.recipient_type == "character")
{
var r = await APIHelper.ESIAPI.GetCharacterData(Reason, recipient.recipient_id);
if (r == null)
{
continue;
}
if (r.alliance_id.HasValue && r.alliance_id == allyId)
{
header.ToName = await GetRecepientNames(Reason, header.recipients, user.CharacterId, token);
header.FromName = user.Data.CharacterName;
newList.Add(header);
break;
}
}
else if (recipient.recipient_type == "corporation")
{
var corp = await APIHelper.ESIAPI.GetCorporationData(Reason, recipient.recipient_id);
if (corp == null)
{
continue;
}
if (corp.alliance_id.HasValue && corp.alliance_id == allyId)
{
header.ToName = await GetRecepientNames(Reason, header.recipients, user.CharacterId, token);
header.FromName = user.Data.CharacterName;
newList.Add(header);
break;
}
}
else if (recipient.recipient_type == "alliance")
{
if (recipient.recipient_id == allyId)
{
header.ToName = await GetRecepientNames(Reason, header.recipients, user.CharacterId, token);
header.FromName = user.Data.CharacterName;
newList.Add(header);
break;
}
}
}
continue;
}
}
mailHeaders = newList.ToList();
}
break;
case 4: //header text
{
mailHeaders = mailHeaders.Where(a => a.subject.Contains(item.smText, StringComparison.OrdinalIgnoreCase)).ToList();
}
break;
}
foreach (var entry in mailHeaders)
{
var mailBodyUrl = WebServerModule.GetHRM_AjaxMailURL(entry.mail_id, user.CharacterId, authCode);
sb.AppendLine("<tr>");
sb.AppendLine($" <td><a href=\"#\" onclick=\"openMailDialog('{mailBodyUrl}')\">{entry.subject}</td>");
sb.AppendLine($" <td>{entry.FromName ?? LM.Get("Unknown")}</td>");
sb.AppendLine($" <td>{entry.ToName ?? LM.Get("Unknown")}</td>");
sb.AppendLine($" <td>{entry.Date.ToShortDateString()}</td>");
sb.AppendLine("</tr>");
}
}
if (sb.Length > 0)
{
var sbFinal = new StringBuilder();
sbFinal.AppendLine("<thead>");
sbFinal.AppendLine("<tr>");
sbFinal.AppendLine($"<th scope=\"col-md-auto\">{LM.Get("mailSubjectHeader")}</th>");
sbFinal.AppendLine($"<th scope=\"col-md-auto\">{LM.Get("mailFromHeader")}</th>");
sbFinal.AppendLine($"<th scope=\"col-md-auto\">{LM.Get("mailToHeader")}</th>");
sbFinal.AppendLine($"<th scope=\"col\">{LM.Get("mailDateHeader")}</th>");
sbFinal.AppendLine("</tr>");
sbFinal.AppendLine("</thead>");
sbFinal.AppendLine("<tbody>");
sbFinal.Append(sb.ToString());
sbFinal.AppendLine("</tbody>");
return(sbFinal.ToString());
}
return("No results");
}
public async Task Help([Remainder] string x)
{
var forbidden = APIHelper.DiscordAPI.GetConfigForbiddenPublicChannels();
if (forbidden.Any() && forbidden.Contains(Context.Channel.Id))
{
return;
}
switch (x)
{
case "help":
await APIHelper.DiscordAPI.ReplyMessageAsync(Context, $"{LM.Get("helpHelp")}", true);
break;
case "web":
await APIHelper.DiscordAPI.ReplyMessageAsync(Context, $"{LM.Get("helpWeb")}", true);
break;
case "auth":
await APIHelper.DiscordAPI.ReplyMessageAsync(Context, $"{LM.Get("helpAuth")}", true);
break;
case "authnotify":
await APIHelper.DiscordAPI.ReplyMessageAsync(Context, $"{LM.Get("helpAuthNotify")}", true);
break;
case "evetime":
await APIHelper.DiscordAPI.ReplyMessageAsync(Context, $"{LM.Get("helpTime")}", true);
break;
case "stat":
case "stats":
await APIHelper.DiscordAPI.ReplyMessageAsync(Context, $"{LM.Get("helpStat")}", true);
break;
case "about":
await APIHelper.DiscordAPI.ReplyMessageAsync(Context, $"{LM.Get("helpAbout")}", true);
break;
case "char":
await APIHelper.DiscordAPI.ReplyMessageAsync(Context, $"{LM.Get("helpChar")}", true);
break;
case "corp":
await APIHelper.DiscordAPI.ReplyMessageAsync(Context, $"{LM.Get("helpCorp")}", true);
break;
case CMD_TQ:
await APIHelper.DiscordAPI.ReplyMessageAsync(Context, $"{LM.Get("helpTQ")}", true);
break;
case "jita":
case "amarr":
case "dodixie":
case "rens":
await APIHelper.DiscordAPI.ReplyMessageAsync(Context, $"{LM.Get("helpJita")}", true);
break;
case "pc":
await APIHelper.DiscordAPI.ReplyMessageAsync(Context, $"{LM.Get("helpPc")}", true);
break;
case CMD_FWSTATS:
await APIHelper.DiscordAPI.ReplyMessageAsync(Context, $"{LM.Get("helpFwstats", CMD_FWSTATS)}", true);
break;
case CMD_TURL:
await APIHelper.DiscordAPI.ReplyMessageAsync(Context, $"{LM.Get("helpTurl")}", true);
break;
case CMD_TIMERS:
await APIHelper.DiscordAPI.ReplyMessageAsync(Context, $"{LM.Get("helpTimers")}", true);
break;
}
}
private async Task ReportIncursion(JsonClasses.IncursionData incursion, JsonClasses.ConstellationData c, IMessageChannel channel)
{
var result = await SQLHelper.IsIncurionExists(incursion.constellation_id);
//skip existing incursion report
var isUpdate = result && Settings.IncursionNotificationModule.ReportIncursionStatusAfterDT;
if (!isUpdate && result)
{
return;
}
if (!isUpdate)
{
await SQLHelper.AddIncursion(incursion.constellation_id);
}
c = c ?? await APIHelper.ESIAPI.GetConstellationData(Reason, incursion.constellation_id);
var r = await APIHelper.ESIAPI.GetRegionData(Reason, c.region_id);
var sb = new StringBuilder();
foreach (var system in incursion.infested_solar_systems)
{
sb.Append((await APIHelper.ESIAPI.GetSystemData(Reason, system)).name);
sb.Append(" | ");
}
sb.Remove(sb.Length - 3, 2);
var x = new EmbedBuilder().WithTitle(isUpdate ? LM.Get("incursionUpdateHeader", c.name, r.name) : LM.Get("incursionNewHeader", c.name, r.name))
.WithColor(isUpdate ? new Color(0x000045) : new Color(0xdd5353))
.WithThumbnailUrl(Settings.Resources.ImgIncursion)
.AddField(LM.Get("incursionInfestedSystems"), sb.ToString())
.AddField(LM.Get("incursionInfluence"), (incursion.influence).ToString("P"), true)
.AddField(LM.Get("incursionBoss"), incursion.has_boss ? LM.Get("Alive") : LM.Get("Defeated"), true)
.WithCurrentTimestamp()
.Build();
await APIHelper.DiscordAPI.SendMessageAsync(channel, Settings.IncursionNotificationModule.DefaultMention ?? "", x);
}
private async Task SendDiscordMessage(JsonClasses.IndustryJob job, bool isStatusChange, List <ulong> discordChannels, bool isCorp, string token)
{
if (job == null)
{
return;
}
string statusText;
string timeToComplete = null;
switch (job.StatusValue)
{
case IndustryJobStatusEnum.active:
statusText = LM.Get("industryJobsStatusActive");
timeToComplete = TimeSpan.FromSeconds(job.duration).ToFormattedString(" ");
break;
case IndustryJobStatusEnum.cancelled:
statusText = LM.Get("industryJobsStatusCancelled");
break;
case IndustryJobStatusEnum.delivered:
statusText = LM.Get("industryJobsStatusDelivered");
break;
case IndustryJobStatusEnum.paused:
statusText = LM.Get("industryJobsStatusPaused");
break;
case IndustryJobStatusEnum.ready:
statusText = LM.Get("industryJobsStatusReady");
break;
case IndustryJobStatusEnum.reverted:
statusText = LM.Get("industryJobsStatusReverted");
break;
default:
throw new ArgumentOutOfRangeException($"Unknown job status: {job.StatusValue}");
}
string activityText;
switch (job.Activity)
{
case IndustryJobActivity.none:
activityText = LM.Get("industryJobsActivityNone");
break;
case IndustryJobActivity.build:
activityText = LM.Get("industryJobsActivityBuild");
break;
case IndustryJobActivity.techResearch:
activityText = LM.Get("industryJobsActivityTechResearch");
break;
case IndustryJobActivity.te:
activityText = LM.Get("industryJobsActivityTEResearch");
break;
case IndustryJobActivity.me:
activityText = LM.Get("industryJobsActivityMEResearch");
break;
case IndustryJobActivity.copy:
activityText = LM.Get("industryJobsActivityCopying");
break;
case IndustryJobActivity.duplicating:
activityText = LM.Get("industryJobsActivityDuplicating");
break;
case IndustryJobActivity.reverseEng:
activityText = LM.Get("industryJobsActivityReverseEng");
break;
case IndustryJobActivity.inventing:
activityText = LM.Get("industryJobsActivityInventing");
break;
case IndustryJobActivity.reaction:
activityText = LM.Get("industryJobsActivityReaction");
break;
case IndustryJobActivity.reaction2:
activityText = LM.Get("industryJobsActivityReaction");
break;
default:
throw new ArgumentOutOfRangeException($"Unknown activity {job.activity_id}");
}
var bpType = await APIHelper.ESIAPI.GetTypeId(Reason, job.blueprint_type_id);
var productType = await APIHelper.ESIAPI.GetTypeId(Reason, job.product_type_id);
var completedBy = job.completed_character_id > 0 ? await APIHelper.ESIAPI.GetCharacterData(Reason, job.completed_character_id) : null;
var unk = LM.Get("Unknown");
var installer = job.installer_id > 0 ? await APIHelper.ESIAPI.GetCharacterData(Reason, job.installer_id) : null;
var station = (await APIHelper.ESIAPI.GetStationData(Reason, job.facility_id, token))?.name ?? (await APIHelper.ESIAPI.GetStructureData(Reason, job.facility_id, token))?.name;
var header = isStatusChange ? LM.Get("industryJobsStatusHeader") : LM.Get("industryJobsNewHeader");
var sb = new StringBuilder();
var color = isStatusChange ? null : "fix";
var colorMark = string.Empty;
var colorMove = string.Empty;
if (job.StatusValue == IndustryJobStatusEnum.cancelled || job.StatusValue == IndustryJobStatusEnum.reverted)
{
color = "diff";
colorMark = "-";
colorMove = " ";
}
if (job.StatusValue == IndustryJobStatusEnum.ready || job.StatusValue == IndustryJobStatusEnum.delivered)
{
color = "diff";
colorMark = "+";
colorMove = " ";
}
sb.AppendLine($"```{color}");
sb.AppendLine($"*{header}*");
sb.AppendLine($"{colorMove}{LM.Get("industryJobsRowActivity"),-11}: {activityText}");
sb.AppendLine($"{colorMark}{LM.Get("industryJobsRowStatus"),-11}: {statusText}");
if (job.Activity == IndustryJobActivity.build || job.Activity == IndustryJobActivity.inventing || job.Activity == IndustryJobActivity.reverseEng)
{
sb.AppendLine($"{colorMove}{LM.Get("industryJobsRowFrom"),-11}: {bpType?.name ?? unk}");
sb.AppendLine($"{colorMove}{LM.Get("industryJobsRowTo"),-11}: {productType?.name ?? unk}");
}
else
{
sb.AppendLine($"{colorMove}{LM.Get("industryJobsRowBPO"),-11}: {productType?.name ?? unk}");
}
if (!string.IsNullOrEmpty(timeToComplete))
{
sb.AppendLine($"{colorMove}{LM.Get("industryJobsRowDuration"),-11}: {timeToComplete}");
}
if (installer != null)
{
sb.AppendLine($"{colorMove}{LM.Get("industryJobsRowInstaller"),-11}: {installer.name}");
}
if (completedBy != null && isCorp)
{
sb.AppendLine($"{colorMove}{LM.Get("industryJobsRowCompletedBy"),-11}: {completedBy.name}");
}
sb.AppendLine($"{colorMark}{LM.Get("industryJobsRowStation"),-11}: {station ?? LM.Get("Unknown")}");
sb.AppendLine("```");
//sb.Append($"{LM.Get("industryJobsRowTime"),10}": {job.});
foreach (var channel in discordChannels)
{
await APIHelper.DiscordAPI.SendMessageAsync(channel, sb.ToString());
}
}
public static async Task OneSec_TQStatusPost(DateTime now)
{
if (!_IsTQOnline.HasValue)
{
_IsTQOnline = TickManager.IsConnected;
}
if (!_isTQOnlineRunning && SettingsManager.Settings.ContinousCheckModule.EnableTQStatusPost && SettingsManager.Settings.ContinousCheckModule.TQStatusPostChannels.Any() && _IsTQOnline != TickManager.IsConnected)
{
try
{
_isTQOnlineRunning = true;
if (APIHelper.DiscordAPI.IsAvailable)
{
var msg = _IsTQOnline.Value ? $"{LM.Get("autopost_tq")} {LM.Get("Offline")}" : $"{LM.Get("autopost_tq")} {LM.Get("Online")}";
var color = _IsTQOnline.Value ? new Discord.Color(0xFF0000) : new Discord.Color(0x00FF00);
foreach (var channelId in SettingsManager.Settings.ContinousCheckModule.TQStatusPostChannels)
{
try
{
var embed = new EmbedBuilder().WithTitle(msg).WithColor(color);
await APIHelper.DiscordAPI.SendMessageAsync(channelId, SettingsManager.Settings.ContinousCheckModule.TQStatusPostMention, embed.Build()).ConfigureAwait(false);
}
catch (Exception ex)
{
await LogHelper.LogEx("Autopost - TQStatus", ex, LogCat.Continuous);
}
}
_IsTQOnline = TickManager.IsConnected;
}
}
catch (Exception ex)
{
await LogHelper.LogEx("OneSec_TQStatusPost", ex, LogCat.Continuous);
}
finally
{
_isTQOnlineRunning = false;
}
}
}
private async Task WriteCorrectResponce(HttpListenerResponse response, bool isEditor, long characterId)
{
var baseCharId = Convert.ToBase64String(Encoding.UTF8.GetBytes(characterId.ToString()));
var rChar = await APIHelper.ESIAPI.GetCharacterData(Reason, characterId, true);
if (rChar == null)
{
await response.WriteContentAsync("ERROR: Probably EVE ESI is shut down at the moment. Please try again later.");
return;
}
var text = File.ReadAllText(SettingsManager.FileTemplateTimersPage).Replace("{header}", LM.Get("timersTemplateHeader"))
.Replace("{headerContent}",
WebServerModule.GetHtmlResourceDefault(true) + WebServerModule.GetHtmlResourceDatetime() + WebServerModule.GetHtmlResourceConfirmation())
.Replace("{loggedInAs}", LM.Get("loggedInAs", rChar.name))
.Replace("{charId}", baseCharId)
.Replace("{body}", await GenerateTimersHtml(isEditor, baseCharId))
.Replace("{isEditorElement}", isEditor ? null : "d-none")
.Replace("{addNewTimerHeader}", LM.Get("timersAddHeader"))
.Replace("{addNewRfTimerHeader}", LM.Get("timersAddRfHeader"))
.Replace("{timersType}", LM.Get("timersType"))
.Replace("{timersStage}", LM.Get("timersStage"))
.Replace("{timersLocation}", LM.Get("timersLocation"))
.Replace("{timersOwner}", LM.Get("timersOwner"))
.Replace("{timersET}", LM.Get("timersET"))
.Replace("{timersRfET}", LM.Get("timersRfET"))
.Replace("{timersNotes}", LM.Get("timersNotes"))
.Replace("{Add}", LM.Get("Add"))
.Replace("{Cancel}", LM.Get("Cancel"))
.Replace("{timerOffensive}", LM.Get("timerOffensive"))
.Replace("{timerDefensive}", LM.Get("timerDefensive"))
.Replace("{timerHull}", LM.Get("timerHull"))
.Replace("{timerArmor}", LM.Get("timerArmor"))
.Replace("{timerShield}", LM.Get("timerShield"))
.Replace("{timerOther}", LM.Get("timerOther"))
.Replace("{LogOutUrl}", WebServerModule.GetWebSiteUrl())
.Replace("{LogOut}", LM.Get("LogOut"))
.Replace("{timerTooltipLocation}", LM.Get("timerTooltipLocation"))
.Replace("{timerTooltipOwner}", LM.Get("timerTooltipOwner"))
.Replace("{timerTooltipET}", LM.Get("timerTooltipET"))
.Replace("{locale}", LM.Locale)
.Replace("{dateformat}", Settings.TimersModule.TimeInputFormat)
;
await WebServerModule.WriteResponce(text, response);
}
public async Task ProcessExistingCampaigns()
{
if (_isCheckRunning)
{
return;
}
try
{
_isCheckRunning = true;
if (DateTime.Now <= _nextNotificationCheck2)
{
return;
}
_nextNotificationCheck2 = DateTime.Now.AddMinutes(1);
await LogHelper.LogModule("Running NullCampaign module check...", Category);
foreach (var pair in Settings.NullCampaignModule.GetEnabledGroups())
{
foreach (var campaign in await SQLHelper.GetNullCampaigns(pair.Key))
{
var startTime = campaign.Time;
//delete outdated campaigns
if (startTime <= DateTime.UtcNow)
{
if (!pair.Value.Announces.Any())
{
await PrepareMessage(campaign, pair.Value, LM.Get("NC_LessThanMinsLeft", TimeSpan.FromMinutes(0).ToFormattedString()), 0xFF0000);
}
await SQLHelper.DeleteNullCampaign(pair.Key, campaign.campaign_id);
await LogHelper.LogInfo($"Nullsec Campaign {campaign.campaign_id} has been deleted...", Category, true, false);
continue;
}
if (pair.Value.Announces.Any())
{
var announceList = pair.Value.Announces.OrderBy(a => a).ToList();
var max = announceList.Max();
//not a notification time
var minutesLeft = (startTime - DateTime.UtcNow).TotalMinutes;
if (minutesLeft > max)
{
continue;
}
foreach (var announce in announceList.Where(a => campaign.LastAnnounce == 0 || a < campaign.LastAnnounce))
{
if (minutesLeft < announce)
{
await PrepareMessage(campaign, pair.Value, LM.Get("NC_LessThanMinsLeft", TimeSpan.FromMinutes(minutesLeft).ToFormattedString()), 0xFF0000);
//update last announce
await SQLHelper.UpdateNullCampaignAnnounce(pair.Key, campaign.campaign_id, announce);
break;
}
}
}
}
}
}
catch (Exception ex)
{
await LogHelper.LogEx(ex.Message, ex, Category);
}
finally
{
_isCheckRunning = false;
}
}
