private static async Task AuthWarningLog(JsonClasses.CharacterData ch, string message, bool isOptional = false)
{
if (!isOptional || SettingsManager.Settings.WebAuthModule.EnableDetailedLogging)
{
await LogHelper.LogWarning($"[{ch.character_id}|{ch.name}]: {message}", LogCat.AuthCheck);
}
}
public async Task UpdateData(JsonClasses.CharacterData characterData, JsonClasses.CorporationData rCorp = null, JsonClasses.AllianceData rAlliance = null, string permissions = null)
{
rCorp = rCorp ?? await APIHelper.ESIAPI.GetCorporationData(LogCat.AuthCheck.ToString(), characterData.corporation_id, true);
Data.CharacterName = characterData.name;
Data.CorporationId = characterData.corporation_id;
Data.CorporationName = rCorp?.name;
Data.CorporationTicker = rCorp?.ticker;
Data.AllianceId = characterData.alliance_id ?? 0;
if (Data.AllianceId > 0)
{
rAlliance = rAlliance ?? await APIHelper.ESIAPI.GetAllianceData(LogCat.AuthCheck.ToString(), characterData.alliance_id, true);
Data.AllianceName = rAlliance?.name;
Data.AllianceTicker = rAlliance?.ticker;
}
if (permissions != null)
{
Data.Permissions = permissions;
}
}
public async Task <bool> RefreshRadius(string reason, JsonZKill.Killmail kill)
{
if (killmailID > 0)
{
return(true);
}
try
{
killmailID = kill.killmail_id;
value = kill.zkb.totalValue;
systemId = kill.solar_system_id;
rSystem = await APIHelper.ESIAPI.GetSystemData(reason, systemId);
isUnreachableSystem = systemId == 31000005;
if (rSystem != null)
{
sysName = rSystem.name == rSystem.system_id.ToString() ? "Abyss" : (rSystem.name ?? "J");
isUnreachableSystem = rSystem.IsUnreachable();
}
else
{
sysName = "?";
}
victimCharacterID = kill.victim.character_id;
victimCorpID = kill.victim.corporation_id;
victimAllianceID = kill.victim.alliance_id;
attackers = kill.attackers;
finalBlowAttacker = attackers.FirstOrDefault(a => a.final_blow);
finalBlowAttackerCorpId = finalBlowAttacker?.corporation_id ?? 0;
finalBlowAttackerAllyId = finalBlowAttacker?.alliance_id ?? 0;
shipID = kill.victim.ship_type_id;
killTime = kill.killmail_time.ToString(SettingsManager.Settings.Config.ShortTimeFormat);
rVictimCorp = await APIHelper.ESIAPI.GetCorporationData(reason, victimCorpID);
rAttackerCorp = finalBlowAttackerCorpId > 0
? await APIHelper.ESIAPI.GetCorporationData(reason, finalBlowAttackerCorpId)
: null;
rVictimAlliance = victimAllianceID != 0 ? await APIHelper.ESIAPI.GetAllianceData(reason, victimAllianceID) : null;
rAttackerAlliance = finalBlowAttackerAllyId > 0
? await APIHelper.ESIAPI.GetAllianceData(reason, finalBlowAttackerAllyId)
: null;
rShipType = await APIHelper.ESIAPI.GetTypeId(reason, shipID);
rVictimCharacter = await APIHelper.ESIAPI.GetCharacterData(reason, victimCharacterID);
rAttackerCharacter = await APIHelper.ESIAPI.GetCharacterData(reason, finalBlowAttacker?.character_id);
systemSecurityStatus = Math.Round(rSystem.security_status, 1).ToString("0.0");
dic = new Dictionary <string, string>
{
{ "{shipID}", shipID.ToString() },
{ "{shipType}", rShipType?.name },
{ "{iskValue}", value.ToString("n0") },
{ "{systemName}", sysName },
{ "{systemSec}", systemSecurityStatus },
{ "{victimName}", rVictimCharacter?.name },
{ "{victimCorpName}", rVictimCorp?.name },
{ "{victimCorpTicker}", rVictimCorp?.ticker },
{ "{victimAllyName}", rVictimAlliance?.name },
{ "{victimAllyTicker}", rVictimAlliance == null ? null : $"<{rVictimAlliance.ticker}>" },
{ "{attackerName}", rAttackerCharacter?.name },
{ "{attackerCorpName}", rAttackerCorp?.name },
{ "{attackerCorpTicker}", rAttackerCorp?.ticker },
{ "{attackerAllyTicker}", rAttackerAlliance == null ? null : $"<{rAttackerAlliance.ticker}>" },
{ "{attackerAllyName}", rAttackerAlliance?.name },
{ "{attackersCount}", attackers?.Length.ToString() },
{ "{kmId}", killmailID.ToString() },
{ "{isNpcKill}", isNPCKill.ToString() },
{ "{timestamp}", killTime }
};
return(true);
}
catch (Exception ex)
{
killmailID = 0;
await LogHelper.LogEx("refresh ex", ex, LogCat.RadiusKill);
return(false);
}
}
public static async Task <RoleSearchResult> GetRoleGroup(JsonClasses.CharacterData characterData, ulong discordUserId, string refreshToken = null)
{
var result = new RoleSearchResult();
var discordGuild = APIHelper.DiscordAPI.GetGuild();
var u = discordGuild.GetUser(discordUserId);
try
{
if (characterData == null)
{
await AuthWarningLog(discordUserId, "[RG] Aborted due to character data is null");
result.IsConnectionError = true;
return(result);
}
if (u != null)
{
result.UpdatedRoles.Add(u.Roles.FirstOrDefault(x => x.Name == "@everyone"));
}
var groupsToCheck = new Dictionary <string, WebAuthGroup>();
var authData = await SQLHelper.GetAuthUserByCharacterId(characterData.character_id);
#region Select groups to check
if (!string.IsNullOrEmpty(authData?.GroupName))
{
await AuthInfoLog(characterData, $"[RG] Has group name {authData.GroupName}", true);
//check specified group for roles
var(groupName, group) = GetGroupByName(authData.GroupName);
if (group != null)
{
//process upgrade groups first
if (group.UpgradeGroupNames.Any())
{
await AuthInfoLog(characterData, $"[RG] Adding upgrade groups: {string.Join(',', group.UpgradeGroupNames)}", true);
foreach (var item in group.UpgradeGroupNames)
{
var(key, value) = GetGroupByName(item);
if (value != null)
{
groupsToCheck.Add(key, value);
}
}
}
//add root group
groupsToCheck.Add(groupName, group);
//add downgrade groups (checked last)
if (authData.IsAuthed && group.DowngradeGroupNames.Any())
{
await AuthInfoLog(characterData, $"[RG] Adding downgrade groups: {string.Join(',', group.DowngradeGroupNames)}", true);
foreach (var item in group.DowngradeGroupNames)
{
var(key, value) = GetGroupByName(item);
if (value != null)
{
groupsToCheck.Add(key, value);
}
}
}
}
else
{
await AuthWarningLog(characterData, "[RG] Specified group not found!", true);
}
}
else //no auth group specifies - fresh general auth
{
//check only GENERAL auth groups for roles
//non-general group auth should have group name supplied
foreach (var(key, value) in SettingsManager.Settings.WebAuthModule.AuthGroups.Where(a => !a.Value.ESICustomAuthRoles.Any() && !a.Value.BindToMainCharacter))
{
groupsToCheck.Add(key, value);
}
await AuthInfoLog(characterData, $"[RG] No group were specified, selected for search: {string.Join(',', groupsToCheck.Keys)}!", true);
}
#endregion
// string groupName = null;
//refresh token
var tq = string.IsNullOrEmpty(refreshToken) ? null : await APIHelper.ESIAPI.RefreshToken(refreshToken, SettingsManager.Settings.WebServerModule.CcpAppClientId,
SettingsManager.Settings.WebServerModule.CcpAppSecret);
var uToken = tq?.Result;
if (tq != null)
{
if (tq.Data.IsFailed)
{
if (!tq.Data.IsNotValid)
{
result.IsConnectionError = true;
await AuthWarningLog(characterData, $"[RG] {characterData.name} Connection error while fetching token!");
return(result);
}
}
}
await AuthInfoLog(characterData, $"[RG] PRE TOCHECK: {string.Join(',', groupsToCheck.Keys)} CHARID: {characterData.character_id} DID: {authData.DiscordId} AUTH: {authData.AuthState} GRP: {authData.GroupName}", true);
var foundGroup = await GetAuthGroupByCharacter(groupsToCheck, characterData);
if (foundGroup != null)
{
await AuthInfoLog(characterData, $"[RG] Group found: {foundGroup.GroupName} Roles: {string.Join(',', foundGroup.RoleEntities.SelectMany(a=> a.DiscordRoles))} Titles: {string.Join(',', foundGroup.RoleEntities.SelectMany(a=> a.Titles))}!", true);
//bad token
if (tq != null && tq.Data.IsNotValid)
{
if (foundGroup.Group.RemoveAuthIfTokenIsInvalid)
{
await AuthWarningLog(characterData, $"[RG] User {characterData.name} token is no more valid. Authentication will be declined.");
return(result);
}
if (foundGroup.Group.RemoveTokenIfTokenIsInvalid)
{
await AuthWarningLog(characterData, $"[RG] User {characterData.name} token is no more valid. Token will be omitted from auth data.");
result.TokenMustBeDeleted = true;
// return result;
}
}
await UpdateResultRolesWithTitles(discordGuild, foundGroup.RoleEntities, result, characterData, uToken);
result.ValidManualAssignmentRoles.AddRange(foundGroup.Group.ManualAssignmentRoles.Where(a => !result.ValidManualAssignmentRoles.Contains(a)));
result.GroupName = foundGroup.GroupName;
result.Group = foundGroup.Group;
}
else
{
await AuthInfoLog(characterData, $"[RG] Group not found", true);
}
return(result);
}
catch (Exception ex)
{
await LogHelper.LogError($"EXCEPTION: {ex.Message} CHARACTER: {characterData.character_id} [{characterData?.name}][{characterData?.corporation_id}]", LogCat.AuthCheck);
throw;
}
}
private static async Task UpdateResultRolesWithTitles(SocketGuild discordGuild, List <AuthRoleEntity> roleEntities, RoleSearchResult result, JsonClasses.CharacterData ch, string uToken)
{
//process titles in priority
//TODO titles and general mix?
var titleEntity = roleEntities.FirstOrDefault(a => a.Titles.Any());
if (titleEntity != null)
{
if (string.IsNullOrEmpty(uToken))
{
await AuthWarningLog(ch,
$"User has no ESI token but is being checked against group with Titles! Titles require `esi-characters.read_titles.v1` permissions!");
return;
}
var userTitles = (await APIHelper.ESIAPI.GetCharacterTitles("AuthCheck", ch.character_id, uToken))?.Select(a => a.name).ToList();
if (userTitles != null && userTitles.Any())
{
foreach (var roleTitle in titleEntity.Titles.Values)
{
if (!roleTitle.TitleNames.ContainsAnyFromList(userTitles))
{
continue;
}
foreach (var roleName in roleTitle.DiscordRoles)
{
var role = APIHelper.DiscordAPI.GetGuildRole(roleName);
if (role != null && !result.UpdatedRoles.Contains(role))
{
result.UpdatedRoles.Add(role);
}
}
}
}
else
{
var forEmpty = titleEntity.Titles.FirstOrDefault(a => a.Value.TitleNames.Count == 0 && a.Value.DiscordRoles.Any()).Value;
if (forEmpty != null)
{
foreach (var roleName in forEmpty.DiscordRoles)
{
var role = APIHelper.DiscordAPI.GetGuildRole(roleName);
if (role != null && !result.UpdatedRoles.Contains(role))
{
result.UpdatedRoles.Add(role);
}
}
}
}
}
else
{
var foundRoles = roleEntities.SelectMany(a => a.DiscordRoles).Distinct();
var aRoles = discordGuild.Roles.Where(a => foundRoles.Contains(a.Name) && !result.UpdatedRoles.Contains(a));
foreach (var role in aRoles)
{
if (!result.UpdatedRoles.Contains(role))
{
result.UpdatedRoles.Add(role);
}
}
}
}
private async Task <WCEAccessFilter> CheckAccess(long characterId, JsonClasses.CharacterData rChar)
{
var authgroups = Settings.WebConfigEditorModule.GetEnabledGroups();
if (authgroups.Count == 0 || authgroups.Values.All(a => !a.AllowedEntities.Any() && !a.AllowedDiscordRoles.Any()))
{
return(new WCEAccessFilter());
}
//check discord roles auth
foreach (var filter in authgroups.Values)
{
if (filter.AllowedDiscordRoles.Any())
{
var authUser = await SQLHelper.GetAuthUserByCharacterId(characterId);
if (authUser != null && authUser.DiscordId > 0)
{
if (APIHelper.DiscordAPI.GetUserRoleNames(authUser.DiscordId).Intersect(filter.AllowedDiscordRoles).Any())
{
return(filter);
}
}
}
}
//check for Discord admins
var discordId = SQLHelper.GetAuthUserDiscordId(characterId).GetAwaiter().GetResult();
if (discordId > 0)
{
var roles = string.Join(',', APIHelper.DiscordAPI.GetUserRoleNames(discordId));
if (!string.IsNullOrEmpty(roles))
{
var exemptRoles = Settings.Config.DiscordAdminRoles;
if (roles.Replace("&br;", "\"").Split(',').Any(role => exemptRoles.Contains(role)))
{
return(new WCEAccessFilter());
}
}
}
foreach (var accessList in Settings.WebConfigEditorModule.GetEnabledGroups())
{
var filterName = accessList.Key;
var filter = accessList.Value;
var accessChars = GetParsedCharacters(filterName) ?? new List <long>();
var accessCorps = GetParsedCorporations(filterName) ?? new List <long>();
var accessAlliance = GetParsedAlliances(filterName) ?? new List <long>();
if (!accessCorps.Contains(rChar.corporation_id) && (!rChar.alliance_id.HasValue || !(rChar.alliance_id > 0) || (!accessAlliance.Contains(
rChar.alliance_id
.Value))))
{
if (!accessChars.Contains(characterId))
{
continue;
}
}
return(filter);
}
return(null);
}
private async Task <bool[]> CheckAccess(long characterId, JsonClasses.CharacterData rChar)
{
var authgroups = Settings.TimersModule.AccessList;
var accessCorps = new List <long>();
var accessAlliance = new List <long>();
var accessChars = new List <long>();
// isEditor = false;
bool skip = false;
if (authgroups.Count == 0 || authgroups.Values.All(a => !a.FilterEntities.Any() && !a.FilterDiscordRoles.Any()))
{
skip = true;
}
else
{
var discordRoles = authgroups.Values.SelectMany(a => a.FilterDiscordRoles).Distinct().ToList();
if (discordRoles.Any())
{
var authUser = await SQLHelper.GetAuthUserByCharacterId(characterId);
if (authUser != null && authUser.DiscordId > 0 && APIHelper.IsDiscordAvailable)
{
if (APIHelper.DiscordAPI.GetUserRoleNames(authUser.DiscordId).Intersect(discordRoles).Any())
{
skip = true;
}
}
}
accessChars = ParsedAccessLists.Where(a => a.Value.ContainsKey("character")).SelectMany(a => a.Value["character"]).Distinct().Where(a => a > 0).ToList();
accessCorps = ParsedAccessLists.Where(a => a.Value.ContainsKey("corporation")).SelectMany(a => a.Value["corporation"]).Distinct().Where(a => a > 0).ToList();
accessAlliance = ParsedAccessLists.Where(a => a.Value.ContainsKey("alliance")).SelectMany(a => a.Value["alliance"]).Distinct().Where(a => a > 0).ToList();
}
authgroups = Settings.TimersModule.EditList;
var editCorps = new List <long>();
var editAlliance = new List <long>();
var editChars = new List <long>();
bool skip2 = false;
if (authgroups.Count == 0 || authgroups.Values.All(a => !a.FilterEntities.Any() && !a.FilterDiscordRoles.Any()))
{
skip2 = true;
}
else
{
var discordRoles = authgroups.Values.SelectMany(a => a.FilterDiscordRoles).Distinct().ToList();
if (discordRoles.Any())
{
var authUser = await SQLHelper.GetAuthUserByCharacterId(characterId);
if (authUser != null && authUser.DiscordId > 0)
{
if (APIHelper.DiscordAPI.GetUserRoleNames(authUser.DiscordId).Intersect(discordRoles).Any())
{
skip2 = true;
}
}
}
editChars = ParsedEditLists.Where(a => a.Value.ContainsKey("character")).SelectMany(a => a.Value["character"]).Distinct().Where(a => a > 0).ToList();
editCorps = ParsedEditLists.Where(a => a.Value.ContainsKey("corporation")).SelectMany(a => a.Value["corporation"]).Distinct().Where(a => a > 0).ToList();
editAlliance = ParsedEditLists.Where(a => a.Value.ContainsKey("alliance")).SelectMany(a => a.Value["alliance"]).Distinct().Where(a => a > 0).ToList();
}
//check for Discord admins
if (!skip2 && Settings.TimersModule.GrantEditRolesToDiscordAdmins)
{
var discordId = await SQLHelper.GetAuthUserDiscordId(characterId);
if (discordId > 0)
{
var roles = string.Join(',', APIHelper.DiscordAPI.GetUserRoleNames(discordId));
if (!string.IsNullOrEmpty(roles))
{
var exemptRoles = Settings.Config.DiscordAdminRoles;
skip2 = roles.Replace("&br;", "\"").Split(',').Any(role => exemptRoles.Contains(role));
}
}
}
if (!skip && !skip2 && !accessCorps.Contains(rChar.corporation_id) && !editCorps.Contains(rChar.corporation_id) &&
(!rChar.alliance_id.HasValue || !(rChar.alliance_id > 0) || (!accessAlliance.Contains(
rChar.alliance_id
.Value) && !editAlliance.Contains(
rChar.alliance_id.Value))))
{
if (!editChars.Contains(characterId) && !accessChars.Contains(characterId))
{
return(new[] { false, false });
}
}
var isEditor = skip2 || editCorps.Contains(rChar.corporation_id) || (rChar.alliance_id.HasValue && rChar.alliance_id.Value > 0 && editAlliance.Contains(rChar.alliance_id.Value)) ||
editChars.Contains(characterId);
return(new [] { true, isEditor });
}
private static async Task <bool> AuthGrantRoles(ulong channelId, string characterID, Dictionary <int, List <string> > foundList, JsonClasses.CharacterData characterData, JsonClasses.CorporationData corporationData, string remainder, ulong discordId)
{
var rolesToAdd = new List <SocketRole>();
var allianceID = characterData.alliance_id ?? 0;
var corpID = characterData.corporation_id;
var authSettings = TickManager.GetModule <WebAuthModule>()?.Settings.WebAuthModule;
var missedRoles = new List <string>();
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);
}
else
{
missedRoles.Add(a);
}
});
}
//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);
}
else
{
missedRoles.Add(a);
}
});
}
var discordUser = APIHelper.DiscordAPI.GetUser(discordId);
if (authSettings.AuthReportChannel != 0)
{
await APIHelper.DiscordAPI.SendMessageAsync(authSettings.AuthReportChannel, LM.Get("grantRolesMessage", characterData.name))
.ConfigureAwait(false);
}
await APIHelper.DiscordAPI.AssignRolesToUser(discordUser, rolesToAdd);
if (missedRoles.Any())
{
await LogHelper.LogWarning($"Missing discord roles: {string.Join(',', missedRoles)}");
}
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);
if (channelId != 0)
{
await APIHelper.DiscordAPI.SendMessageAsync(channelId, LM.Get("msgAuthSuccess", discordUser.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);
return(false);
}
return(true);
}
public async Task <bool> Refresh(string reason, JsonZKill.Killmail kill)
{
if (killmailID > 0)
{
return(true);
}
try
{
killmailID = kill.killmail_id;
killTime = kill.killmail_time.ToString(SettingsManager.Settings.Config.ShortTimeFormat);
victimShipID = kill.victim.ship_type_id;
value = kill.zkb.totalValue;
victimCharacterID = kill.victim.character_id;
victimCorpID = kill.victim.corporation_id;
victimAllianceID = kill.victim.alliance_id;
attackers = kill.attackers;
finalBlowAttacker = attackers.FirstOrDefault(a => a.final_blow);
finalBlowAttackerCharacterId = finalBlowAttacker.character_id;
attackerShipID = finalBlowAttacker?.ship_type_id ?? 0;
finalBlowAttackerCorpId = finalBlowAttacker?.corporation_id ?? 0;
finalBlowAttackerAllyId = finalBlowAttacker?.alliance_id ?? 0;
isNPCKill = kill.zkb.npc;
systemId = kill.solar_system_id;
rSystem = await APIHelper.ESIAPI.GetSystemData(reason, systemId);
if (rSystem == null)
{
//ESI fail - check back later
return(false);
}
rVictimCorp = await APIHelper.ESIAPI.GetCorporationData(reason, victimCorpID);
rAttackerCorp = finalBlowAttackerCorpId > 0
? await APIHelper.ESIAPI.GetCorporationData(reason, finalBlowAttackerCorpId)
: null;
rVictimAlliance = victimAllianceID != 0 ? await APIHelper.ESIAPI.GetAllianceData(reason, victimAllianceID) : null;
rAttackerAlliance = finalBlowAttackerAllyId > 0
? await APIHelper.ESIAPI.GetAllianceData(reason, finalBlowAttackerAllyId)
: null;
sysName = rSystem.name == rSystem.system_id.ToString() ? "Abyss" : rSystem.name;
var rConst = rSystem != null ? await APIHelper.ESIAPI.GetConstellationData(reason, rSystem.constellation_id) : null;
var rRegion = rConst != null ? await APIHelper.ESIAPI.GetRegionData(reason, rConst.region_id) : null;
rVictimShipType = await APIHelper.ESIAPI.GetTypeId(reason, victimShipID);
rAttackerShipType = await APIHelper.ESIAPI.GetTypeId(reason, attackerShipID);
rVictimCharacter = await APIHelper.ESIAPI.GetCharacterData(reason, victimCharacterID);
rAttackerCharacter = await APIHelper.ESIAPI.GetCharacterData(reason, finalBlowAttacker?.character_id);
systemSecurityStatus = Math.Round(rSystem.security_status, 1).ToString("0.0");
dic = new Dictionary <string, string>
{
{ "{shipID}", victimShipID.ToString() },
{ "{shipType}", rVictimShipType?.name },
{ "{attackerShipID}", attackerShipID.ToString() },
{ "{attackerShipType}", rAttackerShipType?.name },
{ "{iskValue}", value.ToString("n0") },
{ "{iskFittedValue}", kill?.zkb?.fittedValue.ToString("n0") ?? "0" },
{ "{systemName}", sysName },
{ "{constName}", rConst?.name },
{ "{regionName}", rRegion?.name },
{ "{systemSec}", systemSecurityStatus },
{ "{victimName}", rVictimCharacter?.name },
{ "{victimCorpName}", rVictimCorp?.name },
{ "{victimCorpTicker}", rVictimCorp?.ticker },
{ "{victimAllyName}", rVictimAlliance?.name },
{ "{victimAllyTicker}", rVictimAlliance == null ? null : $"<{rVictimAlliance.ticker}>" },
{ "{victimAllyOrCorpName}", rVictimAlliance?.name ?? rVictimCorp?.name },
{ "{victimAllyOrCorpTicker}", rVictimAlliance?.ticker ?? rVictimCorp?.ticker },
{ "{attackerName}", rAttackerCharacter?.name },
{ "{attackerCorpName}", rAttackerCorp?.name },
{ "{attackerCorpTicker}", rAttackerCorp?.ticker },
{ "{attackerAllyTicker}", rAttackerAlliance == null ? null : $"<{rAttackerAlliance.ticker}>" },
{ "{attackerAllyName}", rAttackerAlliance?.name },
{ "{attackerAllyOrCorpName}", rAttackerAlliance?.name ?? rAttackerCorp?.name },
{ "{attackerAllyOrCorpTicker}", rAttackerAlliance?.ticker ?? rAttackerCorp?.ticker },
{ "{attackersCount}", attackers.Length.ToString() },
{ "{kmId}", killmailID.ToString() },
{ "{timestamp}", killTime },
{ "{isLoss}", "false" },
{ "{isNpcKill}", isNPCKill.ToString() ?? "false" },
{ "{isSoloKill}", kill?.zkb?.solo.ToString() ?? "false" },
{ "{isAwoxKill}", kill?.zkb?.awox.ToString() ?? "false" },
};
return(true);
}
catch (Exception ex)
{
killmailID = 0;
await LogHelper.LogEx("refresh ex", ex, LogCat.KillFeed);
return(false);
}
}
private bool CheckAccess(int characterId, JsonClasses.CharacterData rChar, out bool isEditor)
{
var authgroups = SettingsManager.GetSubList("timersModule", "accessList");
var accessCorps = new List <int>();
var accessAlliance = new List <int>();
var accessChars = new List <int>();
isEditor = false;
bool skip = false;
if (authgroups.Count == 0 || authgroups.All(a => (a.GetChildren().ToList().FirstOrDefault(x => x.Key == "id")?.Value ?? "") == "0"))
{
skip = true;
}
else
{
foreach (var config in authgroups)
{
var configChildren = config.GetChildren().ToList();
var id = configChildren.FirstOrDefault(x => x.Key == "id")?.Value ?? "";
var isAlliance = Convert.ToBoolean(configChildren.FirstOrDefault(x => x.Key == "isAlliance")?.Value ?? "false");
var isChar = Convert.ToBoolean(configChildren.FirstOrDefault(x => x.Key == "isCharacter")?.Value ?? "false");
if (isChar)
{
accessChars.Add(Convert.ToInt32(id));
}
else
{
if (isAlliance)
{
accessAlliance.Add(Convert.ToInt32(id));
}
else
{
accessCorps.Add(Convert.ToInt32(id));
}
}
}
}
authgroups = SettingsManager.GetSubList("timersModule", "editList");
var editCorps = new List <int>();
var editAlliance = new List <int>();
var editChars = new List <int>();
bool skip2 = false;
//check for Discord admins
if (SettingsManager.GetBool("timersModule", "grantEditRolesToDiscordAdmins"))
{
var roles = SQLHelper.SQLiteDataQuery <string>("authUsers", "role", "characterID", characterId.ToString()).GetAwaiter().GetResult();
if (!string.IsNullOrEmpty(roles))
{
var exemptRoles = SettingsManager.GetSubList("config", "discordAdminRoles").Select(a => a.Value);
skip2 = roles.Replace("&br;", "\"").Split(',').Any(role => exemptRoles.Contains(role));
}
}
if (authgroups.Count == 0 || authgroups.All(a => (a.GetChildren().ToList().FirstOrDefault(x => x.Key == "id")?.Value ?? "") == "0"))
{
skip2 = true;
}
else
{
foreach (var config in authgroups)
{
var configChildren = config.GetChildren().ToList();
var id = configChildren.FirstOrDefault(x => x.Key == "id")?.Value ?? "";
var isAlliance = Convert.ToBoolean(configChildren.FirstOrDefault(x => x.Key == "isAlliance")?.Value ?? "false");
var isChar = Convert.ToBoolean(configChildren.FirstOrDefault(x => x.Key == "isCharacter")?.Value ?? "false");
if (isChar)
{
editChars.Add(Convert.ToInt32(id));
}
else
{
if (isAlliance)
{
editAlliance.Add(Convert.ToInt32(id));
}
else
{
editCorps.Add(Convert.ToInt32(id));
}
}
}
}
if (!skip && !skip2 && !accessCorps.Contains(rChar.corporation_id) && !editCorps.Contains(rChar.corporation_id) &&
(!rChar.alliance_id.HasValue || !(rChar.alliance_id > 0) || (!accessAlliance.Contains(
rChar.alliance_id
.Value) && !editAlliance.Contains(
rChar.alliance_id.Value))))
{
if (!editChars.Contains(characterId) && !accessChars.Contains(characterId))
{
//TODO access denied
return(false);
}
}
isEditor = skip2 || editCorps.Contains(rChar.corporation_id) || (rChar.alliance_id.HasValue && rChar.alliance_id.Value > 0 && editAlliance.Contains(rChar.alliance_id.Value)) ||
editChars.Contains(characterId);
return(true);
}
private bool CheckAccess(int characterId, JsonClasses.CharacterData rChar, out bool isEditor)
{
var authgroups = Settings.TimersModule.AccessList;
var accessCorps = new List <int>();
var accessAlliance = new List <int>();
var accessChars = new List <int>();
isEditor = false;
bool skip = false;
if (authgroups.Count == 0 || authgroups.All(a => a.Value.Id == 0))
{
skip = true;
}
else
{
foreach (var config in authgroups)
{
var id = config.Value.Id;
if (config.Value.IsCharacter)
{
accessChars.Add(id);
}
else
{
if (config.Value.IsAlliance)
{
accessAlliance.Add(id);
}
else
{
accessCorps.Add(id);
}
}
}
}
authgroups = Settings.TimersModule.EditList;
var editCorps = new List <int>();
var editAlliance = new List <int>();
var editChars = new List <int>();
bool skip2 = false;
//check for Discord admins
if (Settings.TimersModule.GrantEditRolesToDiscordAdmins)
{
var roles = SQLHelper.SQLiteDataQuery <string>("authUsers", "role", "characterID", characterId.ToString()).GetAwaiter().GetResult();
if (!string.IsNullOrEmpty(roles))
{
var exemptRoles = Settings.Config.DiscordAdminRoles;
skip2 = roles.Replace("&br;", "\"").Split(',').Any(role => exemptRoles.Contains(role));
}
}
if (authgroups.Count == 0 || authgroups.All(a => a.Value.Id == 0))
{
skip2 = true;
}
else
{
foreach (var config in authgroups)
{
var id = config.Value.Id;
if (config.Value.IsCharacter)
{
editChars.Add(id);
}
else
{
if (config.Value.IsAlliance)
{
editAlliance.Add(id);
}
else
{
editCorps.Add(id);
}
}
}
}
if (!skip && !skip2 && !accessCorps.Contains(rChar.corporation_id) && !editCorps.Contains(rChar.corporation_id) &&
(!rChar.alliance_id.HasValue || !(rChar.alliance_id > 0) || (!accessAlliance.Contains(
rChar.alliance_id
.Value) && !editAlliance.Contains(
rChar.alliance_id.Value))))
{
if (!editChars.Contains(characterId) && !accessChars.Contains(characterId))
{
return(false);
}
}
isEditor = skip2 || editCorps.Contains(rChar.corporation_id) || (rChar.alliance_id.HasValue && rChar.alliance_id.Value > 0 && editAlliance.Contains(rChar.alliance_id.Value)) ||
editChars.Contains(characterId);
return(true);
}
internal static async Task AuthUser(ICommandContext context, string remainder, ulong discordId)
{
JsonClasses.CharacterData characterData = null;
try
{
discordId = discordId > 0 ? discordId : context.Message.Author.Id;
//check pending user validity
var authUser = !string.IsNullOrEmpty(remainder) ? await SQLHelper.GetAuthUserByRegCode(remainder) : await SQLHelper.GetAuthUserByDiscordId(discordId);
if (authUser == null)
{
await AuthWarningLog(discordId, $"Failed to get authUser from `{remainder}` or by Discord ID");
if (context != null)
{
await APIHelper.DiscordAPI.ReplyMessageAsync(context, context.Channel, LM.Get("authHasInvalidKey", SettingsManager.Settings.Config.BotDiscordCommandPrefix), true).ConfigureAwait(false);
}
return;
}
if (authUser.IsAuthed || string.IsNullOrEmpty(authUser.RegCode))
{
await AuthWarningLog(authUser, authUser.IsAuthed? "User already authenticated" : "Specified reg code is empty");
if (context != null)
{
await APIHelper.DiscordAPI.ReplyMessageAsync(context, context.Channel, LM.Get("authHasInactiveKey", SettingsManager.Settings.Config.BotDiscordCommandPrefix), true).ConfigureAwait(false);
}
return;
}
if (authUser.Data.PermissionsList.Any())
{
var token = (await APIHelper.ESIAPI.RefreshToken(authUser.RefreshToken, SettingsManager.Settings.WebServerModule.CcpAppClientId,
SettingsManager.Settings.WebServerModule.CcpAppSecret, $"From WebAuth | Char ID: {authUser.CharacterId} | Char name: {authUser.Data.CharacterName}"))?.Result;
//delete char if token is invalid
if (string.IsNullOrEmpty(token))
{
//just reauth... if happens
await AuthWarningLog(authUser, $"Character has invalid token and will be deleted from DB.");
if (context != null)
{
await APIHelper.DiscordAPI.ReplyMessageAsync(context, context.Channel, LM.Get("authUnableToCompleteTryAgainLater"), true).ConfigureAwait(false);
}
await SQLHelper.DeleteAuthDataByCharId(authUser.CharacterId);
return;
}
}
characterData = await APIHelper.ESIAPI.GetCharacterData("Auth", authUser.CharacterId, true);
//check if we fit some group
var result = await GetRoleGroup(characterData, discordId, authUser.RefreshToken);
if (result.IsConnectionError)
{
await AuthWarningLog(authUser, $"Possible connection error while processing auth request(search for group)!");
await APIHelper.DiscordAPI.ReplyMessageAsync(context, context.Channel, LM.Get("authUnableToCompleteTryAgainLater"), true).ConfigureAwait(false);
return;
}
await AuthInfoLog(authUser, $"GRPFETCH GROUP: {result.GroupName} ROLES: {(result.UpdatedRoles == null || !result.UpdatedRoles.Any() ? "null" : string.Join(',', result.UpdatedRoles?.Select(a=> a.Name.Replace("@", "_"))))} MANUAL: {(result.UpdatedRoles == null || !result.UpdatedRoles.Any() ? "null" : string.Join(',', result.ValidManualAssignmentRoles.Select(a=> a.Replace("@", "_"))))}", true);
//var groupName = result?.GroupName;
//pass auth
if (!string.IsNullOrEmpty(result?.GroupName))
{
var group = result.Group;
var channel = context?.Channel?.Id ?? SettingsManager.Settings.WebAuthModule.AuthReportChannel;
if (characterData == null)
{
await AuthWarningLog(authUser, $"Unable to get character {authUser.CharacterId} from ESI. Aborting auth.");
if (context != null)
{
await APIHelper.DiscordAPI.ReplyMessageAsync(context, context.Channel, LM.Get("authUnableToCompleteTryAgainLater"), true).ConfigureAwait(false);
}
//await SQLHelper.DeleteAuthDataByCharId(authUser.CharacterId);
return;
}
//report to discord
var reportChannel = SettingsManager.Settings.WebAuthModule.AuthReportChannel;
if (reportChannel != 0)
{
var mention = group.DefaultMention;
if (group.PreliminaryAuthMode)
{
await APIHelper.DiscordAPI.SendMessageAsync(reportChannel, $"{mention} {LM.Get("grantRolesPrelMessage", characterData.name, result.GroupName)}")
.ConfigureAwait(false);
}
else
{
await APIHelper.DiscordAPI.SendMessageAsync(reportChannel, $"{mention} {LM.Get("grantRolesMessage", characterData.name)}")
.ConfigureAwait(false);
}
}
//remove all prevoius users associated with discordID or charID
List <long> altCharIds = null;
if (discordId > 0)
{
altCharIds = await SQLHelper.DeleteAuthDataByDiscordId(discordId);
await SQLHelper.DeleteAuthDataByCharId(authUser.CharacterId);
}
// authUser.CharacterId = authUser.CharacterId;
authUser.DiscordId = discordId > 0 ? discordId : authUser.DiscordId;
if (discordId == 0)
{
await AuthWarningLog(authUser, "Assigning 0 Discord ID to auth user?");
}
authUser.GroupName = result.GroupName;
authUser.SetStateAuthed();
authUser.RegCode = null;
await authUser.UpdateData(group.ESICustomAuthRoles.Count > 0?string.Join(',', group.ESICustomAuthRoles) : null);
await SQLHelper.SaveAuthUser(authUser);
if (altCharIds?.Any() ?? false)
{
altCharIds.ForEach(async a => await SQLHelper.UpdateMainCharacter(a, authUser.CharacterId));
}
//run roles assignment
await AuthInfoLog(authUser, $"Running roles update for {characterData.name} {(group.PreliminaryAuthMode ? $"[AUTO-AUTH from {result.GroupName}]" : $"[MANUAL-AUTH {result.GroupName}]")}");
await APIHelper.DiscordAPI.GetGuild(SettingsManager.Settings.Config.DiscordGuildId).DownloadUsersAsync();
await UpdateUserRoles(discordId, SettingsManager.Settings.WebAuthModule.ExemptDiscordRoles,
SettingsManager.Settings.WebAuthModule.AuthCheckIgnoreRoles);
//notify about success
if (channel != 0)
{
await APIHelper.DiscordAPI.SendMessageAsync(channel, LM.Get("msgAuthSuccess", await APIHelper.DiscordAPI.GetUserMention(discordId), characterData.name));
}
await AuthInfoLog(authUser, $"Character {characterData.name} has been successfully authenticated");
}
else
{
if (context != null)
{
await APIHelper.DiscordAPI.SendMessageAsync(context.Channel, "Unable to accept user as he don't fit into auth group access criteria!").ConfigureAwait(false);
}
await LogHelper.LogError($"ESI Failure or No Access - auth group name not matching user data! DiscordID: {discordId}", LogCat.AuthWeb);
}
}
private static async Task <WebAuthResult> GetAuthGroupByCharacter(Dictionary <string, WebAuthGroup> groups, JsonClasses.CharacterData chData)
{
groups = groups ?? SettingsManager.Settings.WebAuthModule.GetEnabledAuthGroups();
var result = await GetAuthRoleEntityById(groups, chData);
return(result.RoleEntities.Any() ? new WebAuthResult {
GroupName = result.GroupName, Group = result.Group, RoleEntities = result.RoleEntities
} : null);
}
private static async Task <List <AuthRoleEntity> > GetEntityForStandingsAuth(WebAuthGroup group, JsonClasses.CharacterData chData) //0 personal, 1 corp, 2 ally, 3 faction
{
var list = new List <AuthRoleEntity>();
foreach (var characterID in group.StandingsAuth.CharacterIDs)
{
var standings = await SQLHelper.LoadAuthStands(characterID);
if (standings == null)
{
continue;
}
await AuthInfoLog(chData, $"[GARE] Checking stands from {characterID}...", true);
for (var typeNumber = 0; typeNumber < 3; typeNumber++)
{
string typeName;
var id = 0L;
switch (typeNumber)
{
case 0:
typeName = "character";
id = chData.character_id;
break;
case 1:
typeName = "corporation";
id = chData.corporation_id;
break;
case 2:
typeName = "alliance";
id = chData.alliance_id ?? 0;
break;
default:
return(list);
}
var st = new List <JsonClasses.Contact>();
st.AddRange(group.StandingsAuth.UseCharacterStandings && standings.PersonalStands != null ? standings.PersonalStands : new List <JsonClasses.Contact>());
st.AddRange(group.StandingsAuth.UseCorporationStandings && standings.CorpStands != null ? standings.CorpStands : new List <JsonClasses.Contact>());
st.AddRange(group.StandingsAuth.UseAllianceStandings && standings.AllianceStands != null? standings.AllianceStands : new List <JsonClasses.Contact>());
await AuthInfoLog(chData, $"[GARE] Total stands to check {st.Count}...", true);
var stands = st.Where(a => a.contact_type == typeName && a.contact_id == id).Select(a => a.standing).Distinct();
var s = group.StandingsAuth.StandingFilters.Values.Where(a => a.Modifier == "eq").FirstOrDefault(a => a.Standings.Any(b => stands.Contains(b)));
if (s != null)
{
list.Add(new AuthRoleEntity {
Entities = new List <object> {
id
}, DiscordRoles = s.DiscordRoles
});
}
if (group.StopSearchingOnFirstMatch)
{
return(list);
}
s = group.StandingsAuth.StandingFilters.Values.Where(a => a.Modifier == "le").FirstOrDefault(a => a.Standings.Any(b => stands.Any(c => c <= b)));
if (s != null)
{
list.Add(new AuthRoleEntity {
Entities = new List <object> {
id
}, DiscordRoles = s.DiscordRoles
});
}
if (group.StopSearchingOnFirstMatch)
{
return(list);
}
s = group.StandingsAuth.StandingFilters.Values.Where(a => a.Modifier == "ge").FirstOrDefault(a => a.Standings.Any(b => stands.Any(c => c >= b)));
if (s != null)
{
list.Add(new AuthRoleEntity {
Entities = new List <object> {
id
}, DiscordRoles = s.DiscordRoles
});
}
if (group.StopSearchingOnFirstMatch)
{
return(list);
}
s = group.StandingsAuth.StandingFilters.Values.Where(a => a.Modifier == "lt").FirstOrDefault(a => a.Standings.Any(b => stands.Any(c => c < b)));
if (s != null)
{
list.Add(new AuthRoleEntity {
Entities = new List <object> {
id
}, DiscordRoles = s.DiscordRoles
});
}
if (group.StopSearchingOnFirstMatch)
{
return(list);
}
s = group.StandingsAuth.StandingFilters.Values.Where(a => a.Modifier == "gt").FirstOrDefault(a => a.Standings.Any(b => stands.Any(c => c > b)));
if (s != null)
{
list.Add(new AuthRoleEntity {
Entities = new List <object> {
id
}, DiscordRoles = s.DiscordRoles
});
}
if (group.StopSearchingOnFirstMatch)
{
return(list);
}
}
}
return(list);
}
public static async Task <WebAuthResult> GetAuthRoleEntityById(KeyValuePair <string, WebAuthGroup> group, JsonClasses.CharacterData chData)
{
var(key, value) = @group;
return(await GetAuthRoleEntityById(new Dictionary <string, WebAuthGroup> {
{ key, value }
}, chData));
}
public static async Task <WebAuthResult> GetAuthRoleEntityById(Dictionary <string, WebAuthGroup> groups, JsonClasses.CharacterData chData)
{
groups = groups ?? SettingsManager.Settings.WebAuthModule.GetEnabledAuthGroups();
var result = new WebAuthResult();
foreach (var(groupName, group) in groups)
{
if (group.StandingsAuth == null)
{
var nameList = new List <string>();
foreach (var(entityName, entity) in group.AllowedMembers)
{
//found guest
if (!entity.Entities.Any())
{
await AuthInfoLog(chData, $"[GARE] Found guest group {groupName}! Return OK.", true);
result.RoleEntities.Add(entity);
result.Group = group;
result.GroupName = groupName;
return(result);
}
await AuthInfoLog(chData, $"[GARE] Checking {groupName}|{entityName} - FSTOP: {group.StopSearchingOnFirstMatch} ...", true);
List <long> data;
lock (UpdateLock)
data = Instance.GetTier2CharacterIds(Instance.ParsedMembersLists, groupName, entityName);
if (data.Contains(chData.character_id))
{
result.RoleEntities.Add(entity);
}
else
{
lock (UpdateLock)
data = Instance.GetTier2CorporationIds(Instance.ParsedMembersLists, groupName, entityName);
if (data.Contains(chData.corporation_id))
{
result.RoleEntities.Add(entity);
}
else
{
lock (UpdateLock)
data = Instance.GetTier2AllianceIds(Instance.ParsedMembersLists, groupName, entityName);
if (chData.alliance_id.HasValue && data.Contains(chData.alliance_id.Value))
{
result.RoleEntities.Add(entity);
}
}
}
//return if we have a match and don't need to check all members
if (result.RoleEntities.Any())
{
nameList.Add(entityName);
if (group.StopSearchingOnFirstMatch)
{
await AuthInfoLog(chData, $"[GARE] Found match. Return OK.", true);
result.Group = group;
result.GroupName = groupName;
return(result);
}
else
{
await AuthInfoLog(chData, $"[GARE] Found pre-match in {groupName}|{entityName}. Continue search...", true);
}
}
}
//return after all members has been checked
if (result.RoleEntities.Any())
{
await AuthInfoLog(chData, $"[GARE] Found matches from {string.Join(',', nameList)}. Return OK.", true);
result.Group = group;
result.GroupName = groupName;
return(result);
}
}
else
{
var r = await GetEntityForStandingsAuth(group, chData);
if (r.Any())
{
await AuthInfoLog(chData, $"[GARE] Found match. Return OK.", true);
result.Group = group;
result.GroupName = groupName;
result.RoleEntities = r;
return(result);
}
}
}
return(result);
}
