Compare commits
No commits in common. "release/pre" and "2.3-prerelease8r0" have entirely different histories.
release/pr
...
2.3-prerel
1
.github/FUNDING.yml
vendored
1
.github/FUNDING.yml
vendored
@ -1 +0,0 @@
|
||||
ko_fi: raidmax
|
||||
15
.gitignore
vendored
15
.gitignore
vendored
@ -221,11 +221,10 @@ DEPLOY
|
||||
global.min.css
|
||||
global.min.js
|
||||
bootstrap-custom.min.css
|
||||
bootstrap-custom.css
|
||||
**/Master/static
|
||||
**/Master/dev_env
|
||||
/WebfrontCore/Views/Plugins/*
|
||||
/WebfrontCore/wwwroot/**/dds
|
||||
/WebfrontCore/wwwroot/images/radar/*
|
||||
|
||||
/DiscordWebhook/env
|
||||
/DiscordWebhook/config.dev.json
|
||||
@ -235,15 +234,3 @@ launchSettings.json
|
||||
/Plugins/ScriptPlugins/VpnDetectionPrivate.js
|
||||
**/Master/env_master
|
||||
/GameLogServer/log_env
|
||||
**/*.css
|
||||
/Master/master/persistence
|
||||
/WebfrontCore/wwwroot/fonts
|
||||
/WebfrontCore/wwwroot/font
|
||||
/Plugins/Tests/TestSourceFiles
|
||||
/Tests/ApplicationTests/Files/GameEvents.json
|
||||
/Tests/ApplicationTests/Files/replay.json
|
||||
/GameLogServer/game_log_server_env
|
||||
.idea/*
|
||||
*.db
|
||||
/Data/IW4MAdmin_Migration.db-shm
|
||||
/Data/IW4MAdmin_Migration.db-wal
|
||||
|
||||
@ -6,7 +6,7 @@ namespace IW4MAdmin.Application.API.GameLogServer
|
||||
[Header("User-Agent", "IW4MAdmin-RestEase")]
|
||||
public interface IGameLogServer
|
||||
{
|
||||
[Get("log/{path}/{key}")]
|
||||
Task<LogInfo> Log([Path] string path, [Path] string key);
|
||||
[Get("log/{path}")]
|
||||
Task<LogInfo> Log([Path] string path);
|
||||
}
|
||||
}
|
||||
|
||||
@ -13,7 +13,5 @@ namespace IW4MAdmin.Application.API.GameLogServer
|
||||
public int Length { get; set; }
|
||||
[JsonProperty("data")]
|
||||
public string Data { get; set; }
|
||||
[JsonProperty("next_key")]
|
||||
public string NextKey { get; set; }
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,43 +1,20 @@
|
||||
using System.Collections.Generic;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Text;
|
||||
using Newtonsoft.Json;
|
||||
using SharedLibraryCore.Helpers;
|
||||
using RestEase;
|
||||
|
||||
namespace IW4MAdmin.Application.API.Master
|
||||
{
|
||||
/// <summary>
|
||||
/// Defines the structure of the IW4MAdmin instance for the master API
|
||||
/// </summary>
|
||||
public class ApiInstance
|
||||
{
|
||||
/// <summary>
|
||||
/// Unique ID of the instance
|
||||
/// </summary>
|
||||
[JsonProperty("id")]
|
||||
public string Id { get; set; }
|
||||
|
||||
/// <summary>
|
||||
/// Indicates how long the instance has been running
|
||||
/// </summary>
|
||||
[JsonProperty("uptime")]
|
||||
public int Uptime { get; set; }
|
||||
|
||||
/// <summary>
|
||||
/// Specifies the version of the instance
|
||||
/// </summary>
|
||||
[JsonProperty("version")]
|
||||
[JsonConverter(typeof(BuildNumberJsonConverter))]
|
||||
public BuildNumber Version { get; set; }
|
||||
|
||||
/// <summary>
|
||||
/// List of servers the instance is monitoring
|
||||
/// </summary>
|
||||
public float Version { get; set; }
|
||||
[JsonProperty("servers")]
|
||||
public List<ApiServer> Servers { get; set; }
|
||||
|
||||
/// <summary>
|
||||
/// Url IW4MAdmin is listening on
|
||||
/// </summary>
|
||||
[JsonProperty("webfront_url")]
|
||||
public string WebfrontUrl { get; set; }
|
||||
}
|
||||
}
|
||||
|
||||
66
Application/API/Master/Heartbeat.cs
Normal file
66
Application/API/Master/Heartbeat.cs
Normal file
@ -0,0 +1,66 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using RestEase;
|
||||
using SharedLibraryCore;
|
||||
|
||||
namespace IW4MAdmin.Application.API.Master
|
||||
{
|
||||
public class HeartbeatState
|
||||
{
|
||||
public bool Connected { get; set; }
|
||||
public CancellationToken Token { get; set; }
|
||||
}
|
||||
|
||||
public class Heartbeat
|
||||
{
|
||||
public static async Task Send(ApplicationManager mgr, bool firstHeartbeat = false)
|
||||
{
|
||||
var api = Endpoint.Get();
|
||||
|
||||
if (firstHeartbeat)
|
||||
{
|
||||
var token = await api.Authenticate(new AuthenticationId()
|
||||
{
|
||||
Id = mgr.GetApplicationSettings().Configuration().Id
|
||||
});
|
||||
|
||||
api.AuthorizationToken = $"Bearer {token.AccessToken}";
|
||||
}
|
||||
|
||||
var instance = new ApiInstance()
|
||||
{
|
||||
Id = mgr.GetApplicationSettings().Configuration().Id,
|
||||
Uptime = (int)(DateTime.UtcNow - mgr.StartTime).TotalSeconds,
|
||||
Version = (float)Program.Version,
|
||||
Servers = mgr.Servers.Select(s =>
|
||||
new ApiServer()
|
||||
{
|
||||
ClientNum = s.ClientNum,
|
||||
Game = s.GameName.ToString(),
|
||||
Version = s.Version,
|
||||
Gametype = s.Gametype,
|
||||
Hostname = s.Hostname,
|
||||
Map = s.CurrentMap.Name,
|
||||
MaxClientNum = s.MaxClients,
|
||||
Id = s.EndPoint,
|
||||
Port = (short)s.GetPort(),
|
||||
IPAddress = s.IP
|
||||
}).ToList()
|
||||
};
|
||||
|
||||
if (firstHeartbeat)
|
||||
{
|
||||
var message = await api.AddInstance(instance);
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
var message = await api.UpdateInstance(instance.Id, instance);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,10 +1,9 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
using IW4MAdmin.Application.Plugin;
|
||||
using Newtonsoft.Json;
|
||||
using RestEase;
|
||||
using SharedLibraryCore.Helpers;
|
||||
|
||||
namespace IW4MAdmin.Application.API.Master
|
||||
{
|
||||
@ -23,12 +22,9 @@ namespace IW4MAdmin.Application.API.Master
|
||||
public class VersionInfo
|
||||
{
|
||||
[JsonProperty("current-version-stable")]
|
||||
[JsonConverter(typeof(BuildNumberJsonConverter))]
|
||||
public BuildNumber CurrentVersionStable { get; set; }
|
||||
|
||||
public float CurrentVersionStable { get; set; }
|
||||
[JsonProperty("current-version-prerelease")]
|
||||
[JsonConverter(typeof(BuildNumberJsonConverter))]
|
||||
public BuildNumber CurrentVersionPrerelease { get; set; }
|
||||
public float CurrentVersionPrerelease { get; set; }
|
||||
}
|
||||
|
||||
public class ResultMessage
|
||||
@ -37,16 +33,16 @@ namespace IW4MAdmin.Application.API.Master
|
||||
public string Message { get; set; }
|
||||
}
|
||||
|
||||
public class PluginSubscriptionContent
|
||||
public class Endpoint
|
||||
{
|
||||
public string Content { get; set; }
|
||||
public PluginType Type { get; set; }
|
||||
#if !DEBUG
|
||||
private static readonly IMasterApi api = RestClient.For<IMasterApi>("http://api.raidmax.org:5000");
|
||||
#else
|
||||
private static IMasterApi api = RestClient.For<IMasterApi>("http://127.0.0.1");
|
||||
#endif
|
||||
public static IMasterApi Get() => api;
|
||||
}
|
||||
|
||||
|
||||
/// <summary>
|
||||
/// Defines the capabilities of the master API
|
||||
/// </summary>
|
||||
[Header("User-Agent", "IW4MAdmin-RestEase")]
|
||||
public interface IMasterApi
|
||||
{
|
||||
@ -57,23 +53,18 @@ namespace IW4MAdmin.Application.API.Master
|
||||
Task<TokenId> Authenticate([Body] AuthenticationId Id);
|
||||
|
||||
[Post("instance/")]
|
||||
[AllowAnyStatusCode]
|
||||
Task<Response<ResultMessage>> AddInstance([Body] ApiInstance instance);
|
||||
Task<ResultMessage> AddInstance([Body] ApiInstance instance);
|
||||
|
||||
[Put("instance/{id}")]
|
||||
[AllowAnyStatusCode]
|
||||
Task<Response<ResultMessage>> UpdateInstance([Path] string id, [Body] ApiInstance instance);
|
||||
Task<ResultMessage> UpdateInstance([Path] string id, [Body] ApiInstance instance);
|
||||
|
||||
[Get("version/{apiVersion}")]
|
||||
Task<VersionInfo> GetVersion([Path] int apiVersion);
|
||||
[Get("version")]
|
||||
Task<VersionInfo> GetVersion();
|
||||
|
||||
[Get("localization")]
|
||||
Task<List<SharedLibraryCore.Localization.Layout>> GetLocalization();
|
||||
|
||||
[Get("localization/{languageTag}")]
|
||||
Task<SharedLibraryCore.Localization.Layout> GetLocalization([Path("languageTag")] string languageTag);
|
||||
|
||||
[Get("plugin_subscriptions")]
|
||||
Task<IEnumerable<PluginSubscriptionContent>> GetPluginSubscription([Query("instance_id")] Guid instanceId, [Query("subscription_id")] string subscription_id);
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,55 +0,0 @@
|
||||
using System;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Alerts;
|
||||
using SharedLibraryCore.Database.Models;
|
||||
|
||||
namespace IW4MAdmin.Application.Alerts;
|
||||
|
||||
public static class AlertExtensions
|
||||
{
|
||||
public static Alert.AlertState BuildAlert(this EFClient client, Alert.AlertCategory? type = null)
|
||||
{
|
||||
return new Alert.AlertState
|
||||
{
|
||||
RecipientId = client.ClientId,
|
||||
Category = type ?? Alert.AlertCategory.Information
|
||||
};
|
||||
}
|
||||
|
||||
public static Alert.AlertState WithCategory(this Alert.AlertState state, Alert.AlertCategory category)
|
||||
{
|
||||
state.Category = category;
|
||||
return state;
|
||||
}
|
||||
|
||||
public static Alert.AlertState OfType(this Alert.AlertState state, string type)
|
||||
{
|
||||
state.Type = type;
|
||||
return state;
|
||||
}
|
||||
|
||||
public static Alert.AlertState WithMessage(this Alert.AlertState state, string message)
|
||||
{
|
||||
state.Message = message;
|
||||
return state;
|
||||
}
|
||||
|
||||
public static Alert.AlertState ExpiresIn(this Alert.AlertState state, TimeSpan expiration)
|
||||
{
|
||||
state.ExpiresAt = DateTime.Now.Add(expiration);
|
||||
return state;
|
||||
}
|
||||
|
||||
public static Alert.AlertState FromSource(this Alert.AlertState state, string source)
|
||||
{
|
||||
state.Source = source;
|
||||
return state;
|
||||
}
|
||||
|
||||
public static Alert.AlertState FromClient(this Alert.AlertState state, EFClient client)
|
||||
{
|
||||
state.Source = client.Name.StripColors();
|
||||
state.SourceId = client.ClientId;
|
||||
return state;
|
||||
}
|
||||
}
|
||||
@ -1,172 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Concurrent;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using SharedLibraryCore.Alerts;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Database.Models;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Alerts;
|
||||
|
||||
public class AlertManager : IAlertManager
|
||||
{
|
||||
private readonly ApplicationConfiguration _appConfig;
|
||||
private readonly ConcurrentDictionary<int, List<Alert.AlertState>> _states = new();
|
||||
private readonly List<Func<Task<IEnumerable<Alert.AlertState>>>> _staticSources = new();
|
||||
private readonly SemaphoreSlim _onModifyingAlerts = new(1, 1);
|
||||
|
||||
public AlertManager(ApplicationConfiguration appConfig)
|
||||
{
|
||||
_appConfig = appConfig;
|
||||
_states.TryAdd(0, new List<Alert.AlertState>());
|
||||
}
|
||||
|
||||
public EventHandler<Alert.AlertState> OnAlertConsumed { get; set; }
|
||||
|
||||
public async Task Initialize()
|
||||
{
|
||||
foreach (var source in _staticSources)
|
||||
{
|
||||
var alerts = await source();
|
||||
foreach (var alert in alerts)
|
||||
{
|
||||
AddAlert(alert);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public IEnumerable<Alert.AlertState> RetrieveAlerts(EFClient client)
|
||||
{
|
||||
try
|
||||
{
|
||||
_onModifyingAlerts.Wait();
|
||||
var alerts = Enumerable.Empty<Alert.AlertState>();
|
||||
if (client.Level > Data.Models.Client.EFClient.Permission.Trusted)
|
||||
{
|
||||
alerts = alerts.Concat(_states[0].Where(alert =>
|
||||
alert.MinimumPermission is null || alert.MinimumPermission <= client.Level));
|
||||
}
|
||||
|
||||
if (_states.ContainsKey(client.ClientId))
|
||||
{
|
||||
alerts = alerts.Concat(_states[client.ClientId].AsReadOnly());
|
||||
}
|
||||
|
||||
return alerts.OrderByDescending(alert => alert.OccuredAt).ToList();
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (_onModifyingAlerts.CurrentCount == 0)
|
||||
{
|
||||
_onModifyingAlerts.Release(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void MarkAlertAsRead(Guid alertId)
|
||||
{
|
||||
try
|
||||
{
|
||||
_onModifyingAlerts.Wait();
|
||||
foreach (var items in _states.Values)
|
||||
{
|
||||
var matchingEvent = items.FirstOrDefault(item => item.AlertId == alertId);
|
||||
|
||||
if (matchingEvent is null)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
items.Remove(matchingEvent);
|
||||
OnAlertConsumed?.Invoke(this, matchingEvent);
|
||||
}
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (_onModifyingAlerts.CurrentCount == 0)
|
||||
{
|
||||
_onModifyingAlerts.Release(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void MarkAllAlertsAsRead(int recipientId)
|
||||
{
|
||||
try
|
||||
{
|
||||
_onModifyingAlerts.Wait();
|
||||
foreach (var items in _states.Values)
|
||||
{
|
||||
items.RemoveAll(item =>
|
||||
{
|
||||
if (item.RecipientId != null && item.RecipientId != recipientId)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
OnAlertConsumed?.Invoke(this, item);
|
||||
return true;
|
||||
});
|
||||
}
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (_onModifyingAlerts.CurrentCount == 0)
|
||||
{
|
||||
_onModifyingAlerts.Release(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void AddAlert(Alert.AlertState alert)
|
||||
{
|
||||
try
|
||||
{
|
||||
_onModifyingAlerts.Wait();
|
||||
if (alert.RecipientId is null)
|
||||
{
|
||||
_states[0].Add(alert);
|
||||
return;
|
||||
}
|
||||
|
||||
if (!_states.ContainsKey(alert.RecipientId.Value))
|
||||
{
|
||||
_states[alert.RecipientId.Value] = new List<Alert.AlertState>();
|
||||
}
|
||||
|
||||
if (_appConfig.MinimumAlertPermissions.ContainsKey(alert.Type))
|
||||
{
|
||||
alert.MinimumPermission = _appConfig.MinimumAlertPermissions[alert.Type];
|
||||
}
|
||||
|
||||
_states[alert.RecipientId.Value].Add(alert);
|
||||
|
||||
PruneOldAlerts();
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (_onModifyingAlerts.CurrentCount == 0)
|
||||
{
|
||||
_onModifyingAlerts.Release(1);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public void RegisterStaticAlertSource(Func<Task<IEnumerable<Alert.AlertState>>> alertSource)
|
||||
{
|
||||
_staticSources.Add(alertSource);
|
||||
}
|
||||
|
||||
|
||||
private void PruneOldAlerts()
|
||||
{
|
||||
foreach (var value in _states.Values)
|
||||
{
|
||||
value.RemoveAll(item => item.ExpiresAt < DateTime.UtcNow);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -2,15 +2,16 @@
|
||||
|
||||
<PropertyGroup>
|
||||
<OutputType>Exe</OutputType>
|
||||
<TargetFramework>net6.0</TargetFramework>
|
||||
<TargetFramework>netcoreapp2.2</TargetFramework>
|
||||
<RuntimeFrameworkVersion>2.2.2</RuntimeFrameworkVersion>
|
||||
<MvcRazorExcludeRefAssembliesFromPublish>false</MvcRazorExcludeRefAssembliesFromPublish>
|
||||
<PackageId>RaidMax.IW4MAdmin.Application</PackageId>
|
||||
<Version>2020.0.0.0</Version>
|
||||
<Version>2.2.6.5</Version>
|
||||
<Authors>RaidMax</Authors>
|
||||
<Company>Forever None</Company>
|
||||
<Product>IW4MAdmin</Product>
|
||||
<Description>IW4MAdmin is a complete server administration tool for IW4x and most Call of Duty® dedicated servers</Description>
|
||||
<Copyright>2020</Copyright>
|
||||
<Copyright>2019</Copyright>
|
||||
<PackageLicenseUrl>https://github.com/RaidMax/IW4M-Admin/blob/master/LICENSE</PackageLicenseUrl>
|
||||
<PackageProjectUrl>https://raidmax.org/IW4MAdmin</PackageProjectUrl>
|
||||
<RepositoryUrl>https://github.com/RaidMax/IW4M-Admin</RepositoryUrl>
|
||||
@ -20,69 +21,52 @@
|
||||
<Configurations>Debug;Release;Prerelease</Configurations>
|
||||
<Win32Resource />
|
||||
<RootNamespace>IW4MAdmin.Application</RootNamespace>
|
||||
<PublishWithAspNetCoreTargetManifest>false</PublishWithAspNetCoreTargetManifest>
|
||||
</PropertyGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<PackageReference Include="Jint" Version="3.0.0-beta-2049" />
|
||||
<PackageReference Include="MaxMind.GeoIP2" Version="5.1.0" />
|
||||
<PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="6.0.8">
|
||||
<PrivateAssets>all</PrivateAssets>
|
||||
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
|
||||
</PackageReference>
|
||||
<PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="6.0.0" />
|
||||
<PackageReference Include="RestEase" Version="1.5.7" />
|
||||
<PackageReference Include="System.CommandLine" Version="2.0.0-beta4.22272.1" />
|
||||
<PackageReference Include="System.CommandLine.DragonFruit" Version="0.4.0-alpha.22272.1" />
|
||||
<PackageReference Include="System.Text.Encoding.CodePages" Version="6.0.0" />
|
||||
<PackageReference Include="RestEase" Version="1.4.7" />
|
||||
<PackageReference Include="System.Text.Encoding.CodePages" Version="4.5.1" />
|
||||
</ItemGroup>
|
||||
|
||||
<PropertyGroup>
|
||||
<ServerGarbageCollection>true</ServerGarbageCollection>
|
||||
<ConcurrentGarbageCollection>true</ConcurrentGarbageCollection>
|
||||
<TieredCompilation>true</TieredCompilation>
|
||||
<LangVersion>Latest</LangVersion>
|
||||
</PropertyGroup>
|
||||
|
||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Prerelease|AnyCPU'">
|
||||
<ErrorReport>none</ErrorReport>
|
||||
<DebugType>full</DebugType>
|
||||
<DebugSymbols>true</DebugSymbols>
|
||||
<AssemblyVersion>2.2.6.5</AssemblyVersion>
|
||||
<FileVersion>2.2.6.5</FileVersion>
|
||||
</PropertyGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<ProjectReference Include="..\Integrations\Cod\Integrations.Cod.csproj" />
|
||||
<ProjectReference Include="..\Integrations\Source\Integrations.Source.csproj" />
|
||||
<ProjectReference Include="..\SharedLibraryCore\SharedLibraryCore.csproj">
|
||||
<Private>true</Private>
|
||||
</ProjectReference>
|
||||
<ProjectReference Include="..\WebfrontCore\WebfrontCore.csproj" />
|
||||
<ProjectReference Include="..\WebfrontCore\WebfrontCore.csproj">
|
||||
<Private>true</Private>
|
||||
<CopyLocalSatelliteAssemblies>true</CopyLocalSatelliteAssemblies>
|
||||
</ProjectReference>
|
||||
</ItemGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<None Update="DefaultSettings.json">
|
||||
<CopyToOutputDirectory>Always</CopyToOutputDirectory>
|
||||
</None>
|
||||
<None Update="Configuration\LoggingConfiguration.json">
|
||||
<CopyToOutputDirectory>Always</CopyToOutputDirectory>
|
||||
</None>
|
||||
<None Update="Resources\GeoLite2-Country.mmdb">
|
||||
<CopyToOutputDirectory>Always</CopyToOutputDirectory>
|
||||
</None>
|
||||
</ItemGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<PackageReference Update="Microsoft.NETCore.App" Version="2.2.2" />
|
||||
</ItemGroup>
|
||||
|
||||
<Target Name="PreBuild" BeforeTargets="PreBuildEvent">
|
||||
<Exec Command="if $(ConfigurationName) == Debug call $(ProjectDir)BuildScripts\PreBuild.bat $(ProjectDir)..\ $(ProjectDir) $(TargetDir) $(OutDir)" />
|
||||
<Exec Command="call $(ProjectDir)BuildScripts\PreBuild.bat $(ProjectDir)..\ $(ProjectDir) $(TargetDir) $(OutDir)" />
|
||||
</Target>
|
||||
|
||||
<Target Name="PostBuild" AfterTargets="PostBuildEvent">
|
||||
<GetAssemblyIdentity AssemblyFiles="$(TargetPath)">
|
||||
<Output TaskParameter="Assemblies" ItemName="CurrentAssembly" />
|
||||
</GetAssemblyIdentity>
|
||||
<Exec Command="if $(ConfigurationName) == Debug call $(ProjectDir)BuildScripts\PostBuild.bat $(ProjectDir)..\ $(ProjectDir) $(TargetDir) $(OutDir) %25(CurrentAssembly.Version)" />
|
||||
<Exec Command="call $(ProjectDir)BuildScripts\PostBuild.bat $(ProjectDir)..\ $(ProjectDir) $(TargetDir) $(OutDir) %(CurrentAssembly.Version)" />
|
||||
</Target>
|
||||
|
||||
<Target Name="PostPublish" AfterTargets="Publish">
|
||||
<Exec Command="if $(ConfigurationName) == Debug call $(ProjectDir)BuildScripts\PostPublish.bat $(ProjectDir)..\ $(ProjectDir) $(TargetDir) $(ConfigurationName)" />
|
||||
<Exec Command="call $(ProjectDir)BuildScripts\PostPublish.bat $(ProjectDir)..\ $(ProjectDir) $(TargetDir) $(ConfigurationName)" />
|
||||
</Target>
|
||||
</Project>
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,12 +0,0 @@
|
||||
param (
|
||||
[string]$OutputDir = $(throw "-OutputDir is required.")
|
||||
)
|
||||
|
||||
$localizations = @("en-US", "ru-RU", "es-EC", "pt-BR", "de-DE")
|
||||
foreach($localization in $localizations)
|
||||
{
|
||||
$url = "http://api.raidmax.org:5000/localization/{0}" -f $localization
|
||||
$filePath = "{0}Localization\IW4MAdmin.{1}.json" -f $OutputDir, $localization
|
||||
$response = Invoke-WebRequest $url -UseBasicParsing
|
||||
Out-File -FilePath $filePath -InputObject $response.Content -Encoding utf8
|
||||
}
|
||||
@ -4,9 +4,11 @@ set TargetDir=%3
|
||||
set OutDir=%4
|
||||
set Version=%5
|
||||
|
||||
echo %Version% > "%SolutionDir%DEPLOY\version.txt"
|
||||
|
||||
echo Copying dependency configs
|
||||
copy "%SolutionDir%WebfrontCore\%OutDir%*.deps.json" "%TargetDir%"
|
||||
copy "%SolutionDir%SharedLibraryCore\%OutDir%*.deps.json" "%TargetDir%"
|
||||
copy "%SolutionDir%SharedLibaryCore\%OutDir%*.deps.json" "%TargetDir%"
|
||||
|
||||
if not exist "%TargetDir%Plugins" (
|
||||
echo "Making plugin dir"
|
||||
@ -14,4 +16,19 @@ if not exist "%TargetDir%Plugins" (
|
||||
)
|
||||
|
||||
xcopy /y "%SolutionDir%Build\Plugins" "%TargetDir%Plugins\"
|
||||
del "%TargetDir%Plugins\SQLite*"
|
||||
|
||||
echo Copying plugins for publish
|
||||
del %SolutionDir%BUILD\Plugins\Tests.dll
|
||||
xcopy /Y "%SolutionDir%BUILD\Plugins" "%SolutionDir%Publish\Windows\Plugins\"
|
||||
xcopy /Y "%SolutionDir%BUILD\Plugins" "%SolutionDir%Publish\WindowsPrerelease\Plugins\"
|
||||
|
||||
echo Copying script plugins for publish
|
||||
xcopy /Y "%SolutionDir%Plugins\ScriptPlugins" "%SolutionDir%Publish\Windows\Plugins\"
|
||||
xcopy /Y "%SolutionDir%Plugins\ScriptPlugins" "%SolutionDir%Publish\WindowsPrerelease\Plugins\"
|
||||
|
||||
echo Copying GSC files for publish
|
||||
xcopy /Y "%SolutionDir%_customcallbacks.gsc" "%SolutionDir%Publish\Windows\userraw\scripts\"
|
||||
xcopy /Y "%SolutionDir%_customcallbacks.gsc" "%SolutionDir%Publish\WindowsPrerelease\userraw\scripts\"
|
||||
|
||||
xcopy /Y "%SolutionDir%_commands.gsc" "%SolutionDir%Publish\Windows\userraw\scripts\"
|
||||
xcopy /Y "%SolutionDir%_commands.gsc" "%SolutionDir%Publish\WindowsPrerelease\userraw\scripts\"
|
||||
@ -1,67 +1,115 @@
|
||||
set PublishDir=%1
|
||||
set SourceDir=%2
|
||||
set SolutionDir=%1
|
||||
set ProjectDir=%2
|
||||
set TargetDir=%3
|
||||
set CurrentConfiguration=%4
|
||||
SET COPYCMD=/Y
|
||||
|
||||
echo deleting extra runtime files
|
||||
if exist "%PublishDir%\runtimes\linux-arm" powershell Remove-Item -Force -Recurse '%PublishDir%\runtimes\linux-arm'
|
||||
if exist "%PublishDir%\runtimes\linux-arm64" powershell Remove-Item -Force -Recurse '%PublishDir%\runtimes\linux-arm64'
|
||||
if exist "%PublishDir%\runtimes\linux-armel" powershell Remove-Item -Force -Recurse '%PublishDir%\runtimes\linux-armel'
|
||||
if exist "%PublishDir%\runtimes\osx" powershell Remove-Item -Force -Recurse '%PublishDir%\runtimes\osx'
|
||||
if exist "%PublishDir%\runtimes\osx-x64" powershell Remove-Item -Force -Recurse '%PublishDir%\runtimes\osx-x64'
|
||||
if exist "%PublishDir%\runtimes\win-arm" powershell Remove-Item -Force -Recurse '%PublishDir%\runtimes\win-arm'
|
||||
if exist "%PublishDir%\runtimes\win-arm64" powershell Remove-Item -Force -Recurse '%PublishDir%\runtimes\win-arm64'
|
||||
if exist "%PublishDir%\runtimes\alpine-x64" powershell Remove-Item -Force -Recurse '%PublishDir%\runtimes\alpine-x64'
|
||||
if exist "%PublishDir%\runtimes\linux-musl-x64" powershell Remove-Item -Force -Recurse '%PublishDir%\runtimes\linux-musl-x64'
|
||||
echo Deleting extra language files
|
||||
|
||||
echo deleting misc files
|
||||
if exist "%PublishDir%\web.config" del "%PublishDir%\web.config"
|
||||
if exist "%PublishDir%\libman.json" del "%PublishDir%\libman.json"
|
||||
del "%PublishDir%\*.exe"
|
||||
del "%PublishDir%\*.pdb"
|
||||
if exist "%SolutionDir%Publish\Windows\en-US\" powershell Remove-Item -Force -Recurse '%SolutionDir%Publish\Windows\en-US'
|
||||
if exist "%SolutionDir%Publish\Windows\de\" powershell Remove-Item -Force -Recurse '%SolutionDir%Publish\Windows\de'
|
||||
if exist "%SolutionDir%Publish\Windows\es\" powershell Remove-Item -Force -Recurse '%SolutionDir%Publish\Windows\es'
|
||||
if exist "%SolutionDir%Publish\Windows\fr\" powershell Remove-Item -Force -Recurse '%SolutionDir%Publish\Windows\fr'
|
||||
if exist "%SolutionDir%Publish\Windows\it\" powershell Remove-Item -Force -Recurse '%SolutionDir%Publish\Windows\it'
|
||||
if exist "%SolutionDir%Publish\Windows\ja\" powershell Remove-Item -Force -Recurse '%SolutionDir%Publish\Windows\ja'
|
||||
if exist "%SolutionDir%Publish\Windows\ko\" powershell Remove-Item -Force -Recurse '%SolutionDir%Publish\Windows\ko'
|
||||
if exist "%SolutionDir%Publish\Windows\ru\" powershell Remove-Item -Force -Recurse '%SolutionDir%Publish\Windows\ru'
|
||||
if exist "%SolutionDir%Publish\Windows\zh-Hans\" powershell Remove-Item -Force -Recurse '%SolutionDir%Publish\Windows\zh-Hans'
|
||||
if exist "%SolutionDir%Publish\Windows\zh-Hant\" powershell Remove-Item -Force -Recurse '%SolutionDir%Publish\Windows\zh-Hant'
|
||||
|
||||
echo setting up default folders
|
||||
if not exist "%PublishDir%\Configuration" md "%PublishDir%\Configuration"
|
||||
move "%PublishDir%\DefaultSettings.json" "%PublishDir%\Configuration\"
|
||||
if not exist "%PublishDir%\Lib\" md "%PublishDir%\Lib\"
|
||||
del "%PublishDir%\Microsoft.CodeAnalysis*.dll" /F /Q
|
||||
move "%PublishDir%\*.dll" "%PublishDir%\Lib\"
|
||||
move "%PublishDir%\*.json" "%PublishDir%\Lib\"
|
||||
move "%PublishDir%\runtimes" "%PublishDir%\Lib\runtimes"
|
||||
move "%PublishDir%\ru" "%PublishDir%\Lib\ru"
|
||||
move "%PublishDir%\de" "%PublishDir%\Lib\de"
|
||||
move "%PublishDir%\pt" "%PublishDir%\Lib\pt"
|
||||
move "%PublishDir%\es" "%PublishDir%\Lib\es"
|
||||
rmdir /Q /S "%PublishDir%\cs"
|
||||
rmdir /Q /S "%PublishDir%\fr"
|
||||
rmdir /Q /S "%PublishDir%\it"
|
||||
rmdir /Q /S "%PublishDir%\ja"
|
||||
rmdir /Q /S "%PublishDir%\ko"
|
||||
rmdir /Q /S "%PublishDir%\pl"
|
||||
rmdir /Q /S "%PublishDir%\pt-BR"
|
||||
rmdir /Q /S "%PublishDir%\tr"
|
||||
rmdir /Q /S "%PublishDir%\zh-Hans"
|
||||
rmdir /Q /S "%PublishDir%\zh-Hant"
|
||||
if exist "%PublishDir%\refs" move "%PublishDir%\refs" "%PublishDir%\Lib\refs"
|
||||
if exist "%SolutionDir%Publish\WindowsPrerelease\en-US\" powershell Remove-Item -Force -Recurse '%SolutionDir%Publish\WindowsPrerelease\en-US'
|
||||
if exist "%SolutionDir%Publish\WindowsPrerelease\de\" powershell Remove-Item -Force -Recurse '%SolutionDir%Publish\WindowsPrerelease\de'
|
||||
if exist "%SolutionDir%Publish\WindowsPrerelease\es\" powershell Remove-Item -Force -Recurse '%SolutionDir%Publish\WindowsPrerelease\es'
|
||||
if exist "%SolutionDir%Publish\WindowsPrerelease\fr\" powershell Remove-Item -Force -Recurse '%SolutionDir%Publish\WindowsPrerelease\fr'
|
||||
if exist "%SolutionDir%Publish\WindowsPrerelease\it\" powershell Remove-Item -Force -Recurse '%SolutionDir%Publish\WindowsPrerelease\it'
|
||||
if exist "%SolutionDir%Publish\WindowsPrerelease\ja\" powershell Remove-Item -Force -Recurse '%SolutionDir%Publish\WindowsPrerelease\ja'
|
||||
if exist "%SolutionDir%Publish\WindowsPrerelease\ko\" powershell Remove-Item -Force -Recurse '%SolutionDir%Publish\WindowsPrerelease\ko'
|
||||
if exist "%SolutionDir%Publish\WindowsPrerelease\ru\" powershell Remove-Item -Force -Recurse '%SolutionDir%Publish\WindowsPrerelease\ru'
|
||||
if exist "%SolutionDir%Publish\WindowsPrerelease\zh-Hans\" powershell Remove-Item -Force -Recurse '%SolutionDir%Publish\WindowsPrerelease\zh-Hans'
|
||||
if exist "%SolutionDir%Publish\WindowsPrerelease\zh-Hant\" powershell Remove-Item -Force -Recurse '%SolutionDir%Publish\WindowsPrerelease\zh-Hant'
|
||||
|
||||
echo Deleting extra runtime files
|
||||
if exist "%SolutionDir%Publish\Windows\runtimes\linux-arm" powershell Remove-Item -Force -Recurse '%SolutionDir%Publish\Windows\runtimes\linux-arm'
|
||||
if exist "%SolutionDir%Publish\Windows\runtimes\linux-arm64" powershell Remove-Item -Force -Recurse '%SolutionDir%Publish\Windows\runtimes\linux-arm64'
|
||||
if exist "%SolutionDir%Publish\Windows\runtimes\linux-armel" powershell Remove-Item -Force -Recurse '%SolutionDir%Publish\Windows\runtimes\linux-armel'
|
||||
|
||||
if exist "%SolutionDir%Publish\Windows\runtimes\osx" powershell Remove-Item -Force -Recurse '%SolutionDir%Publish\Windows\runtimes\osx'
|
||||
if exist "%SolutionDir%Publish\Windows\runtimes\osx-x64" powershell Remove-Item -Force -Recurse '%SolutionDir%Publish\Windows\runtimes\osx-x64'
|
||||
|
||||
if exist "%SolutionDir%Publish\Windows\runtimes\win-arm" powershell Remove-Item -Force -Recurse '%SolutionDir%Publish\Windows\runtimes\win-arm'
|
||||
if exist "%SolutionDir%Publish\Windows\runtimes\win-arm64" powershell Remove-Item -Force -Recurse '%SolutionDir%Publish\Windows\runtimes\win-arm64'
|
||||
|
||||
if exist "%SolutionDir%Publish\WindowsPrerelease\runtimes\linux-arm" powershell Remove-Item -Force -Recurse '%SolutionDir%Publish\WindowsPrerelease\runtimes\linux-arm'
|
||||
if exist "%SolutionDir%Publish\WindowsPrerelease\runtimes\linux-arm64" powershell Remove-Item -Force -Recurse '%SolutionDir%Publish\WindowsPrerelease\runtimes\linux-arm64'
|
||||
if exist "%SolutionDir%Publish\WindowsPrerelease\runtimes\linux-armel" powershell Remove-Item -Force -Recurse '%SolutionDir%Publish\WindowsPrerelease\runtimes\linux-armel'
|
||||
|
||||
if exist "%SolutionDir%Publish\WindowsPrerelease\runtimes\osx" powershell Remove-Item -Force -Recurse '%SolutionDir%Publish\WindowsPrerelease\runtimes\osx'
|
||||
if exist "%SolutionDir%Publish\WindowsPrerelease\runtimes\osx-x64" powershell Remove-Item -Force -Recurse '%SolutionDir%Publish\WindowsPrerelease\runtimes\osx-x64'
|
||||
|
||||
if exist "%SolutionDir%Publish\WindowsPrerelease\runtimes\win-arm" powershell Remove-Item -Force -Recurse '%SolutionDir%Publish\WindowsPrerelease\runtimes\win-arm'
|
||||
if exist "%SolutionDir%Publish\WindowsPrerelease\runtimes\win-arm64" powershell Remove-Item -Force -Recurse '%SolutionDir%Publish\WindowsPrerelease\runtimes\win-arm64'
|
||||
|
||||
echo Deleting misc files
|
||||
if exist "%SolutionDir%Publish\Windows\web.config" del "%SolutionDir%Publish\Windows\web.config"
|
||||
del "%SolutionDir%Publish\Windows\*pdb"
|
||||
|
||||
if exist "%SolutionDir%Publish\WindowsPrerelease\web.config" del "%SolutionDir%Publish\WindowsPrerelease\web.config"
|
||||
del "%SolutionDir%Publish\WindowsPrerelease\*pdb"
|
||||
|
||||
echo setting up library folders
|
||||
|
||||
if "%CurrentConfiguration%" == "Prerelease" (
|
||||
echo PR-Config
|
||||
if not exist "%SolutionDir%Publish\WindowsPrerelease\Configuration" md "%SolutionDir%Publish\WindowsPrerelease\Configuration"
|
||||
move "%SolutionDir%Publish\WindowsPrerelease\DefaultSettings.json" "%SolutionDir%Publish\WindowsPrerelease\Configuration\"
|
||||
)
|
||||
|
||||
if "%CurrentConfiguration%" == "Release" (
|
||||
echo R-Config
|
||||
if not exist "%SolutionDir%Publish\Windows\Configuration" md "%SolutionDir%Publish\Windows\Configuration"
|
||||
if exist "%SolutionDir%Publish\Windows\DefaultSettings.json" move "%SolutionDir%Publish\Windows\DefaultSettings.json" "%SolutionDir%Publish\Windows\Configuration\DefaultSettings.json"
|
||||
)
|
||||
|
||||
if "%CurrentConfiguration%" == "Prerelease" (
|
||||
echo PR-LIB
|
||||
if not exist "%SolutionDir%Publish\WindowsPrerelease\Lib\" md "%SolutionDir%Publish\WindowsPrerelease\Lib\"
|
||||
move "%SolutionDir%Publish\WindowsPrerelease\*.dll" "%SolutionDir%Publish\WindowsPrerelease\Lib\"
|
||||
move "%SolutionDir%Publish\WindowsPrerelease\*.json" "%SolutionDir%Publish\WindowsPrerelease\Lib\"
|
||||
)
|
||||
|
||||
if "%CurrentConfiguration%" == "Release" (
|
||||
echo R-LIB
|
||||
if not exist "%SolutionDir%Publish\Windows\Lib\" md "%SolutionDir%Publish\Windows\Lib\"
|
||||
move "%SolutionDir%Publish\Windows\*.dll" "%SolutionDir%Publish\Windows\Lib\"
|
||||
move "%SolutionDir%Publish\Windows\*.json" "%SolutionDir%Publish\Windows\Lib\"
|
||||
)
|
||||
|
||||
if "%CurrentConfiguration%" == "Prerelease" (
|
||||
echo PR-RT
|
||||
move "%SolutionDir%Publish\WindowsPrerelease\runtimes" "%SolutionDir%Publish\WindowsPrerelease\Lib\runtimes"
|
||||
if exist "%SolutionDir%Publish\WindowsPrerelease\refs" move "%SolutionDir%Publish\WindowsPrerelease\refs" "%SolutionDir%Publish\WindowsPrerelease\Lib\refs"
|
||||
)
|
||||
|
||||
|
||||
if "%CurrentConfiguration%" == "Release" (
|
||||
echo R-RT
|
||||
move "%SolutionDir%Publish\Windows\runtimes" "%SolutionDir%Publish\Windows\Lib\runtimes"
|
||||
if exist "%SolutionDir%Publish\Windows\refs" move "%SolutionDir%Publish\Windows\refs" "%SolutionDir%Publish\Windows\Lib\refs"
|
||||
)
|
||||
|
||||
if "%CurrentConfiguration%" == "Prerelease" (
|
||||
echo PR-LOC
|
||||
if not exist "%SolutionDir%Publish\WindowsPrerelease\Localization" md "%SolutionDir%Publish\WindowsPrerelease\Localization"
|
||||
)
|
||||
|
||||
if "%CurrentConfiguration%" == "Release" (
|
||||
echo R-LOC
|
||||
if not exist "%SolutionDir%Publish\Windows\Localization" md "%SolutionDir%Publish\Windows\Localization"
|
||||
)
|
||||
|
||||
echo making start scripts
|
||||
@(echo @echo off && echo @title IW4MAdmin && echo set DOTNET_CLI_TELEMETRY_OPTOUT=1 && echo dotnet Lib\IW4MAdmin.dll && echo pause) > "%PublishDir%\StartIW4MAdmin.cmd"
|
||||
@(echo #!/bin/bash&& echo export DOTNET_CLI_TELEMETRY_OPTOUT=1&& echo dotnet Lib/IW4MAdmin.dll) > "%PublishDir%\StartIW4MAdmin.sh"
|
||||
@(echo @echo off && echo @title IW4MAdmin && echo dotnet Lib\IW4MAdmin.dll && echo pause) > "%SolutionDir%Publish\WindowsPrerelease\StartIW4MAdmin.cmd"
|
||||
@(echo @echo off && echo @title IW4MAdmin && echo dotnet Lib\IW4MAdmin.dll && echo pause) > "%SolutionDir%Publish\Windows\StartIW4MAdmin.cmd"
|
||||
|
||||
echo copying update scripts
|
||||
copy "%SourceDir%\DeploymentFiles\UpdateIW4MAdmin.ps1" "%PublishDir%\UpdateIW4MAdmin.ps1"
|
||||
copy "%SourceDir%\DeploymentFiles\UpdateIW4MAdmin.sh" "%PublishDir%\UpdateIW4MAdmin.sh"
|
||||
|
||||
echo moving front-end library dependencies
|
||||
if not exist "%PublishDir%\wwwroot\font" mkdir "%PublishDir%\wwwroot\font"
|
||||
move "WebfrontCore\wwwroot\lib\open-iconic\font\fonts\*.*" "%PublishDir%\wwwroot\font\"
|
||||
if exist "%PublishDir%\wwwroot\lib" rd /s /q "%PublishDir%\wwwroot\lib"
|
||||
if not exist "%PublishDir%\wwwroot\css" mkdir "%PublishDir%\wwwroot\css"
|
||||
move "WebfrontCore\wwwroot\css\global.min.css" "%PublishDir%\wwwroot\css\global.min.css"
|
||||
if not exist "%PublishDir%\wwwroot\js" mkdir "%PublishDir%\wwwroot\js"
|
||||
move "%SourceDir%\WebfrontCore\wwwroot\js\global.min.js" "%PublishDir%\wwwroot\js\global.min.js"
|
||||
if not exist "%PublishDir%\wwwroot\images" mkdir "%PublishDir%\wwwroot\images"
|
||||
xcopy "%SourceDir%\WebfrontCore\wwwroot\images" "%PublishDir%\wwwroot\images" /E /H /C /I
|
||||
|
||||
|
||||
echo setting permissions...
|
||||
cacls "%PublishDir%" /t /e /p Everyone:F
|
||||
@(echo #!/bin/bash && echo dotnet Lib/IW4MAdmin.dll) > "%SolutionDir%Publish\WindowsPrerelease\StartIW4MAdmin.sh"
|
||||
@(echo #!/bin/bash && echo dotnet Lib/IW4MAdmin.dll) > "%SolutionDir%Publish\Windows\StartIW4MAdmin.sh"
|
||||
|
||||
@ -1,6 +1,3 @@
|
||||
set SolutionDir=%1
|
||||
set ProjectDir=%2
|
||||
set TargetDir=%3
|
||||
|
||||
echo D | xcopy "%SolutionDir%Plugins\ScriptPlugins\*.js" "%TargetDir%Plugins" /y
|
||||
powershell -File "%ProjectDir%BuildScripts\DownloadTranslations.ps1" %TargetDir%
|
||||
@ -1,52 +0,0 @@
|
||||
using System;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Models.Client;
|
||||
using IW4MAdmin.Application.Meta;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Commands;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Dtos.Meta.Responses;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Commands;
|
||||
|
||||
public class AddClientNoteCommand : Command
|
||||
{
|
||||
private readonly IMetaServiceV2 _metaService;
|
||||
|
||||
public AddClientNoteCommand(CommandConfiguration config, ITranslationLookup layout, IMetaServiceV2 metaService) : base(config, layout)
|
||||
{
|
||||
Name = "addnote";
|
||||
Description = _translationLookup["COMMANDS_ADD_CLIENT_NOTE_DESCRIPTION"];
|
||||
Alias = "an";
|
||||
Permission = EFClient.Permission.Moderator;
|
||||
RequiresTarget = true;
|
||||
Arguments = new[]
|
||||
{
|
||||
new CommandArgument
|
||||
{
|
||||
Name = _translationLookup["COMMANDS_ARGS_PLAYER"],
|
||||
Required = true
|
||||
},
|
||||
new CommandArgument
|
||||
{
|
||||
Name = _translationLookup["COMMANDS_ARGS_NOTE"],
|
||||
Required = false
|
||||
}
|
||||
};
|
||||
|
||||
_metaService = metaService;
|
||||
}
|
||||
|
||||
public override async Task ExecuteAsync(GameEvent gameEvent)
|
||||
{
|
||||
var note = new ClientNoteMetaResponse
|
||||
{
|
||||
Note = gameEvent.Data?.Trim(),
|
||||
OriginEntityId = gameEvent.Origin.ClientId,
|
||||
ModifiedDate = DateTime.UtcNow
|
||||
};
|
||||
await _metaService.SetPersistentMetaValue("ClientNotes", note, gameEvent.Target.ClientId);
|
||||
gameEvent.Origin.Tell(_translationLookup["COMMANDS_ADD_CLIENT_NOTE_SUCCESS"]);
|
||||
}
|
||||
}
|
||||
@ -1,64 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Models;
|
||||
using Data.Models.Client;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Commands;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Commands.ClientTags
|
||||
{
|
||||
public class AddClientTagCommand : Command
|
||||
{
|
||||
private readonly IMetaServiceV2 _metaService;
|
||||
|
||||
public AddClientTagCommand(ILogger<AddClientTagCommand> commandLogger, CommandConfiguration config,
|
||||
ITranslationLookup layout, IMetaServiceV2 metaService) :
|
||||
base(config, layout)
|
||||
{
|
||||
Name = "addclienttag";
|
||||
Description = layout["COMMANDS_ADD_CLIENT_TAG_DESC"];
|
||||
Alias = "act";
|
||||
Permission = EFClient.Permission.Owner;
|
||||
RequiresTarget = false;
|
||||
Arguments = new[]
|
||||
{
|
||||
new CommandArgument
|
||||
{
|
||||
Name = _translationLookup["COMMANDS_ARGUMENT_TAG"],
|
||||
Required = true
|
||||
}
|
||||
};
|
||||
|
||||
_metaService = metaService;
|
||||
logger = commandLogger;
|
||||
}
|
||||
|
||||
public override async Task ExecuteAsync(GameEvent gameEvent)
|
||||
{
|
||||
var existingTags = await _metaService.GetPersistentMetaValue<List<TagMeta>>(EFMeta.ClientTagNameV2) ??
|
||||
new List<TagMeta>();
|
||||
|
||||
var tagName = gameEvent.Data.Trim();
|
||||
|
||||
if (existingTags.Any(tag => tag.TagName == tagName))
|
||||
{
|
||||
logger.LogWarning("Tag with name {TagName} already exists", tagName);
|
||||
return;
|
||||
}
|
||||
|
||||
existingTags.Add(new TagMeta
|
||||
{
|
||||
Id = (existingTags.LastOrDefault()?.TagId ?? 0) + 1,
|
||||
Value = tagName
|
||||
});
|
||||
|
||||
await _metaService.SetPersistentMetaValue(EFMeta.ClientTagNameV2, existingTags,
|
||||
gameEvent.Owner.Manager.CancellationToken);
|
||||
gameEvent.Origin.Tell(_translationLookup["COMMANDS_ADD_CLIENT_TAG_SUCCESS"].FormatExt(gameEvent.Data));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,38 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Models;
|
||||
using Data.Models.Client;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Commands.ClientTags
|
||||
{
|
||||
public class ListClientTags : Command
|
||||
{
|
||||
private readonly IMetaServiceV2 _metaService;
|
||||
|
||||
public ListClientTags(CommandConfiguration config, ITranslationLookup layout, IMetaServiceV2 metaService) : base(
|
||||
config, layout)
|
||||
{
|
||||
Name = "listclienttags";
|
||||
Description = layout["COMMANDS_LIST_CLIENT_TAGS_DESC"];
|
||||
Alias = "lct";
|
||||
Permission = EFClient.Permission.Owner;
|
||||
RequiresTarget = false;
|
||||
_metaService = metaService;
|
||||
}
|
||||
|
||||
public override async Task ExecuteAsync(GameEvent gameEvent)
|
||||
{
|
||||
var tags = await _metaService.GetPersistentMetaValue<List<TagMeta>>(EFMeta.ClientTagNameV2);
|
||||
|
||||
if (tags is not null)
|
||||
{
|
||||
await gameEvent.Origin.TellAsync(tags.Select(tag => tag.TagName),
|
||||
gameEvent.Owner.Manager.CancellationToken);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,48 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Threading.Tasks;
|
||||
using System.Linq;
|
||||
using Data.Models;
|
||||
using Data.Models.Client;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Commands;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Commands.ClientTags
|
||||
{
|
||||
public class RemoveClientTag : Command
|
||||
{
|
||||
private readonly IMetaServiceV2 _metaService;
|
||||
|
||||
public RemoveClientTag(CommandConfiguration config, ITranslationLookup layout, IMetaServiceV2 metaService) : base(
|
||||
config, layout)
|
||||
{
|
||||
Name = "removeclienttag";
|
||||
Description = layout["COMMANDS_REMOVE_CLIENT_TAG_DESC"];
|
||||
Alias = "rct";
|
||||
Permission = EFClient.Permission.Owner;
|
||||
RequiresTarget = false;
|
||||
Arguments = new[]
|
||||
{
|
||||
new CommandArgument
|
||||
{
|
||||
Name = _translationLookup["COMMANDS_ARGUMENT_TAG"],
|
||||
Required = true
|
||||
}
|
||||
};
|
||||
|
||||
_metaService = metaService;
|
||||
}
|
||||
|
||||
public override async Task ExecuteAsync(GameEvent gameEvent)
|
||||
{
|
||||
var existingMeta = await _metaService.GetPersistentMetaValue<List<TagMeta>>(EFMeta.ClientTagNameV2,
|
||||
gameEvent.Owner.Manager.CancellationToken);
|
||||
existingMeta = existingMeta.Where(meta => meta.TagName != gameEvent.Data.Trim()).ToList();
|
||||
await _metaService.SetPersistentMetaValue(EFMeta.ClientTagNameV2, existingMeta,
|
||||
gameEvent.Owner.Manager.CancellationToken);
|
||||
|
||||
gameEvent.Origin.Tell(_translationLookup["COMMANDS_REMOVE_CLIENT_TAG_SUCCESS"].FormatExt(gameEvent.Data));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,58 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Models;
|
||||
using Data.Models.Client;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Commands;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Dtos;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Commands.ClientTags
|
||||
{
|
||||
public class SetClientTagCommand : Command
|
||||
{
|
||||
private readonly IMetaServiceV2 _metaService;
|
||||
|
||||
|
||||
public SetClientTagCommand(CommandConfiguration config, ITranslationLookup layout, IMetaServiceV2 metaService) :
|
||||
base(config, layout)
|
||||
{
|
||||
Name = "setclienttag";
|
||||
Description = layout["COMMANDS_SET_CLIENT_TAG_DESC"];
|
||||
Alias = "sct";
|
||||
Permission = EFClient.Permission.Owner;
|
||||
RequiresTarget = true;
|
||||
Arguments = new[]
|
||||
{
|
||||
new CommandArgument
|
||||
{
|
||||
Name = _translationLookup["COMMANDS_ARGUMENT_TAG"],
|
||||
Required = true
|
||||
}
|
||||
};
|
||||
|
||||
_metaService = metaService;
|
||||
}
|
||||
|
||||
public override async Task ExecuteAsync(GameEvent gameEvent)
|
||||
{
|
||||
var token = gameEvent.Owner.Manager.CancellationToken;
|
||||
|
||||
var availableTags = await _metaService.GetPersistentMetaValue<List<LookupValue<string>>>(EFMeta.ClientTagNameV2, token);
|
||||
var matchingTag = availableTags.FirstOrDefault(tag => tag.Value == gameEvent.Data.Trim());
|
||||
|
||||
if (matchingTag == null)
|
||||
{
|
||||
gameEvent.Origin.Tell(_translationLookup["COMMANDS_SET_CLIENT_TAG_FAIL"].FormatExt(gameEvent.Data));
|
||||
return;
|
||||
}
|
||||
|
||||
gameEvent.Target.Tag = matchingTag.Value;
|
||||
await _metaService.SetPersistentMetaForLookupKey(EFMeta.ClientTagV2, EFMeta.ClientTagNameV2, matchingTag.Id,
|
||||
gameEvent.Target.ClientId, token);
|
||||
gameEvent.Origin.Tell(_translationLookup["COMMANDS_SET_CLIENT_TAG_SUCCESS"].FormatExt(matchingTag.Value));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,13 +0,0 @@
|
||||
using System.Text.Json.Serialization;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Commands.ClientTags;
|
||||
|
||||
public class TagMeta : ILookupValue<string>
|
||||
{
|
||||
[JsonIgnore] public int TagId => Id;
|
||||
[JsonIgnore] public string TagName => Value;
|
||||
|
||||
public int Id { get; set; }
|
||||
public string Value { get; set; }
|
||||
}
|
||||
@ -1,43 +0,0 @@
|
||||
using System.Threading.Tasks;
|
||||
using Data.Models;
|
||||
using Data.Models.Client;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Commands;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Commands.ClientTags
|
||||
{
|
||||
public class UnsetClientTagCommand : Command
|
||||
{
|
||||
private readonly IMetaServiceV2 _metaService;
|
||||
|
||||
public UnsetClientTagCommand(CommandConfiguration config, ITranslationLookup layout, IMetaServiceV2 metaService) :
|
||||
base(config, layout)
|
||||
{
|
||||
Name = "unsetclienttag";
|
||||
Description = layout["COMMANDS_UNSET_CLIENT_TAG_DESC"];
|
||||
Alias = "uct";
|
||||
Permission = EFClient.Permission.Owner;
|
||||
RequiresTarget = true;
|
||||
Arguments = new[]
|
||||
{
|
||||
new CommandArgument
|
||||
{
|
||||
Name = _translationLookup["COMMANDS_ARGUMENT_TAG"],
|
||||
Required = true
|
||||
}
|
||||
};
|
||||
|
||||
_metaService = metaService;
|
||||
}
|
||||
|
||||
public override async Task ExecuteAsync(GameEvent gameEvent)
|
||||
{
|
||||
gameEvent.Target.Tag = null;
|
||||
await _metaService.RemovePersistentMeta(EFMeta.ClientTagV2, gameEvent.Target.ClientId,
|
||||
gameEvent.Owner.Manager.CancellationToken);
|
||||
gameEvent.Origin.Tell(_translationLookup["COMMANDS_UNSET_CLIENT_TAG_SUCCESS"]);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,59 +0,0 @@
|
||||
using System;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Models.Client;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Commands;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Commands
|
||||
{
|
||||
/// <summary>
|
||||
/// Finds player by name
|
||||
/// </summary>
|
||||
public class FindPlayerCommand : Command
|
||||
{
|
||||
public FindPlayerCommand(CommandConfiguration config, ITranslationLookup translationLookup) : base(config,
|
||||
translationLookup)
|
||||
{
|
||||
Name = "find";
|
||||
Description = _translationLookup["COMMANDS_FIND_DESC"];
|
||||
Alias = "f";
|
||||
Permission = EFClient.Permission.Administrator;
|
||||
RequiresTarget = false;
|
||||
Arguments = new[]
|
||||
{
|
||||
new CommandArgument()
|
||||
{
|
||||
Name = _translationLookup["COMMANDS_ARGS_PLAYER"],
|
||||
Required = true
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
public override async Task ExecuteAsync(GameEvent gameEvent)
|
||||
{
|
||||
if (gameEvent.Data.Length < 3)
|
||||
{
|
||||
gameEvent.Origin.Tell(_translationLookup["COMMANDS_FIND_MIN"]);
|
||||
return;
|
||||
}
|
||||
|
||||
var players = await gameEvent.Owner.Manager.GetClientService().FindClientsByIdentifier(gameEvent.Data);
|
||||
|
||||
if (!players.Any())
|
||||
{
|
||||
gameEvent.Origin.Tell(_translationLookup["COMMANDS_FIND_EMPTY"]);
|
||||
return;
|
||||
}
|
||||
|
||||
foreach (var client in players)
|
||||
{
|
||||
gameEvent.Origin.Tell(_translationLookup["COMMANDS_FIND_FORMAT_V2"].FormatExt(client.Name,
|
||||
client.ClientId, Utilities.ConvertLevelToColor((EFClient.Permission) client.LevelInt, client.Level),
|
||||
client.IPAddress, (DateTime.UtcNow - client.LastConnection).HumanizeForCurrentCulture()));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,95 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Models.Client;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Commands;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Commands
|
||||
{
|
||||
/// <summary>
|
||||
/// Prints help information
|
||||
/// </summary>
|
||||
public class HelpCommand : Command
|
||||
{
|
||||
public HelpCommand(CommandConfiguration config, ITranslationLookup translationLookup) :
|
||||
base(config, translationLookup)
|
||||
{
|
||||
Name = "help";
|
||||
Description = translationLookup["COMMANDS_HELP_DESC"];
|
||||
Alias = "h";
|
||||
Permission = EFClient.Permission.User;
|
||||
RequiresTarget = false;
|
||||
Arguments = new[]
|
||||
{
|
||||
new CommandArgument
|
||||
{
|
||||
Name = translationLookup["COMMANDS_ARGS_COMMANDS"],
|
||||
Required = false
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
public override async Task ExecuteAsync(GameEvent gameEvent)
|
||||
{
|
||||
var searchTerm = gameEvent.Data.Trim();
|
||||
var availableCommands = gameEvent.Owner.Manager.Commands.Distinct().Where(command =>
|
||||
command.SupportedGames == null || !command.SupportedGames.Any() ||
|
||||
command.SupportedGames.Contains(gameEvent.Owner.GameName))
|
||||
.Where(command => gameEvent.Origin.Level >= command.Permission);
|
||||
|
||||
if (searchTerm.Length > 2)
|
||||
{
|
||||
var matchingCommand = availableCommands.FirstOrDefault(command =>
|
||||
command.Name.Equals(searchTerm, StringComparison.InvariantCultureIgnoreCase) ||
|
||||
command.Alias.Equals(searchTerm, StringComparison.InvariantCultureIgnoreCase));
|
||||
|
||||
if (matchingCommand != null)
|
||||
{
|
||||
gameEvent.Origin.Tell(_translationLookup["COMMANDS_HELP_SEARCH_RESULT"]
|
||||
.FormatExt(matchingCommand.Name, matchingCommand.Alias));
|
||||
gameEvent.Origin.Tell(matchingCommand.Syntax);
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
gameEvent.Origin.Tell(_translationLookup["COMMANDS_HELP_NOTFOUND"]);
|
||||
}
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
var commandStrings = availableCommands.Select((command, index) =>
|
||||
new
|
||||
{
|
||||
response = $" {_translationLookup["COMMANDS_HELP_LIST_FORMAT"].FormatExt(command.Name)} ",
|
||||
index
|
||||
});
|
||||
|
||||
var helpResponse = new StringBuilder();
|
||||
var messageList = new List<string>();
|
||||
|
||||
foreach (var item in commandStrings)
|
||||
{
|
||||
helpResponse.Append(item.response);
|
||||
|
||||
if (item.index == 0 || item.index % 4 != 0)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
messageList.Add(helpResponse.ToString());
|
||||
helpResponse = new StringBuilder();
|
||||
}
|
||||
|
||||
messageList.Add(helpResponse.ToString());
|
||||
|
||||
await gameEvent.Origin.TellAsync(messageList);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,50 +0,0 @@
|
||||
using System;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Models.Client;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Commands
|
||||
{
|
||||
/// <summary>
|
||||
/// Lists all unmasked admins
|
||||
/// </summary>
|
||||
public class ListAdminsCommand : Command
|
||||
{
|
||||
public ListAdminsCommand(CommandConfiguration config, ITranslationLookup translationLookup) : base(config,
|
||||
translationLookup)
|
||||
{
|
||||
Name = "admins";
|
||||
Description = _translationLookup["COMMANDS_ADMINS_DESC"];
|
||||
Alias = "a";
|
||||
Permission = EFClient.Permission.User;
|
||||
RequiresTarget = false;
|
||||
}
|
||||
|
||||
public static string OnlineAdmins(Server server, ITranslationLookup lookup)
|
||||
{
|
||||
var onlineAdmins = server.GetClientsAsList()
|
||||
.Where(p => p.Level > EFClient.Permission.Flagged)
|
||||
.Where(p => !p.Masked)
|
||||
.Select(p =>
|
||||
$"[(Color::Yellow){Utilities.ConvertLevelToColor(p.Level, p.ClientPermission.Name)}(Color::White)] {p.Name}")
|
||||
.ToList();
|
||||
|
||||
return onlineAdmins.Any() ? string.Join(Environment.NewLine, onlineAdmins) : lookup["COMMANDS_ADMINS_NONE"];
|
||||
}
|
||||
|
||||
public override Task ExecuteAsync(GameEvent gameEvent)
|
||||
{
|
||||
foreach (var line in OnlineAdmins(gameEvent.Owner, _translationLookup).Split(Environment.NewLine))
|
||||
{
|
||||
var _ = gameEvent.Message.IsBroadcastCommand(_config.BroadcastCommandPrefix)
|
||||
? gameEvent.Owner.Broadcast(line)
|
||||
: gameEvent.Origin.Tell(line);
|
||||
}
|
||||
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,57 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Models.Client;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Commands;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Commands
|
||||
{
|
||||
/// <summary>
|
||||
/// Lists alises of specified client
|
||||
/// </summary>
|
||||
public class ListAliasesCommand : Command
|
||||
{
|
||||
public ListAliasesCommand(CommandConfiguration config, ITranslationLookup translationLookup) : base(config,
|
||||
translationLookup)
|
||||
{
|
||||
Name = "alias";
|
||||
Description = _translationLookup["COMMANDS_ALIAS_DESC"];
|
||||
Alias = "known";
|
||||
Permission = EFClient.Permission.Moderator;
|
||||
RequiresTarget = true;
|
||||
Arguments = new[]
|
||||
{
|
||||
new CommandArgument()
|
||||
{
|
||||
Name = _translationLookup["COMMANDS_ARGS_PLAYER"],
|
||||
Required = true,
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
public override Task ExecuteAsync(GameEvent gameEvent)
|
||||
{
|
||||
var message = new StringBuilder();
|
||||
var names = new List<string>(gameEvent.Target.AliasLink.Children.Select(a => a.Name));
|
||||
var ips = new List<string>(gameEvent.Target.AliasLink.Children.Select(a => a.IPAddress.ConvertIPtoString())
|
||||
.Distinct());
|
||||
|
||||
gameEvent.Origin.Tell($"[(Color::Accent){gameEvent.Target}(Color::White)]");
|
||||
|
||||
message.Append($"{_translationLookup["COMMANDS_ALIAS_ALIASES"]}: ");
|
||||
message.Append(string.Join(" | ", names));
|
||||
gameEvent.Origin.Tell(message.ToString());
|
||||
|
||||
message.Clear();
|
||||
message.Append($"{_translationLookup["COMMANDS_ALIAS_IPS"]}: ");
|
||||
message.Append(string.Join(" | ", ips));
|
||||
gameEvent.Origin.Tell(message.ToString());
|
||||
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,37 +0,0 @@
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Models.Client;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Commands
|
||||
{
|
||||
/// <summary>
|
||||
/// List online clients
|
||||
/// </summary>
|
||||
public class ListClientsCommand : Command
|
||||
{
|
||||
public ListClientsCommand(CommandConfiguration config, ITranslationLookup translationLookup) : base(config,
|
||||
translationLookup)
|
||||
{
|
||||
Name = "list";
|
||||
Description = _translationLookup["COMMANDS_LIST_DESC"];
|
||||
Alias = "l";
|
||||
Permission = EFClient.Permission.Moderator;
|
||||
RequiresTarget = false;
|
||||
}
|
||||
|
||||
public override Task ExecuteAsync(GameEvent gameEvent)
|
||||
{
|
||||
var clientList = gameEvent.Owner.GetClientsAsList()
|
||||
.Select(client =>
|
||||
$"[(Color::Accent){client.ClientPermission.Name}(Color::White){(string.IsNullOrEmpty(client.Tag) ? "" : $" {client.Tag}")}(Color::White)][(Color::Yellow)#{client.ClientNumber}(Color::White)] {client.Name}")
|
||||
.ToArray();
|
||||
|
||||
gameEvent.Origin.TellAsync(clientList, gameEvent.Owner.Manager.CancellationToken);
|
||||
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,41 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Models.Client;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Commands
|
||||
{
|
||||
/// <summary>
|
||||
/// Lists the loaded plugins
|
||||
/// </summary>
|
||||
public class ListPluginsCommand : Command
|
||||
{
|
||||
private readonly IEnumerable<IPlugin> _plugins;
|
||||
|
||||
public ListPluginsCommand(CommandConfiguration config, ITranslationLookup translationLookup,
|
||||
IEnumerable<IPlugin> plugins) : base(config, translationLookup)
|
||||
{
|
||||
Name = "plugins";
|
||||
Description = _translationLookup["COMMANDS_PLUGINS_DESC"];
|
||||
Alias = "p";
|
||||
Permission = EFClient.Permission.Administrator;
|
||||
RequiresTarget = false;
|
||||
_plugins = plugins;
|
||||
}
|
||||
|
||||
public override Task ExecuteAsync(GameEvent gameEvent)
|
||||
{
|
||||
gameEvent.Origin.Tell(_translationLookup["COMMANDS_PLUGINS_LOADED"]);
|
||||
foreach (var plugin in _plugins.Where(plugin => !plugin.IsParser))
|
||||
{
|
||||
gameEvent.Origin.Tell(_translationLookup["COMMANDS_LIST_PLUGINS_FORMAT"]
|
||||
.FormatExt(plugin.Name, plugin.Version, plugin.Author));
|
||||
}
|
||||
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,59 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Models.Client;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Commands;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Helpers;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Commands
|
||||
{
|
||||
/// <summary>
|
||||
/// List all reports on the server
|
||||
/// </summary>
|
||||
public class ListReportsCommand : Command
|
||||
{
|
||||
public ListReportsCommand(CommandConfiguration config, ITranslationLookup translationLookup) : base(config,
|
||||
translationLookup)
|
||||
{
|
||||
Name = "reports";
|
||||
Description = _translationLookup["COMMANDS_REPORTS_DESC"];
|
||||
Alias = "reps";
|
||||
Permission = EFClient.Permission.Moderator;
|
||||
RequiresTarget = false;
|
||||
Arguments = new[]
|
||||
{
|
||||
new CommandArgument
|
||||
{
|
||||
Name = _translationLookup["COMMANDS_ARGS_CLEAR"],
|
||||
Required = false
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
public override Task ExecuteAsync(GameEvent gameEvent)
|
||||
{
|
||||
if (gameEvent.Data != null && gameEvent.Data.ToLower().Contains(_translationLookup["COMMANDS_ARGS_CLEAR"]))
|
||||
{
|
||||
gameEvent.Owner.Reports = new List<Report>();
|
||||
gameEvent.Origin.Tell(_translationLookup["COMMANDS_REPORTS_CLEAR_SUCCESS"]);
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
|
||||
if (gameEvent.Owner.Reports.Count < 1)
|
||||
{
|
||||
gameEvent.Origin.Tell(_translationLookup["COMMANDS_REPORTS_NONE"]);
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
|
||||
foreach (var report in gameEvent.Owner.Reports)
|
||||
{
|
||||
gameEvent.Origin.Tell(
|
||||
$"(Color::Accent){report.Origin.Name}(Color::White) -> (Color::Red){report.Target.Name}(Color::White): {report.Reason}");
|
||||
}
|
||||
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,116 +0,0 @@
|
||||
using System.Linq;
|
||||
using System.Text.RegularExpressions;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Models.Client;
|
||||
using IW4MAdmin.Application.Extensions;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Commands;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
namespace IW4MAdmin.Application.Commands
|
||||
{
|
||||
public class MapAndGameTypeCommand : Command
|
||||
{
|
||||
private const string ArgumentRegexPattern = "(?:\"([^\"]+)\"|([^\\s]+)) (?:\"([^\"]+)\"|([^\\s]+))";
|
||||
private readonly ILogger _logger;
|
||||
private readonly DefaultSettings _defaultSettings;
|
||||
|
||||
public MapAndGameTypeCommand(ILogger<MapAndGameTypeCommand> logger, CommandConfiguration config,
|
||||
DefaultSettings defaultSettings, ITranslationLookup layout) : base(config, layout)
|
||||
{
|
||||
Name = "mapandgametype";
|
||||
Description = _translationLookup["COMMANDS_MAG_DESCRIPTION"];
|
||||
Alias = "mag";
|
||||
Permission = EFClient.Permission.Administrator;
|
||||
RequiresTarget = false;
|
||||
Arguments = new[]
|
||||
{
|
||||
new CommandArgument
|
||||
{
|
||||
Name = _translationLookup["COMMADS_MAG_ARG_1"],
|
||||
Required = true
|
||||
},
|
||||
new CommandArgument
|
||||
{
|
||||
Name = _translationLookup["COMMADS_MAG_ARG_2"],
|
||||
Required = true
|
||||
}
|
||||
};
|
||||
_logger = logger;
|
||||
_defaultSettings = defaultSettings;
|
||||
}
|
||||
|
||||
public override async Task ExecuteAsync(GameEvent gameEvent)
|
||||
{
|
||||
var match = Regex.Match(gameEvent.Data.Trim(), ArgumentRegexPattern,
|
||||
RegexOptions.Compiled | RegexOptions.IgnoreCase);
|
||||
|
||||
if (!match.Success)
|
||||
{
|
||||
gameEvent.Origin.Tell(Syntax);
|
||||
return;
|
||||
}
|
||||
|
||||
var map = match.Groups[1].Length > 0 ? match.Groups[1].ToString() : match.Groups[2].ToString();
|
||||
var gametype = match.Groups[3].Length > 0 ? match.Groups[3].ToString() : match.Groups[4].ToString();
|
||||
|
||||
var matchingMaps = gameEvent.Owner.FindMap(map);
|
||||
var matchingGametypes = _defaultSettings.FindGametype(gametype, gameEvent.Owner.GameName);
|
||||
|
||||
if (matchingMaps.Count > 1)
|
||||
{
|
||||
gameEvent.Origin.Tell(_translationLookup["COMMANDS_MAG_MULTIPLE_MAPS"]);
|
||||
|
||||
foreach (var matchingMap in matchingMaps)
|
||||
{
|
||||
gameEvent.Origin.Tell(
|
||||
$"[(Color::Yellow){matchingMap.Alias}(Color::White)] [(Color::Yellow){matchingMap.Name}(Color::White)]");
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
if (matchingGametypes.Count > 1)
|
||||
{
|
||||
gameEvent.Origin.Tell(_translationLookup["COMMANDS_MAG_MULTIPLE_GAMETYPES"]);
|
||||
|
||||
foreach (var matchingGametype in matchingGametypes)
|
||||
{
|
||||
gameEvent.Origin.Tell(
|
||||
$"[(Color::Yellow){matchingGametype.Alias}(Color::White)] [(Color::Yellow){matchingGametype.Name}(Color::White)]");
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
map = matchingMaps.FirstOrDefault()?.Name ?? map;
|
||||
gametype = matchingGametypes.FirstOrDefault()?.Name ?? gametype;
|
||||
var hasMatchingGametype = matchingGametypes.Any();
|
||||
|
||||
_logger.LogDebug("Changing map to {Map} and gametype {Gametype}", map, gametype);
|
||||
|
||||
await gameEvent.Owner.SetDvarAsync("g_gametype", gametype, gameEvent.Owner.Manager.CancellationToken);
|
||||
gameEvent.Owner.Broadcast(_translationLookup["COMMANDS_MAP_SUCCESS"].FormatExt(map));
|
||||
await Task.Delay(gameEvent.Owner.Manager.GetApplicationSettings().Configuration().MapChangeDelaySeconds);
|
||||
|
||||
switch (gameEvent.Owner.GameName)
|
||||
{
|
||||
case Server.Game.IW5:
|
||||
await gameEvent.Owner.ExecuteCommandAsync(
|
||||
$"load_dsr {(hasMatchingGametype ? gametype.ToUpper() + "_default" : gametype)}");
|
||||
await gameEvent.Owner.ExecuteCommandAsync($"map {map}");
|
||||
break;
|
||||
case Server.Game.T6:
|
||||
await gameEvent.Owner.ExecuteCommandAsync($"exec {gametype}.cfg");
|
||||
await gameEvent.Owner.ExecuteCommandAsync($"map {map}");
|
||||
break;
|
||||
default:
|
||||
await gameEvent.Owner.ExecuteCommandAsync($"map {map}");
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,135 +0,0 @@
|
||||
using System;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Abstractions;
|
||||
using Data.Models.Client;
|
||||
using Data.Models.Misc;
|
||||
using IW4MAdmin.Application.Alerts;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Alerts;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
namespace IW4MAdmin.Application.Commands
|
||||
{
|
||||
public class OfflineMessageCommand : Command
|
||||
{
|
||||
private readonly IDatabaseContextFactory _contextFactory;
|
||||
private readonly ILogger _logger;
|
||||
private readonly IAlertManager _alertManager;
|
||||
private const short MaxLength = 1024;
|
||||
|
||||
public OfflineMessageCommand(CommandConfiguration config, ITranslationLookup layout,
|
||||
IDatabaseContextFactory contextFactory, ILogger<IDatabaseContextFactory> logger, IAlertManager alertManager)
|
||||
: base(config, layout)
|
||||
{
|
||||
Name = "offlinemessage";
|
||||
Description = _translationLookup["COMMANDS_OFFLINE_MESSAGE_DESC"];
|
||||
Alias = "om";
|
||||
Permission = EFClient.Permission.Moderator;
|
||||
RequiresTarget = true;
|
||||
|
||||
_contextFactory = contextFactory;
|
||||
_logger = logger;
|
||||
_alertManager = alertManager;
|
||||
|
||||
_alertManager.RegisterStaticAlertSource(async () =>
|
||||
{
|
||||
var context = contextFactory.CreateContext(false);
|
||||
return await context.InboxMessages.Where(message => !message.IsDelivered)
|
||||
.Where(message => message.CreatedDateTime >= DateTime.UtcNow.AddDays(-7))
|
||||
.Where(message => message.DestinationClient.Level > EFClient.Permission.User)
|
||||
.Select(message => new Alert.AlertState
|
||||
{
|
||||
OccuredAt = message.CreatedDateTime,
|
||||
Message = message.Message,
|
||||
ExpiresAt = DateTime.UtcNow.AddDays(7),
|
||||
Category = Alert.AlertCategory.Message,
|
||||
Source = message.SourceClient.CurrentAlias.Name.StripColors(),
|
||||
SourceId = message.SourceClientId,
|
||||
RecipientId = message.DestinationClientId,
|
||||
ReferenceId = message.InboxMessageId,
|
||||
Type = nameof(EFInboxMessage)
|
||||
}).ToListAsync();
|
||||
});
|
||||
|
||||
_alertManager.OnAlertConsumed += (_, state) =>
|
||||
{
|
||||
if (state.Category != Alert.AlertCategory.Message || state.ReferenceId is null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
var context = contextFactory.CreateContext(true);
|
||||
foreach (var message in context.InboxMessages
|
||||
.Where(message => message.InboxMessageId == state.ReferenceId.Value).ToList())
|
||||
{
|
||||
message.IsDelivered = true;
|
||||
}
|
||||
|
||||
context.SaveChanges();
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not update message state for alert {@Alert}", state);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
public override async Task ExecuteAsync(GameEvent gameEvent)
|
||||
{
|
||||
if (gameEvent.Data.Length > MaxLength)
|
||||
{
|
||||
gameEvent.Origin.Tell(_translationLookup["COMMANDS_OFFLINE_MESSAGE_TOO_LONG"].FormatExt(MaxLength));
|
||||
return;
|
||||
}
|
||||
|
||||
if (gameEvent.Target.ClientId == gameEvent.Origin.ClientId)
|
||||
{
|
||||
gameEvent.Origin.Tell(_translationLookup["COMMANDS_OFFLINE_MESSAGE_SELF"].FormatExt(MaxLength));
|
||||
return;
|
||||
}
|
||||
|
||||
if (gameEvent.Target.IsIngame)
|
||||
{
|
||||
gameEvent.Origin.Tell(_translationLookup["COMMANDS_OFFLINE_MESSAGE_INGAME"]
|
||||
.FormatExt(gameEvent.Target.Name));
|
||||
return;
|
||||
}
|
||||
|
||||
await using var context = _contextFactory.CreateContext(enableTracking: false);
|
||||
var server = await context.Servers.FirstAsync(srv => srv.EndPoint == gameEvent.Owner.ToString());
|
||||
|
||||
var newMessage = new EFInboxMessage
|
||||
{
|
||||
SourceClientId = gameEvent.Origin.ClientId,
|
||||
DestinationClientId = gameEvent.Target.ClientId,
|
||||
ServerId = server.Id,
|
||||
Message = gameEvent.Data,
|
||||
};
|
||||
|
||||
_alertManager.AddAlert(gameEvent.Target.BuildAlert(Alert.AlertCategory.Message)
|
||||
.WithMessage(gameEvent.Data.Trim())
|
||||
.FromClient(gameEvent.Origin)
|
||||
.OfType(nameof(EFInboxMessage))
|
||||
.ExpiresIn(TimeSpan.FromDays(7)));
|
||||
|
||||
try
|
||||
{
|
||||
context.Set<EFInboxMessage>().Add(newMessage);
|
||||
await context.SaveChangesAsync();
|
||||
gameEvent.Origin.Tell(_translationLookup["COMMANDS_OFFLINE_MESSAGE_SUCCESS"]);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not save offline message {@Message}", newMessage);
|
||||
throw;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,45 +0,0 @@
|
||||
using System.Threading.Tasks;
|
||||
using Data.Models.Client;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Commands;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Commands
|
||||
{
|
||||
/// <summary>
|
||||
/// Sends a private message to another player
|
||||
/// </summary>
|
||||
public class PrivateMessageCommand : Command
|
||||
{
|
||||
public PrivateMessageCommand(CommandConfiguration config, ITranslationLookup translationLookup) : base(config, translationLookup)
|
||||
{
|
||||
Name = "privatemessage";
|
||||
Description = _translationLookup["COMMANDS_PM_DESC"];
|
||||
Alias = "pm";
|
||||
Permission = EFClient.Permission.User;
|
||||
RequiresTarget = true;
|
||||
Arguments = new[]
|
||||
{
|
||||
new CommandArgument
|
||||
{
|
||||
Name = _translationLookup["COMMANDS_ARGS_PLAYER"],
|
||||
Required = true
|
||||
},
|
||||
new CommandArgument
|
||||
{
|
||||
Name = _translationLookup["COMMANDS_ARGS_MESSAGE"],
|
||||
Required = true
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
public override Task ExecuteAsync(GameEvent gameEvent)
|
||||
{
|
||||
gameEvent.Target.Tell(_translationLookup["COMMANDS_PRIVATE_MESSAGE_FORMAT"].FormatExt(gameEvent.Origin.Name, gameEvent.Data));
|
||||
gameEvent.Origin.Tell(_translationLookup["COMMANDS_PRIVATE_MESSAGE_RESULT"]
|
||||
.FormatExt(gameEvent.Target.Name, gameEvent.Data));
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,72 +0,0 @@
|
||||
using System;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Abstractions;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using EFClient = Data.Models.Client.EFClient;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
|
||||
namespace IW4MAdmin.Application.Commands
|
||||
{
|
||||
public class ReadMessageCommand : Command
|
||||
{
|
||||
private readonly IDatabaseContextFactory _contextFactory;
|
||||
private readonly ILogger _logger;
|
||||
|
||||
public ReadMessageCommand(CommandConfiguration config, ITranslationLookup layout,
|
||||
IDatabaseContextFactory contextFactory, ILogger<IDatabaseContextFactory> logger) : base(config, layout)
|
||||
{
|
||||
Name = "readmessage";
|
||||
Description = _translationLookup["COMMANDS_READ_MESSAGE_DESC"];
|
||||
Alias = "rm";
|
||||
Permission = EFClient.Permission.User;
|
||||
|
||||
_contextFactory = contextFactory;
|
||||
_logger = logger;
|
||||
}
|
||||
|
||||
public override async Task ExecuteAsync(GameEvent gameEvent)
|
||||
{
|
||||
try
|
||||
{
|
||||
await using var context = _contextFactory.CreateContext();
|
||||
|
||||
var inboxItems = await context.InboxMessages
|
||||
.Include(message => message.SourceClient)
|
||||
.ThenInclude(client => client.CurrentAlias)
|
||||
.Where(message => message.DestinationClientId == gameEvent.Origin.ClientId)
|
||||
.Where(message => !message.IsDelivered)
|
||||
.ToListAsync();
|
||||
|
||||
if (!inboxItems.Any())
|
||||
{
|
||||
gameEvent.Origin.Tell(_translationLookup["COMMANDS_READ_MESSAGE_NONE"]);
|
||||
return;
|
||||
}
|
||||
|
||||
await gameEvent.Origin.TellAsync(inboxItems.Select((inboxItem, index) =>
|
||||
{
|
||||
var header = _translationLookup["COMMANDS_READ_MESSAGE_SUCCESS"]
|
||||
.FormatExt($"{index + 1}/{inboxItems.Count}", inboxItem.SourceClient.CurrentAlias.Name);
|
||||
|
||||
return new[] { header }.Union(inboxItem.Message.FragmentMessageForDisplay());
|
||||
}).SelectMany(item => item));
|
||||
|
||||
inboxItems.ForEach(item => { item.IsDelivered = true; });
|
||||
|
||||
context.UpdateRange(inboxItems);
|
||||
await context.SaveChangesAsync();
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
logger.LogError(ex, "Could not retrieve offline messages for {Client}", gameEvent.Origin.ToString());
|
||||
throw;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,77 +0,0 @@
|
||||
using System.Threading.Tasks;
|
||||
using Data.Models.Client;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Commands;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Commands
|
||||
{
|
||||
/// <summary>
|
||||
/// Report client for given reason
|
||||
/// </summary>
|
||||
public class ReportClientCommand : Command
|
||||
{
|
||||
public ReportClientCommand(CommandConfiguration config, ITranslationLookup translationLookup) : base(config,
|
||||
translationLookup)
|
||||
{
|
||||
Name = "report";
|
||||
Description = _translationLookup["COMMANDS_REPORT_DESC"];
|
||||
Alias = "rep";
|
||||
Permission = EFClient.Permission.User;
|
||||
RequiresTarget = true;
|
||||
Arguments = new[]
|
||||
{
|
||||
new CommandArgument
|
||||
{
|
||||
Name = _translationLookup["COMMANDS_ARGS_PLAYER"],
|
||||
Required = true
|
||||
},
|
||||
new CommandArgument
|
||||
{
|
||||
Name = _translationLookup["COMMANDS_ARGS_REASON"],
|
||||
Required = true
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
public override async Task ExecuteAsync(GameEvent commandEvent)
|
||||
{
|
||||
if (commandEvent.Data.ToLower().Contains("camp"))
|
||||
{
|
||||
commandEvent.Origin.Tell(_translationLookup["COMMANDS_REPORT_FAIL_CAMP"]);
|
||||
return;
|
||||
}
|
||||
|
||||
var success = false;
|
||||
|
||||
switch ((await commandEvent.Target.Report(commandEvent.Data, commandEvent.Origin)
|
||||
.WaitAsync(Utilities.DefaultCommandTimeout, commandEvent.Owner.Manager.CancellationToken)).FailReason)
|
||||
{
|
||||
case GameEvent.EventFailReason.None:
|
||||
commandEvent.Origin.Tell(_translationLookup["COMMANDS_REPORT_SUCCESS"]);
|
||||
success = true;
|
||||
break;
|
||||
case GameEvent.EventFailReason.Exception:
|
||||
commandEvent.Origin.Tell(_translationLookup["COMMANDS_REPORT_FAIL_DUPLICATE"]);
|
||||
break;
|
||||
case GameEvent.EventFailReason.Permission:
|
||||
commandEvent.Origin.Tell(_translationLookup["COMMANDS_REPORT_FAIL"]
|
||||
.FormatExt(commandEvent.Target.Name));
|
||||
break;
|
||||
case GameEvent.EventFailReason.Invalid:
|
||||
commandEvent.Origin.Tell(_translationLookup["COMMANDS_REPORT_FAIL_SELF"]);
|
||||
break;
|
||||
case GameEvent.EventFailReason.Throttle:
|
||||
commandEvent.Origin.Tell(_translationLookup["COMMANDS_REPORT_FAIL_TOOMANY"]);
|
||||
break;
|
||||
}
|
||||
|
||||
if (success)
|
||||
{
|
||||
commandEvent.Owner.ToAdmins(
|
||||
$"(Color::Accent){commandEvent.Origin.Name}(Color::White) -> (Color::Red){commandEvent.Target.Name}(Color::White): {commandEvent.Data}");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,46 +0,0 @@
|
||||
using System.Threading.Tasks;
|
||||
using Data.Models.Client;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Commands;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Commands
|
||||
{
|
||||
/// <summary>
|
||||
/// Prints out a message to all clients on all servers
|
||||
/// </summary>
|
||||
public class SayAllCommand : Command
|
||||
{
|
||||
public SayAllCommand(CommandConfiguration config, ITranslationLookup translationLookup) : base(config,
|
||||
translationLookup)
|
||||
{
|
||||
Name = "sayall";
|
||||
Description = _translationLookup["COMMANDS_SAY_ALL_DESC"];
|
||||
Alias = "sa";
|
||||
Permission = EFClient.Permission.Moderator;
|
||||
RequiresTarget = false;
|
||||
Arguments = new[]
|
||||
{
|
||||
new CommandArgument
|
||||
{
|
||||
Name = _translationLookup["COMMANDS_ARGS_MESSAGE"],
|
||||
Required = true
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
public override Task ExecuteAsync(GameEvent gameEvent)
|
||||
{
|
||||
var message = $"(Color::Accent){gameEvent.Origin.Name}(Color::White) - (Color::Red){gameEvent.Data}";
|
||||
|
||||
foreach (var server in gameEvent.Owner.Manager.GetServers())
|
||||
{
|
||||
server.Broadcast(message, gameEvent.Origin);
|
||||
}
|
||||
|
||||
gameEvent.Origin.Tell(_translationLookup["COMMANDS_SAY_SUCCESS"]);
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,42 +0,0 @@
|
||||
using System.Threading.Tasks;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Commands;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using EFClient = Data.Models.Client.EFClient;
|
||||
|
||||
namespace IW4MAdmin.Application.Commands
|
||||
{
|
||||
/// <summary>
|
||||
/// Prints out a message to all clients on the server
|
||||
/// </summary>
|
||||
public class SayCommand : Command
|
||||
{
|
||||
public SayCommand(CommandConfiguration config, ITranslationLookup translationLookup) : base(config,
|
||||
translationLookup)
|
||||
{
|
||||
Name = "say";
|
||||
Description = _translationLookup["COMMANDS_SAY_DESC"];
|
||||
Alias = "s";
|
||||
Permission = EFClient.Permission.Moderator;
|
||||
RequiresTarget = false;
|
||||
Arguments = new[]
|
||||
{
|
||||
new CommandArgument
|
||||
{
|
||||
Name = _translationLookup["COMMANDS_ARGS_MESSAGE"],
|
||||
Required = true
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
public override Task ExecuteAsync(GameEvent gameEvent)
|
||||
{
|
||||
gameEvent.Owner.Broadcast(
|
||||
_translationLookup["COMMANDS_SAY_FORMAT"].FormatExt(gameEvent.Origin.Name, gameEvent.Data),
|
||||
gameEvent.Origin);
|
||||
gameEvent.Origin.Tell(_translationLookup["COMMANDS_SAY_SUCCESS"]);
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,80 +0,0 @@
|
||||
using System;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Models.Client;
|
||||
using Serilog.Core;
|
||||
using Serilog.Events;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Commands;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Commands;
|
||||
|
||||
public class SetLogLevelCommand : Command
|
||||
{
|
||||
private readonly Func<string, LoggingLevelSwitch> _levelSwitchResolver;
|
||||
|
||||
public SetLogLevelCommand(CommandConfiguration config, ITranslationLookup layout, Func<string, LoggingLevelSwitch> levelSwitchResolver) : base(config, layout)
|
||||
{
|
||||
_levelSwitchResolver = levelSwitchResolver;
|
||||
|
||||
Name = "loglevel";
|
||||
Alias = "ll";
|
||||
Description = "set minimum logging level";
|
||||
Permission = EFClient.Permission.Owner;
|
||||
Arguments = new CommandArgument[]
|
||||
{
|
||||
new()
|
||||
{
|
||||
Name = "Log Level",
|
||||
Required = true
|
||||
},
|
||||
new()
|
||||
{
|
||||
Name = "Override",
|
||||
Required = false
|
||||
},
|
||||
new()
|
||||
{
|
||||
Name = "IsDevelopment",
|
||||
Required = false
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
public override async Task ExecuteAsync(GameEvent gameEvent)
|
||||
{
|
||||
var args = gameEvent.Data.Split(" ");
|
||||
if (!Enum.TryParse<LogEventLevel>(args[0], out var minLevel))
|
||||
{
|
||||
await gameEvent.Origin.TellAsync(new[]
|
||||
{
|
||||
$"Valid log values: {string.Join(",", Enum.GetValues<LogEventLevel>())}"
|
||||
});
|
||||
return;
|
||||
}
|
||||
|
||||
var context = string.Empty;
|
||||
|
||||
if (args.Length > 1)
|
||||
{
|
||||
context = args[1];
|
||||
}
|
||||
|
||||
var loggingSwitch = _levelSwitchResolver(context);
|
||||
loggingSwitch.MinimumLevel = minLevel;
|
||||
|
||||
if (args.Length > 2 && (args[2] == "1" || args[2].ToLower() == "true"))
|
||||
{
|
||||
AppContext.SetSwitch("IsDevelop", true);
|
||||
}
|
||||
else
|
||||
{
|
||||
AppContext.SetSwitch("IsDevelop", false);
|
||||
}
|
||||
|
||||
await gameEvent.Origin.TellAsync(new[]
|
||||
{ $"Set minimum log level to {loggingSwitch.MinimumLevel.ToString()}" });
|
||||
}
|
||||
}
|
||||
@ -1,38 +0,0 @@
|
||||
using System.Threading.Tasks;
|
||||
using Data.Models.Client;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Commands
|
||||
{
|
||||
/// <summary>
|
||||
/// Prints client information
|
||||
/// </summary>
|
||||
public class WhoAmICommand : Command
|
||||
{
|
||||
public WhoAmICommand(CommandConfiguration config, ITranslationLookup translationLookup) : base(config,
|
||||
translationLookup)
|
||||
{
|
||||
Name = "whoami";
|
||||
Description = _translationLookup["COMMANDS_WHO_DESC"];
|
||||
Alias = "who";
|
||||
Permission = EFClient.Permission.User;
|
||||
RequiresTarget = false;
|
||||
}
|
||||
|
||||
public override Task ExecuteAsync(GameEvent gameEvent)
|
||||
{
|
||||
var you =
|
||||
"[(Color::Yellow)#{{clientNumber}}(Color::White)] [(Color::Yellow)@{{clientId}}(Color::White)] [{{networkId}}] [{{ip}}] [(Color::Cyan){{level}}(Color::White){{tag}}(Color::White)] {{name}}"
|
||||
.FormatExt(gameEvent.Origin.ClientNumber,
|
||||
gameEvent.Origin.ClientId, gameEvent.Origin.GuidString,
|
||||
gameEvent.Origin.IPAddressString, gameEvent.Origin.ClientPermission.Name,
|
||||
string.IsNullOrEmpty(gameEvent.Origin.Tag) ? "" : $" {gameEvent.Origin.Tag}",
|
||||
gameEvent.Origin.Name);
|
||||
gameEvent.Origin.Tell(you);
|
||||
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,56 +0,0 @@
|
||||
{
|
||||
"Serilog": {
|
||||
"Using": [
|
||||
"Serilog.Sinks.File"
|
||||
],
|
||||
"MinimumLevel": {
|
||||
"Default": "Information",
|
||||
"Override": {
|
||||
"System": "Warning",
|
||||
"Microsoft": "Warning"
|
||||
}
|
||||
},
|
||||
"WriteTo": [
|
||||
{
|
||||
"Name": "File",
|
||||
"Args": {
|
||||
"path": "Log/IW4MAdmin-Application.log",
|
||||
"rollingInterval": "Day",
|
||||
"outputTemplate": "[{Timestamp:yyyy-MM-dd HH:mm:ss.fff} {Server} {Level:u3}] {Message:lj}{NewLine}{Exception}"
|
||||
}
|
||||
},
|
||||
{
|
||||
"Name": "Console",
|
||||
"Args": {
|
||||
"outputTemplate": "[{Timestamp:yyyy-MM-dd HH:mm:ss.fff} {Server} {Level:u3}] {Message:lj}{NewLine}{Exception}",
|
||||
"RestrictedToMinimumLevel": "Fatal"
|
||||
}
|
||||
}
|
||||
],
|
||||
"Enrich": [
|
||||
"FromLogContext",
|
||||
"WithMachineName",
|
||||
"WithThreadId"
|
||||
],
|
||||
"Destructure": [
|
||||
{
|
||||
"Name": "ToMaximumDepth",
|
||||
"Args": {
|
||||
"maximumDestructuringDepth": 4
|
||||
}
|
||||
},
|
||||
{
|
||||
"Name": "ToMaximumStringLength",
|
||||
"Args": {
|
||||
"maximumStringLength": 1000
|
||||
}
|
||||
},
|
||||
{
|
||||
"Name": "ToMaximumCollectionCount",
|
||||
"Args": {
|
||||
"maximumCollectionCount": 24
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
@ -1,15 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Configuration
|
||||
{
|
||||
public class ScriptPluginConfiguration : Dictionary<string, Dictionary<string, object>>, IBaseConfiguration
|
||||
{
|
||||
public string Name() => nameof(ScriptPluginConfiguration);
|
||||
|
||||
public IBaseConfiguration Generate()
|
||||
{
|
||||
return new ScriptPluginConfiguration();
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,145 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Concurrent;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Events;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using System.Linq;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SharedLibraryCore.Events.Management;
|
||||
using SharedLibraryCore.Events.Server;
|
||||
using SharedLibraryCore.Interfaces.Events;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
namespace IW4MAdmin.Application
|
||||
{
|
||||
public class CoreEventHandler : ICoreEventHandler
|
||||
{
|
||||
private const int MaxCurrentEvents = 25;
|
||||
private readonly ILogger _logger;
|
||||
private readonly SemaphoreSlim _onProcessingEvents = new(MaxCurrentEvents, MaxCurrentEvents);
|
||||
private readonly ManualResetEventSlim _onEventReady = new(false);
|
||||
private readonly ConcurrentQueue<(IManager, CoreEvent)> _runningEventTasks = new();
|
||||
private CancellationToken _cancellationToken;
|
||||
private int _activeTasks;
|
||||
|
||||
private static readonly GameEvent.EventType[] OverrideEvents =
|
||||
{
|
||||
GameEvent.EventType.Connect,
|
||||
GameEvent.EventType.Disconnect,
|
||||
GameEvent.EventType.Quit,
|
||||
GameEvent.EventType.Stop
|
||||
};
|
||||
|
||||
public CoreEventHandler(ILogger<CoreEventHandler> logger)
|
||||
{
|
||||
_logger = logger;
|
||||
}
|
||||
|
||||
public void QueueEvent(IManager manager, CoreEvent coreEvent)
|
||||
{
|
||||
_runningEventTasks.Enqueue((manager, coreEvent));
|
||||
_onEventReady.Set();
|
||||
}
|
||||
|
||||
public void StartProcessing(CancellationToken token)
|
||||
{
|
||||
_cancellationToken = token;
|
||||
|
||||
while (!_cancellationToken.IsCancellationRequested)
|
||||
{
|
||||
_onEventReady.Reset();
|
||||
|
||||
try
|
||||
{
|
||||
_onProcessingEvents.Wait(_cancellationToken);
|
||||
|
||||
if (!_runningEventTasks.TryDequeue(out var coreEvent))
|
||||
{
|
||||
if (_onProcessingEvents.CurrentCount < MaxCurrentEvents)
|
||||
{
|
||||
_onProcessingEvents.Release(1);
|
||||
}
|
||||
|
||||
_onEventReady.Wait(_cancellationToken);
|
||||
continue;
|
||||
}
|
||||
|
||||
_logger.LogDebug("Start processing event {Name} {SemaphoreCount} - {QueuedTasks}",
|
||||
coreEvent.Item2.GetType().Name, _onProcessingEvents.CurrentCount, _runningEventTasks.Count);
|
||||
|
||||
_ = Task.Factory.StartNew(() =>
|
||||
{
|
||||
Interlocked.Increment(ref _activeTasks);
|
||||
_logger.LogDebug("[Start] Active Tasks = {TaskCount}", _activeTasks);
|
||||
return HandleEventTaskExecute(coreEvent);
|
||||
});
|
||||
}
|
||||
catch (OperationCanceledException)
|
||||
{
|
||||
// ignored
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not enqueue event for processing");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private async Task HandleEventTaskExecute((IManager, CoreEvent) coreEvent)
|
||||
{
|
||||
try
|
||||
{
|
||||
await GetEventTask(coreEvent.Item1, coreEvent.Item2);
|
||||
}
|
||||
catch (OperationCanceledException)
|
||||
{
|
||||
_logger.LogWarning("Event timed out {Type}", coreEvent.Item2.GetType().Name);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not complete invoke for {EventType}",
|
||||
coreEvent.Item2.GetType().Name);
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (_onProcessingEvents.CurrentCount < MaxCurrentEvents)
|
||||
{
|
||||
_logger.LogDebug("Freeing up event semaphore for next event {SemaphoreCount}",
|
||||
_onProcessingEvents.CurrentCount);
|
||||
_onProcessingEvents.Release(1);
|
||||
}
|
||||
|
||||
Interlocked.Decrement(ref _activeTasks);
|
||||
_logger.LogDebug("[Complete] {Type}, Active Tasks = {TaskCount} - {Queue}", coreEvent.Item2.GetType(),
|
||||
_activeTasks, _runningEventTasks.Count);
|
||||
}
|
||||
}
|
||||
|
||||
private Task GetEventTask(IManager manager, CoreEvent coreEvent)
|
||||
{
|
||||
return coreEvent switch
|
||||
{
|
||||
GameEvent gameEvent => BuildLegacyEventTask(manager, coreEvent, gameEvent),
|
||||
GameServerEvent gameServerEvent => IGameServerEventSubscriptions.InvokeEventAsync(gameServerEvent,
|
||||
manager.CancellationToken),
|
||||
ManagementEvent managementEvent => IManagementEventSubscriptions.InvokeEventAsync(managementEvent,
|
||||
manager.CancellationToken),
|
||||
_ => Task.CompletedTask
|
||||
};
|
||||
}
|
||||
|
||||
private async Task BuildLegacyEventTask(IManager manager, CoreEvent coreEvent, GameEvent gameEvent)
|
||||
{
|
||||
if (manager.IsRunning || OverrideEvents.Contains(gameEvent.Type))
|
||||
{
|
||||
await manager.ExecuteEvent(gameEvent);
|
||||
await IGameEventSubscriptions.InvokeEventAsync(coreEvent, manager.CancellationToken);
|
||||
return;
|
||||
}
|
||||
|
||||
_logger.LogDebug("Skipping event as we're shutting down {EventId}", gameEvent.IncrementalId);
|
||||
}
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,71 +1,42 @@
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Database.Models;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using Data.Models;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SharedLibraryCore.Events.Game;
|
||||
using static System.Int32;
|
||||
using System.Text.RegularExpressions;
|
||||
using static SharedLibraryCore.Server;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
namespace IW4MAdmin.Application.EventParsers
|
||||
{
|
||||
public class BaseEventParser : IEventParser
|
||||
class BaseEventParser : IEventParser
|
||||
{
|
||||
private readonly Dictionary<string, (string, Func<string, IEventParserConfiguration, GameEvent, GameEvent>)>
|
||||
_customEventRegistrations;
|
||||
|
||||
private readonly ILogger _logger;
|
||||
private readonly ApplicationConfiguration _appConfig;
|
||||
private readonly Dictionary<ParserRegex, GameEvent.EventType> _regexMap;
|
||||
private readonly Dictionary<string, GameEvent.EventType> _eventTypeMap;
|
||||
|
||||
public BaseEventParser(IParserRegexFactory parserRegexFactory, ILogger logger,
|
||||
ApplicationConfiguration appConfig)
|
||||
public BaseEventParser()
|
||||
{
|
||||
_customEventRegistrations =
|
||||
new Dictionary<string, (string, Func<string, IEventParserConfiguration, GameEvent, GameEvent>)>();
|
||||
_logger = logger;
|
||||
_appConfig = appConfig;
|
||||
|
||||
Configuration = new DynamicEventParserConfiguration(parserRegexFactory)
|
||||
Configuration = new DynamicEventParserConfiguration()
|
||||
{
|
||||
GameDirectory = "main",
|
||||
LocalizeText = "\x15",
|
||||
};
|
||||
|
||||
Configuration.Say.Pattern = @"^(say|sayteam);(-?[A-Fa-f0-9_]{1,32}|bot[0-9]+|0);([0-9]+);([^;]*);(.*)$";
|
||||
Configuration.Say.Pattern = @"^(say|sayteam);(-?[A-Fa-f0-9_]{1,32});([0-9]+);(.+);(.*)$";
|
||||
Configuration.Say.AddMapping(ParserRegex.GroupType.EventType, 1);
|
||||
Configuration.Say.AddMapping(ParserRegex.GroupType.OriginNetworkId, 2);
|
||||
Configuration.Say.AddMapping(ParserRegex.GroupType.OriginClientNumber, 3);
|
||||
Configuration.Say.AddMapping(ParserRegex.GroupType.OriginName, 4);
|
||||
Configuration.Say.AddMapping(ParserRegex.GroupType.Message, 5);
|
||||
|
||||
Configuration.Quit.Pattern = @"^(Q);(-?[A-Fa-f0-9_]{1,32}|bot[0-9]+|0);([0-9]+);(.*)$";
|
||||
Configuration.Quit.Pattern = @"^(Q);(-?[A-Fa-f0-9_]{1,32}|bot[0-9]+);([0-9]+);(.*)$";
|
||||
Configuration.Quit.AddMapping(ParserRegex.GroupType.EventType, 1);
|
||||
Configuration.Quit.AddMapping(ParserRegex.GroupType.OriginNetworkId, 2);
|
||||
Configuration.Quit.AddMapping(ParserRegex.GroupType.OriginClientNumber, 3);
|
||||
Configuration.Quit.AddMapping(ParserRegex.GroupType.OriginName, 4);
|
||||
|
||||
Configuration.Join.Pattern = @"^(J);(-?[A-Fa-f0-9_]{1,32}|bot[0-9]+|0);([0-9]+);(.*)$";
|
||||
Configuration.Join.Pattern = @"^(J);(-?[A-Fa-f0-9_]{1,32}|bot[0-9]+);([0-9]+);(.*)$";
|
||||
Configuration.Join.AddMapping(ParserRegex.GroupType.EventType, 1);
|
||||
Configuration.Join.AddMapping(ParserRegex.GroupType.OriginNetworkId, 2);
|
||||
Configuration.Join.AddMapping(ParserRegex.GroupType.OriginClientNumber, 3);
|
||||
Configuration.Join.AddMapping(ParserRegex.GroupType.OriginName, 4);
|
||||
|
||||
Configuration.JoinTeam.Pattern = @"^(JT);(-?[A-Fa-f0-9_]{1,32}|bot[0-9]+|0);([0-9]+);(\w+);(.+)$";
|
||||
Configuration.JoinTeam.AddMapping(ParserRegex.GroupType.EventType, 1);
|
||||
Configuration.JoinTeam.AddMapping(ParserRegex.GroupType.OriginNetworkId, 2);
|
||||
Configuration.JoinTeam.AddMapping(ParserRegex.GroupType.OriginClientNumber, 3);
|
||||
Configuration.JoinTeam.AddMapping(ParserRegex.GroupType.OriginTeam, 4);
|
||||
Configuration.JoinTeam.AddMapping(ParserRegex.GroupType.OriginName, 5);
|
||||
|
||||
Configuration.Damage.Pattern =
|
||||
@"^(D);(-?[A-Fa-f0-9_]{1,32}|bot[0-9]+|0);(-?[0-9]+);(axis|allies|world|none)?;([^;]{1,32});(-?[A-Fa-f0-9_]{1,32}|bot[0-9]+|0)?;(-?[0-9]+);(axis|allies|world|none)?;([^;]{1,32})?;((?:[0-9]+|[a-z]+|_|\+)+);([0-9]+);((?:[A-Z]|_)+);((?:[a-z]|_)+)$";
|
||||
Configuration.Damage.Pattern = @"^(D);(-?[A-Fa-f0-9_]{1,32}|bot[0-9]+);(-?[0-9]+);(axis|allies|world);(.{1,24});(-?[A-Fa-f0-9_]{1,32}|bot[0-9]+)?;-?([0-9]+);(axis|allies|world);(.{1,24})?;((?:[0-9]+|[a-z]+|_)+);([0-9]+);((?:[A-Z]|_)+);((?:[a-z]|_)+)$";
|
||||
Configuration.Damage.AddMapping(ParserRegex.GroupType.EventType, 1);
|
||||
Configuration.Damage.AddMapping(ParserRegex.GroupType.TargetNetworkId, 2);
|
||||
Configuration.Damage.AddMapping(ParserRegex.GroupType.TargetClientNumber, 3);
|
||||
@ -80,8 +51,7 @@ namespace IW4MAdmin.Application.EventParsers
|
||||
Configuration.Damage.AddMapping(ParserRegex.GroupType.MeansOfDeath, 12);
|
||||
Configuration.Damage.AddMapping(ParserRegex.GroupType.HitLocation, 13);
|
||||
|
||||
Configuration.Kill.Pattern =
|
||||
@"^(K);(-?[A-Fa-f0-9_]{1,32}|bot[0-9]+|0);(-?[0-9]+);(axis|allies|world|none)?;([^;]{1,32});(-?[A-Fa-f0-9_]{1,32}|bot[0-9]+|0)?;(-?[0-9]+);(axis|allies|world|none)?;([^;]{1,32})?;((?:[0-9]+|[a-z]+|_|\+)+);([0-9]+);((?:[A-Z]|_)+);((?:[a-z]|_)+)$";
|
||||
Configuration.Kill.Pattern = @"^(K);(-?[A-Fa-f0-9_]{1,32}|bot[0-9]+);(-?[0-9]+);(axis|allies|world);(.{1,24});(-?[A-Fa-f0-9_]{1,32}|bot[0-9]+)?;-?([0-9]+);(axis|allies|world);(.{1,24})?;((?:[0-9]+|[a-z]+|_)+);([0-9]+);((?:[A-Z]|_)+);((?:[a-z]|_)+)$";
|
||||
Configuration.Kill.AddMapping(ParserRegex.GroupType.EventType, 1);
|
||||
Configuration.Kill.AddMapping(ParserRegex.GroupType.TargetNetworkId, 2);
|
||||
Configuration.Kill.AddMapping(ParserRegex.GroupType.TargetClientNumber, 3);
|
||||
@ -95,33 +65,6 @@ namespace IW4MAdmin.Application.EventParsers
|
||||
Configuration.Kill.AddMapping(ParserRegex.GroupType.Damage, 11);
|
||||
Configuration.Kill.AddMapping(ParserRegex.GroupType.MeansOfDeath, 12);
|
||||
Configuration.Kill.AddMapping(ParserRegex.GroupType.HitLocation, 13);
|
||||
|
||||
Configuration.MapChange.Pattern = @".*InitGame.*";
|
||||
Configuration.MapEnd.Pattern = @".*(?:ExitLevel|ShutdownGame).*";
|
||||
|
||||
Configuration.Time.Pattern = @"^ *(([0-9]+):([0-9]+) |^[0-9]+ )";
|
||||
|
||||
_regexMap = new Dictionary<ParserRegex, GameEvent.EventType>
|
||||
{
|
||||
{ Configuration.Say, GameEvent.EventType.Say },
|
||||
{ Configuration.Kill, GameEvent.EventType.Kill },
|
||||
{ Configuration.MapChange, GameEvent.EventType.MapChange },
|
||||
{ Configuration.MapEnd, GameEvent.EventType.MapEnd },
|
||||
{ Configuration.JoinTeam, GameEvent.EventType.JoinTeam }
|
||||
};
|
||||
|
||||
_eventTypeMap = new Dictionary<string, GameEvent.EventType>
|
||||
{
|
||||
{ "say", GameEvent.EventType.Say },
|
||||
{ "sayteam", GameEvent.EventType.SayTeam },
|
||||
{ "chat", GameEvent.EventType.Say },
|
||||
{ "chatteam", GameEvent.EventType.SayTeam },
|
||||
{ "K", GameEvent.EventType.Kill },
|
||||
{ "D", GameEvent.EventType.Damage },
|
||||
{ "J", GameEvent.EventType.PreConnect },
|
||||
{ "JT", GameEvent.EventType.JoinTeam },
|
||||
{ "Q", GameEvent.EventType.PreDisconnect }
|
||||
};
|
||||
}
|
||||
|
||||
public IEventParserConfiguration Configuration { get; set; }
|
||||
@ -132,577 +75,254 @@ namespace IW4MAdmin.Application.EventParsers
|
||||
|
||||
public string URLProtocolFormat { get; set; } = "CoD://{{ip}}:{{port}}";
|
||||
|
||||
public string Name { get; set; } = "Call of Duty";
|
||||
|
||||
public virtual GameEvent GenerateGameEvent(string logLine)
|
||||
public virtual GameEvent GetEvent(Server server, string logLine)
|
||||
{
|
||||
var timeMatch = Configuration.Time.PatternMatcher.Match(logLine);
|
||||
var gameTime = 0L;
|
||||
logLine = Regex.Replace(logLine, @"([0-9]+:[0-9]+ |^[0-9]+ )", "").Trim();
|
||||
string[] lineSplit = logLine.Split(';');
|
||||
string eventType = lineSplit[0];
|
||||
|
||||
if (timeMatch.Success)
|
||||
if (eventType == "JoinTeam")
|
||||
{
|
||||
if (timeMatch.Values[0].Contains(':'))
|
||||
var origin = server.GetClientsAsList()
|
||||
.FirstOrDefault(c => c.NetworkId == lineSplit[1].ConvertLong());
|
||||
|
||||
return new GameEvent()
|
||||
{
|
||||
gameTime = timeMatch
|
||||
.Values
|
||||
.Skip(2)
|
||||
// this converts the timestamp into seconds passed
|
||||
.Select((value, index) => long.Parse(value.ToString()) * (index == 0 ? 60 : 1))
|
||||
.Sum();
|
||||
}
|
||||
else
|
||||
{
|
||||
gameTime = long.Parse(timeMatch.Values[0]);
|
||||
}
|
||||
|
||||
// we want to strip the time from the log line
|
||||
logLine = logLine[timeMatch.Values.First().Length..].Trim();
|
||||
}
|
||||
|
||||
var (eventType, eventKey) = GetEventTypeFromLine(logLine);
|
||||
|
||||
switch (eventType)
|
||||
{
|
||||
case GameEvent.EventType.Say or GameEvent.EventType.SayTeam:
|
||||
return ParseMessageEvent(logLine, gameTime, eventType) ?? GenerateDefaultEvent(logLine, gameTime);
|
||||
case GameEvent.EventType.Kill:
|
||||
return ParseKillEvent(logLine, gameTime) ?? GenerateDefaultEvent(logLine, gameTime);
|
||||
case GameEvent.EventType.Damage:
|
||||
return ParseDamageEvent(logLine, gameTime) ?? GenerateDefaultEvent(logLine, gameTime);
|
||||
case GameEvent.EventType.PreConnect:
|
||||
return ParseClientEnterMatchEvent(logLine, gameTime) ?? GenerateDefaultEvent(logLine, gameTime);
|
||||
case GameEvent.EventType.JoinTeam:
|
||||
return ParseJoinTeamEvent(logLine, gameTime) ?? GenerateDefaultEvent(logLine, gameTime);
|
||||
case GameEvent.EventType.PreDisconnect:
|
||||
return ParseClientExitMatchEvent(logLine, gameTime) ?? GenerateDefaultEvent(logLine, gameTime);
|
||||
case GameEvent.EventType.MapEnd:
|
||||
return ParseMatchEndEvent(logLine, gameTime);
|
||||
case GameEvent.EventType.MapChange:
|
||||
return ParseMatchStartEvent(logLine, gameTime);
|
||||
}
|
||||
|
||||
if (logLine.StartsWith("GSE;"))
|
||||
{
|
||||
return new GameScriptEvent
|
||||
{
|
||||
ScriptData = logLine,
|
||||
GameTime = gameTime,
|
||||
Source = GameEvent.EventSource.Log
|
||||
Type = GameEvent.EventType.JoinTeam,
|
||||
Data = logLine,
|
||||
Origin = origin,
|
||||
Owner = server
|
||||
};
|
||||
}
|
||||
|
||||
if (eventKey is null || !_customEventRegistrations.ContainsKey(eventKey))
|
||||
if (eventType == "say" || eventType == "sayteam")
|
||||
{
|
||||
return GenerateDefaultEvent(logLine, gameTime);
|
||||
}
|
||||
var matchResult = Regex.Match(logLine, Configuration.Say.Pattern);
|
||||
|
||||
var eventModifier = _customEventRegistrations[eventKey];
|
||||
|
||||
try
|
||||
{
|
||||
return eventModifier.Item2(logLine, Configuration, new GameEvent()
|
||||
if (matchResult.Success)
|
||||
{
|
||||
Type = GameEvent.EventType.Other,
|
||||
Data = logLine,
|
||||
Subtype = eventModifier.Item1,
|
||||
GameTime = gameTime,
|
||||
Source = GameEvent.EventSource.Log
|
||||
});
|
||||
string message = matchResult
|
||||
.Groups[Configuration.Say.GroupMapping[ParserRegex.GroupType.Message]]
|
||||
.ToString()
|
||||
.Replace("\x15", "")
|
||||
.Trim();
|
||||
|
||||
var origin = server.GetClientsAsList()
|
||||
.First(c => c.NetworkId == matchResult.Groups[Configuration.Say.GroupMapping[ParserRegex.GroupType.OriginNetworkId]].ToString().ConvertLong());
|
||||
|
||||
if (message[0] == '!' || message[0] == '@')
|
||||
{
|
||||
return new GameEvent()
|
||||
{
|
||||
Type = GameEvent.EventType.Command,
|
||||
Data = message,
|
||||
Origin = origin,
|
||||
Owner = server,
|
||||
Message = message
|
||||
};
|
||||
}
|
||||
|
||||
return new GameEvent()
|
||||
{
|
||||
Type = GameEvent.EventType.Say,
|
||||
Data = message,
|
||||
Origin = origin,
|
||||
Owner = server,
|
||||
Message = message
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
catch (Exception ex)
|
||||
if (eventType == "K")
|
||||
{
|
||||
_logger.LogError(ex, "Could not handle custom log event generation");
|
||||
if (!server.CustomCallback)
|
||||
{
|
||||
var match = Regex.Match(logLine, Configuration.Kill.Pattern);
|
||||
|
||||
if (match.Success)
|
||||
{
|
||||
string originId = match.Groups[Configuration.Kill.GroupMapping[ParserRegex.GroupType.OriginNetworkId]].Value.ToString();
|
||||
string targetId = match.Groups[Configuration.Kill.GroupMapping[ParserRegex.GroupType.TargetNetworkId]].Value.ToString();
|
||||
|
||||
var origin = !string.IsNullOrEmpty(originId) ? server.GetClientsAsList()
|
||||
.First(c => c.NetworkId == originId.ConvertLong()) :
|
||||
Utilities.IW4MAdminClient(server);
|
||||
|
||||
var target = !string.IsNullOrEmpty(targetId) ? server.GetClientsAsList()
|
||||
.First(c => c.NetworkId == targetId.ConvertLong()) :
|
||||
Utilities.IW4MAdminClient(server);
|
||||
|
||||
return new GameEvent()
|
||||
{
|
||||
Type = GameEvent.EventType.Kill,
|
||||
Data = logLine,
|
||||
Origin = origin,
|
||||
Target = target,
|
||||
Owner = server
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return GenerateDefaultEvent(logLine, gameTime);
|
||||
}
|
||||
if (eventType == "ScriptKill")
|
||||
{
|
||||
long originId = lineSplit[1].ConvertLong();
|
||||
long targetId = lineSplit[2].ConvertLong();
|
||||
|
||||
private static GameEvent GenerateDefaultEvent(string logLine, long gameTime)
|
||||
{
|
||||
return new GameEvent
|
||||
var origin = originId == long.MinValue ? Utilities.IW4MAdminClient(server) :
|
||||
server.GetClientsAsList().First(c => c.NetworkId == originId);
|
||||
var target = targetId == long.MinValue ? Utilities.IW4MAdminClient(server) :
|
||||
server.GetClientsAsList().FirstOrDefault(c => c.NetworkId == targetId) ?? Utilities.IW4MAdminClient(server);
|
||||
|
||||
return new GameEvent()
|
||||
{
|
||||
Type = GameEvent.EventType.ScriptKill,
|
||||
Data = logLine,
|
||||
Origin = origin,
|
||||
Target = target,
|
||||
Owner = server
|
||||
};
|
||||
}
|
||||
|
||||
if (eventType == "ScriptDamage")
|
||||
{
|
||||
long originId = lineSplit[1].ConvertLong();
|
||||
long targetId = lineSplit[2].ConvertLong();
|
||||
|
||||
var origin = originId == long.MinValue ? Utilities.IW4MAdminClient(server) :
|
||||
server.GetClientsAsList().First(c => c.NetworkId == originId);
|
||||
var target = targetId == long.MinValue ? Utilities.IW4MAdminClient(server) :
|
||||
server.GetClientsAsList().FirstOrDefault(c => c.NetworkId == targetId) ?? Utilities.IW4MAdminClient(server);
|
||||
|
||||
return new GameEvent()
|
||||
{
|
||||
Type = GameEvent.EventType.ScriptDamage,
|
||||
Data = logLine,
|
||||
Origin = origin,
|
||||
Target = target,
|
||||
Owner = server
|
||||
};
|
||||
}
|
||||
|
||||
// damage
|
||||
if (eventType == "D")
|
||||
{
|
||||
if (!server.CustomCallback)
|
||||
{
|
||||
var regexMatch = Regex.Match(logLine, Configuration.Damage.Pattern);
|
||||
|
||||
if (regexMatch.Success)
|
||||
{
|
||||
string originId = regexMatch.Groups[Configuration.Damage.GroupMapping[ParserRegex.GroupType.OriginNetworkId]].ToString();
|
||||
string targetId = regexMatch.Groups[Configuration.Damage.GroupMapping[ParserRegex.GroupType.TargetNetworkId]].ToString();
|
||||
|
||||
var origin = !string.IsNullOrEmpty(originId) ? server.GetClientsAsList()
|
||||
.First(c => c.NetworkId == originId.ConvertLong()) :
|
||||
Utilities.IW4MAdminClient(server);
|
||||
|
||||
var target = !string.IsNullOrEmpty(targetId) ? server.GetClientsAsList()
|
||||
.First(c => c.NetworkId == targetId.ConvertLong()) :
|
||||
Utilities.IW4MAdminClient(server);
|
||||
|
||||
return new GameEvent()
|
||||
{
|
||||
Type = GameEvent.EventType.Damage,
|
||||
Data = logLine,
|
||||
Origin = origin,
|
||||
Target = target,
|
||||
Owner = server
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// join
|
||||
if (eventType == "J")
|
||||
{
|
||||
var regexMatch = Regex.Match(logLine, Configuration.Join.Pattern);
|
||||
if (regexMatch.Success)
|
||||
{
|
||||
bool isBot = regexMatch.Groups[Configuration.Join.GroupMapping[ParserRegex.GroupType.OriginNetworkId]].ToString().Contains("bot");
|
||||
|
||||
return new GameEvent()
|
||||
{
|
||||
Type = GameEvent.EventType.PreConnect,
|
||||
Data = logLine,
|
||||
Owner = server,
|
||||
Origin = new EFClient()
|
||||
{
|
||||
CurrentAlias = new EFAlias()
|
||||
{
|
||||
Name = regexMatch.Groups[Configuration.Join.GroupMapping[ParserRegex.GroupType.OriginName]].ToString().StripColors(),
|
||||
},
|
||||
NetworkId = regexMatch.Groups[Configuration.Join.GroupMapping[ParserRegex.GroupType.OriginNetworkId]].ToString().ConvertLong(),
|
||||
ClientNumber = Convert.ToInt32(regexMatch.Groups[Configuration.Join.GroupMapping[ParserRegex.GroupType.OriginClientNumber]].ToString()),
|
||||
State = EFClient.ClientState.Connecting,
|
||||
CurrentServer = server,
|
||||
IsBot = isBot
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
if (eventType == "Q")
|
||||
{
|
||||
var regexMatch = Regex.Match(logLine, Configuration.Quit.Pattern);
|
||||
if (regexMatch.Success)
|
||||
{
|
||||
return new GameEvent()
|
||||
{
|
||||
Type = GameEvent.EventType.PreDisconnect,
|
||||
Data = logLine,
|
||||
Owner = server,
|
||||
Origin = new EFClient()
|
||||
{
|
||||
CurrentAlias = new EFAlias()
|
||||
{
|
||||
Name = regexMatch.Groups[Configuration.Quit.GroupMapping[ParserRegex.GroupType.OriginName]].ToString().StripColors()
|
||||
},
|
||||
NetworkId = regexMatch.Groups[Configuration.Quit.GroupMapping[ParserRegex.GroupType.OriginNetworkId]].ToString().ConvertLong(),
|
||||
ClientNumber = Convert.ToInt32(regexMatch.Groups[Configuration.Quit.GroupMapping[ParserRegex.GroupType.OriginClientNumber]].ToString()),
|
||||
State = EFClient.ClientState.Disconnecting
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
if (eventType.Contains("ExitLevel"))
|
||||
{
|
||||
return new GameEvent()
|
||||
{
|
||||
Type = GameEvent.EventType.MapEnd,
|
||||
Data = lineSplit[0],
|
||||
Origin = Utilities.IW4MAdminClient(server),
|
||||
Target = Utilities.IW4MAdminClient(server),
|
||||
Owner = server
|
||||
};
|
||||
}
|
||||
|
||||
if (eventType.Contains("InitGame"))
|
||||
{
|
||||
string dump = eventType.Replace("InitGame: ", "");
|
||||
|
||||
return new GameEvent()
|
||||
{
|
||||
Type = GameEvent.EventType.MapChange,
|
||||
Data = lineSplit[0],
|
||||
Origin = Utilities.IW4MAdminClient(server),
|
||||
Target = Utilities.IW4MAdminClient(server),
|
||||
Owner = server,
|
||||
Extra = dump.DictionaryFromKeyValue()
|
||||
};
|
||||
}
|
||||
|
||||
return new GameEvent()
|
||||
{
|
||||
Type = GameEvent.EventType.Unknown,
|
||||
Data = logLine,
|
||||
Origin = Utilities.IW4MAdminClient(),
|
||||
Target = Utilities.IW4MAdminClient(),
|
||||
RequiredEntity = GameEvent.EventRequiredEntity.None,
|
||||
GameTime = gameTime,
|
||||
Source = GameEvent.EventSource.Log
|
||||
Origin = Utilities.IW4MAdminClient(server),
|
||||
Target = Utilities.IW4MAdminClient(server),
|
||||
Owner = server
|
||||
};
|
||||
}
|
||||
|
||||
private static GameEvent ParseMatchStartEvent(string logLine, long gameTime)
|
||||
{
|
||||
var dump = logLine.Replace("InitGame: ", "").DictionaryFromKeyValue();
|
||||
|
||||
return new MatchStartEvent
|
||||
{
|
||||
Type = GameEvent.EventType.MapChange,
|
||||
Data = logLine,
|
||||
Origin = Utilities.IW4MAdminClient(),
|
||||
Target = Utilities.IW4MAdminClient(),
|
||||
Extra = dump,
|
||||
RequiredEntity = GameEvent.EventRequiredEntity.None,
|
||||
GameTime = gameTime,
|
||||
Source = GameEvent.EventSource.Log,
|
||||
|
||||
// V2
|
||||
SessionData = dump
|
||||
};
|
||||
}
|
||||
|
||||
private static GameEvent ParseMatchEndEvent(string logLine, long gameTime)
|
||||
{
|
||||
return new MatchEndEvent
|
||||
{
|
||||
Type = GameEvent.EventType.MapEnd,
|
||||
Data = logLine,
|
||||
Origin = Utilities.IW4MAdminClient(),
|
||||
Target = Utilities.IW4MAdminClient(),
|
||||
RequiredEntity = GameEvent.EventRequiredEntity.None,
|
||||
GameTime = gameTime,
|
||||
Source = GameEvent.EventSource.Log,
|
||||
|
||||
// V2
|
||||
SessionData = logLine
|
||||
};
|
||||
}
|
||||
|
||||
private GameEvent ParseClientExitMatchEvent(string logLine, long gameTime)
|
||||
{
|
||||
var match = Configuration.Quit.PatternMatcher.Match(logLine);
|
||||
|
||||
if (!match.Success)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
var originIdString =
|
||||
match.Values[Configuration.Quit.GroupMapping[ParserRegex.GroupType.OriginNetworkId]];
|
||||
var originName = match.Values[Configuration.Quit.GroupMapping[ParserRegex.GroupType.OriginName]]
|
||||
?.TrimNewLine();
|
||||
var originClientNumber =
|
||||
Convert.ToInt32(
|
||||
match.Values[Configuration.Join.GroupMapping[ParserRegex.GroupType.OriginClientNumber]]);
|
||||
|
||||
var networkId = originIdString.IsBotGuid()
|
||||
? originName.GenerateGuidFromString()
|
||||
: originIdString.ConvertGuidToLong(Configuration.GuidNumberStyle);
|
||||
|
||||
return new ClientExitMatchEvent
|
||||
{
|
||||
Type = GameEvent.EventType.PreDisconnect,
|
||||
Data = logLine,
|
||||
Origin = new EFClient
|
||||
{
|
||||
CurrentAlias = new EFAlias
|
||||
{
|
||||
Name = originName
|
||||
},
|
||||
NetworkId = networkId,
|
||||
ClientNumber = originClientNumber,
|
||||
State = EFClient.ClientState.Disconnecting
|
||||
},
|
||||
RequiredEntity = GameEvent.EventRequiredEntity.None,
|
||||
IsBlocking = true,
|
||||
GameTime = gameTime,
|
||||
Source = GameEvent.EventSource.Log,
|
||||
|
||||
// V2
|
||||
ClientName = originName,
|
||||
ClientNetworkId = originIdString,
|
||||
ClientSlotNumber = originClientNumber
|
||||
};
|
||||
}
|
||||
|
||||
private GameEvent ParseJoinTeamEvent(string logLine, long gameTime)
|
||||
{
|
||||
var match = Configuration.JoinTeam.PatternMatcher.Match(logLine);
|
||||
|
||||
if (!match.Success)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
var originIdString =
|
||||
match.Values[Configuration.JoinTeam.GroupMapping[ParserRegex.GroupType.OriginNetworkId]];
|
||||
var originName = match.Values[Configuration.JoinTeam.GroupMapping[ParserRegex.GroupType.OriginName]]
|
||||
?.TrimNewLine();
|
||||
var team = match.Values[Configuration.JoinTeam.GroupMapping[ParserRegex.GroupType.OriginTeam]];
|
||||
var clientSlotNumber =
|
||||
Parse(match.Values[
|
||||
Configuration.JoinTeam.GroupMapping[ParserRegex.GroupType.OriginClientNumber]]);
|
||||
|
||||
if (Configuration.TeamMapping.ContainsKey(team))
|
||||
{
|
||||
team = Configuration.TeamMapping[team].ToString();
|
||||
}
|
||||
|
||||
var networkId = originIdString.IsBotGuid()
|
||||
? originName.GenerateGuidFromString()
|
||||
: originIdString.ConvertGuidToLong(Configuration.GuidNumberStyle);
|
||||
|
||||
return new ClientJoinTeamEvent
|
||||
{
|
||||
Type = GameEvent.EventType.JoinTeam,
|
||||
Data = logLine,
|
||||
Origin = new EFClient
|
||||
{
|
||||
CurrentAlias = new EFAlias
|
||||
{
|
||||
Name = originName
|
||||
},
|
||||
NetworkId = networkId,
|
||||
ClientNumber = clientSlotNumber,
|
||||
State = EFClient.ClientState.Connected,
|
||||
},
|
||||
Extra = team,
|
||||
RequiredEntity = GameEvent.EventRequiredEntity.Origin,
|
||||
GameTime = gameTime,
|
||||
Source = GameEvent.EventSource.Log,
|
||||
|
||||
// V2
|
||||
TeamName = team,
|
||||
ClientName = originName,
|
||||
ClientNetworkId = originIdString,
|
||||
ClientSlotNumber = clientSlotNumber
|
||||
};
|
||||
}
|
||||
|
||||
private GameEvent ParseClientEnterMatchEvent(string logLine, long gameTime)
|
||||
{
|
||||
var match = Configuration.Join.PatternMatcher.Match(logLine);
|
||||
|
||||
if (!match.Success)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
var originIdString = match.Values[Configuration.Join.GroupMapping[ParserRegex.GroupType.OriginNetworkId]];
|
||||
var originName = match.Values[Configuration.Join.GroupMapping[ParserRegex.GroupType.OriginName]]
|
||||
.TrimNewLine();
|
||||
var originClientNumber =
|
||||
Convert.ToInt32(
|
||||
match.Values[Configuration.Join.GroupMapping[ParserRegex.GroupType.OriginClientNumber]]);
|
||||
|
||||
var networkId = originIdString.IsBotGuid()
|
||||
? originName.GenerateGuidFromString()
|
||||
: originIdString.ConvertGuidToLong(Configuration.GuidNumberStyle);
|
||||
|
||||
return new ClientEnterMatchEvent
|
||||
{
|
||||
Type = GameEvent.EventType.PreConnect,
|
||||
Data = logLine,
|
||||
Origin = new EFClient
|
||||
{
|
||||
CurrentAlias = new EFAlias
|
||||
{
|
||||
Name = originName
|
||||
},
|
||||
NetworkId = networkId,
|
||||
ClientNumber = originClientNumber,
|
||||
State = EFClient.ClientState.Connecting,
|
||||
},
|
||||
Extra = originIdString,
|
||||
RequiredEntity = GameEvent.EventRequiredEntity.None,
|
||||
IsBlocking = true,
|
||||
GameTime = gameTime,
|
||||
Source = GameEvent.EventSource.Log,
|
||||
|
||||
// V2
|
||||
ClientName = originName,
|
||||
ClientNetworkId = originIdString,
|
||||
ClientSlotNumber = originClientNumber
|
||||
};
|
||||
}
|
||||
|
||||
#region DAMAGE
|
||||
|
||||
private GameEvent ParseDamageEvent(string logLine, long gameTime)
|
||||
{
|
||||
var match = Configuration.Damage.PatternMatcher.Match(logLine);
|
||||
|
||||
if (!match.Success)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
var originIdString = match.Values[Configuration.Damage.GroupMapping[ParserRegex.GroupType.OriginNetworkId]];
|
||||
var targetIdString = match.Values[Configuration.Damage.GroupMapping[ParserRegex.GroupType.TargetNetworkId]];
|
||||
|
||||
var originName = match.Values[Configuration.Damage.GroupMapping[ParserRegex.GroupType.OriginName]]
|
||||
?.TrimNewLine();
|
||||
var targetName = match.Values[Configuration.Damage.GroupMapping[ParserRegex.GroupType.TargetName]]
|
||||
?.TrimNewLine();
|
||||
|
||||
var originId = originIdString.IsBotGuid()
|
||||
? originName.GenerateGuidFromString()
|
||||
: originIdString.ConvertGuidToLong(Configuration.GuidNumberStyle, Utilities.WORLD_ID);
|
||||
var targetId = targetIdString.IsBotGuid()
|
||||
? targetName.GenerateGuidFromString()
|
||||
: targetIdString.ConvertGuidToLong(Configuration.GuidNumberStyle, Utilities.WORLD_ID);
|
||||
|
||||
var originClientNumber =
|
||||
Parse(match.Values[Configuration.Damage.GroupMapping[ParserRegex.GroupType.OriginClientNumber]]);
|
||||
var targetClientNumber =
|
||||
Parse(match.Values[Configuration.Damage.GroupMapping[ParserRegex.GroupType.TargetClientNumber]]);
|
||||
|
||||
var originTeamName =
|
||||
match.Values[Configuration.Damage.GroupMapping[ParserRegex.GroupType.OriginTeam]];
|
||||
var targetTeamName =
|
||||
match.Values[Configuration.Damage.GroupMapping[ParserRegex.GroupType.TargetTeam]];
|
||||
|
||||
if (Configuration.TeamMapping.ContainsKey(originTeamName))
|
||||
{
|
||||
originTeamName = Configuration.TeamMapping[originTeamName].ToString();
|
||||
}
|
||||
|
||||
if (Configuration.TeamMapping.ContainsKey(targetTeamName))
|
||||
{
|
||||
targetTeamName = Configuration.TeamMapping[targetTeamName].ToString();
|
||||
}
|
||||
|
||||
var weaponName = match.Values[Configuration.Damage.GroupMapping[ParserRegex.GroupType.Weapon]];
|
||||
TryParse(match.Values[Configuration.Damage.GroupMapping[ParserRegex.GroupType.Damage]],
|
||||
out var damage);
|
||||
var meansOfDeath =
|
||||
match.Values[Configuration.Damage.GroupMapping[ParserRegex.GroupType.MeansOfDeath]];
|
||||
var hitLocation =
|
||||
match.Values[Configuration.Damage.GroupMapping[ParserRegex.GroupType.HitLocation]];
|
||||
|
||||
return new ClientDamageEvent
|
||||
{
|
||||
Type = GameEvent.EventType.Damage,
|
||||
Data = logLine,
|
||||
Origin = new EFClient { NetworkId = originId, ClientNumber = originClientNumber },
|
||||
Target = new EFClient { NetworkId = targetId, ClientNumber = targetClientNumber },
|
||||
RequiredEntity = GameEvent.EventRequiredEntity.Origin | GameEvent.EventRequiredEntity.Target,
|
||||
GameTime = gameTime,
|
||||
Source = GameEvent.EventSource.Log,
|
||||
|
||||
// V2
|
||||
ClientName = originName,
|
||||
ClientNetworkId = originIdString,
|
||||
ClientSlotNumber = originClientNumber,
|
||||
AttackerTeamName = originTeamName,
|
||||
VictimClientName = targetName,
|
||||
VictimNetworkId = targetIdString,
|
||||
VictimClientSlotNumber = targetClientNumber,
|
||||
VictimTeamName = targetTeamName,
|
||||
WeaponName = weaponName,
|
||||
Damage = damage,
|
||||
MeansOfDeath = meansOfDeath,
|
||||
HitLocation = hitLocation
|
||||
};
|
||||
}
|
||||
|
||||
private GameEvent ParseKillEvent(string logLine, long gameTime)
|
||||
{
|
||||
var match = Configuration.Kill.PatternMatcher.Match(logLine);
|
||||
|
||||
if (!match.Success)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
var originIdString = match.Values[Configuration.Kill.GroupMapping[ParserRegex.GroupType.OriginNetworkId]];
|
||||
var targetIdString = match.Values[Configuration.Kill.GroupMapping[ParserRegex.GroupType.TargetNetworkId]];
|
||||
|
||||
var originName = match.Values[Configuration.Kill.GroupMapping[ParserRegex.GroupType.OriginName]]
|
||||
?.TrimNewLine();
|
||||
var targetName = match.Values[Configuration.Kill.GroupMapping[ParserRegex.GroupType.TargetName]]
|
||||
?.TrimNewLine();
|
||||
|
||||
var originId = originIdString.IsBotGuid()
|
||||
? originName.GenerateGuidFromString()
|
||||
: originIdString.ConvertGuidToLong(Configuration.GuidNumberStyle, Utilities.WORLD_ID);
|
||||
var targetId = targetIdString.IsBotGuid()
|
||||
? targetName.GenerateGuidFromString()
|
||||
: targetIdString.ConvertGuidToLong(Configuration.GuidNumberStyle, Utilities.WORLD_ID);
|
||||
|
||||
var originClientNumber =
|
||||
Parse(match.Values[Configuration.Kill.GroupMapping[ParserRegex.GroupType.OriginClientNumber]]);
|
||||
var targetClientNumber =
|
||||
Parse(match.Values[Configuration.Kill.GroupMapping[ParserRegex.GroupType.TargetClientNumber]]);
|
||||
|
||||
var originTeamName =
|
||||
match.Values[Configuration.Kill.GroupMapping[ParserRegex.GroupType.OriginTeam]];
|
||||
var targetTeamName =
|
||||
match.Values[Configuration.Kill.GroupMapping[ParserRegex.GroupType.TargetTeam]];
|
||||
|
||||
if (Configuration.TeamMapping.ContainsKey(originTeamName))
|
||||
{
|
||||
originTeamName = Configuration.TeamMapping[originTeamName].ToString();
|
||||
}
|
||||
|
||||
if (Configuration.TeamMapping.ContainsKey(targetTeamName))
|
||||
{
|
||||
targetTeamName = Configuration.TeamMapping[targetTeamName].ToString();
|
||||
}
|
||||
|
||||
var weaponName = match.Values[Configuration.Kill.GroupMapping[ParserRegex.GroupType.Weapon]];
|
||||
TryParse(match.Values[Configuration.Kill.GroupMapping[ParserRegex.GroupType.Damage]],
|
||||
out var damage);
|
||||
var meansOfDeath =
|
||||
match.Values[Configuration.Kill.GroupMapping[ParserRegex.GroupType.MeansOfDeath]];
|
||||
var hitLocation =
|
||||
match.Values[Configuration.Kill.GroupMapping[ParserRegex.GroupType.HitLocation]];
|
||||
|
||||
return new ClientKillEvent
|
||||
{
|
||||
Type = GameEvent.EventType.Kill,
|
||||
Data = logLine,
|
||||
Origin = new EFClient { NetworkId = originId, ClientNumber = originClientNumber },
|
||||
Target = new EFClient { NetworkId = targetId, ClientNumber = targetClientNumber },
|
||||
RequiredEntity = GameEvent.EventRequiredEntity.Origin | GameEvent.EventRequiredEntity.Target,
|
||||
GameTime = gameTime,
|
||||
Source = GameEvent.EventSource.Log,
|
||||
|
||||
// V2
|
||||
ClientName = originName,
|
||||
ClientNetworkId = originIdString,
|
||||
ClientSlotNumber = originClientNumber,
|
||||
AttackerTeamName = originTeamName,
|
||||
VictimClientName = targetName,
|
||||
VictimNetworkId = targetIdString,
|
||||
VictimClientSlotNumber = targetClientNumber,
|
||||
VictimTeamName = targetTeamName,
|
||||
WeaponName = weaponName,
|
||||
Damage = damage,
|
||||
MeansOfDeath = meansOfDeath,
|
||||
HitLocation = hitLocation
|
||||
};
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region MESSAGE
|
||||
|
||||
private GameEvent ParseMessageEvent(string logLine, long gameTime, GameEvent.EventType eventType)
|
||||
{
|
||||
var matchResult = Configuration.Say.PatternMatcher.Match(logLine);
|
||||
|
||||
if (!matchResult.Success)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
var message = new string(matchResult.Values[Configuration.Say.GroupMapping[ParserRegex.GroupType.Message]]
|
||||
.Where(c => !char.IsControl(c)).ToArray());
|
||||
|
||||
if (message.StartsWith("/"))
|
||||
{
|
||||
message = message[1..];
|
||||
}
|
||||
|
||||
if (String.IsNullOrEmpty(message))
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
var originIdString =
|
||||
matchResult.Values[Configuration.Say.GroupMapping[ParserRegex.GroupType.OriginNetworkId]];
|
||||
var originName = matchResult.Values[Configuration.Say.GroupMapping[ParserRegex.GroupType.OriginName]]
|
||||
?.TrimNewLine();
|
||||
var clientNumber =
|
||||
Parse(matchResult.Values[Configuration.Say.GroupMapping[ParserRegex.GroupType.OriginClientNumber]]);
|
||||
|
||||
var originId = originIdString.IsBotGuid()
|
||||
? originName.GenerateGuidFromString()
|
||||
: originIdString.ConvertGuidToLong(Configuration.GuidNumberStyle);
|
||||
|
||||
|
||||
if (message.StartsWith(_appConfig.CommandPrefix) || message.StartsWith(_appConfig.BroadcastCommandPrefix))
|
||||
{
|
||||
return new ClientCommandEvent
|
||||
{
|
||||
Type = GameEvent.EventType.Command,
|
||||
Data = message,
|
||||
Origin = new EFClient { NetworkId = originId, ClientNumber = clientNumber },
|
||||
Message = message,
|
||||
Extra = logLine,
|
||||
RequiredEntity = GameEvent.EventRequiredEntity.Origin,
|
||||
GameTime = gameTime,
|
||||
Source = GameEvent.EventSource.Log,
|
||||
|
||||
//V2
|
||||
ClientName = originName,
|
||||
ClientNetworkId = originIdString,
|
||||
ClientSlotNumber = clientNumber,
|
||||
IsTeamMessage = eventType == GameEvent.EventType.SayTeam
|
||||
};
|
||||
}
|
||||
|
||||
return new ClientMessageEvent
|
||||
{
|
||||
Type = GameEvent.EventType.Say,
|
||||
Data = message,
|
||||
Origin = new EFClient { NetworkId = originId, ClientNumber = clientNumber },
|
||||
Message = message,
|
||||
Extra = logLine,
|
||||
RequiredEntity = GameEvent.EventRequiredEntity.Origin,
|
||||
GameTime = gameTime,
|
||||
Source = GameEvent.EventSource.Log,
|
||||
|
||||
//V2
|
||||
ClientName = originName,
|
||||
ClientNetworkId = originIdString,
|
||||
ClientSlotNumber = clientNumber,
|
||||
IsTeamMessage = eventType == GameEvent.EventType.SayTeam
|
||||
};
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
private (GameEvent.EventType type, string eventKey) GetEventTypeFromLine(string logLine)
|
||||
{
|
||||
var lineSplit = logLine.Split(';');
|
||||
if (lineSplit.Length > 1)
|
||||
{
|
||||
var type = lineSplit[0];
|
||||
return _eventTypeMap.ContainsKey(type)
|
||||
? (_eventTypeMap[type], type)
|
||||
: (GameEvent.EventType.Unknown, lineSplit[0]);
|
||||
}
|
||||
|
||||
foreach (var (key, value) in _regexMap)
|
||||
{
|
||||
var result = key.PatternMatcher.Match(logLine);
|
||||
if (result.Success)
|
||||
{
|
||||
return (value, null);
|
||||
}
|
||||
}
|
||||
|
||||
return (GameEvent.EventType.Unknown, null);
|
||||
}
|
||||
|
||||
/// <inheritdoc/>
|
||||
public void RegisterCustomEvent(string eventSubtype, string eventTriggerValue,
|
||||
Func<string, IEventParserConfiguration, GameEvent, GameEvent> eventModifier)
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(eventSubtype))
|
||||
{
|
||||
throw new ArgumentException("Event subtype cannot be empty");
|
||||
}
|
||||
|
||||
if (string.IsNullOrWhiteSpace(eventTriggerValue))
|
||||
{
|
||||
throw new ArgumentException("Event trigger value cannot be empty");
|
||||
}
|
||||
|
||||
if (eventModifier == null)
|
||||
{
|
||||
throw new ArgumentException("Event modifier must be specified");
|
||||
}
|
||||
|
||||
if (_customEventRegistrations.ContainsKey(eventTriggerValue))
|
||||
{
|
||||
throw new ArgumentException($"Event trigger value '{eventTriggerValue}' is already registered");
|
||||
}
|
||||
|
||||
_customEventRegistrations.Add(eventTriggerValue, (eventSubtype, eventModifier));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,6 +1,7 @@
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Text;
|
||||
using static SharedLibraryCore.Server;
|
||||
|
||||
namespace IW4MAdmin.Application.EventParsers
|
||||
{
|
||||
@ -10,8 +11,5 @@ namespace IW4MAdmin.Application.EventParsers
|
||||
/// </summary>
|
||||
sealed internal class DynamicEventParser : BaseEventParser
|
||||
{
|
||||
public DynamicEventParser(IParserRegexFactory parserRegexFactory, ILogger logger, ApplicationConfiguration appConfig) : base(parserRegexFactory, logger, appConfig)
|
||||
{
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,8 +1,4 @@
|
||||
using System.Collections.Generic;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using System.Globalization;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Database.Models;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.EventParsers
|
||||
{
|
||||
@ -10,36 +6,14 @@ namespace IW4MAdmin.Application.EventParsers
|
||||
/// generic implementation of the IEventParserConfiguration
|
||||
/// allows script plugins to generate dynamic configurations
|
||||
/// </summary>
|
||||
internal sealed class DynamicEventParserConfiguration : IEventParserConfiguration
|
||||
sealed internal class DynamicEventParserConfiguration : IEventParserConfiguration
|
||||
{
|
||||
public string GameDirectory { get; set; }
|
||||
public ParserRegex Say { get; set; }
|
||||
public string LocalizeText { get; set; }
|
||||
public ParserRegex Join { get; set; }
|
||||
public ParserRegex JoinTeam { get; set; }
|
||||
public ParserRegex Quit { get; set; }
|
||||
public ParserRegex Kill { get; set; }
|
||||
public ParserRegex Damage { get; set; }
|
||||
public ParserRegex Action { get; set; }
|
||||
public ParserRegex Time { get; set; }
|
||||
public ParserRegex MapChange { get; set; }
|
||||
public ParserRegex MapEnd { get; set; }
|
||||
public NumberStyles GuidNumberStyle { get; set; } = NumberStyles.HexNumber;
|
||||
|
||||
public Dictionary<string, EFClient.TeamType> TeamMapping { get; set; } = new();
|
||||
|
||||
public DynamicEventParserConfiguration(IParserRegexFactory parserRegexFactory)
|
||||
{
|
||||
Say = parserRegexFactory.CreateParserRegex();
|
||||
Join = parserRegexFactory.CreateParserRegex();
|
||||
JoinTeam = parserRegexFactory.CreateParserRegex();
|
||||
Quit = parserRegexFactory.CreateParserRegex();
|
||||
Kill = parserRegexFactory.CreateParserRegex();
|
||||
Damage = parserRegexFactory.CreateParserRegex();
|
||||
Action = parserRegexFactory.CreateParserRegex();
|
||||
Time = parserRegexFactory.CreateParserRegex();
|
||||
MapChange = parserRegexFactory.CreateParserRegex();
|
||||
MapEnd = parserRegexFactory.CreateParserRegex();
|
||||
}
|
||||
public ParserRegex Say { get; set; } = new ParserRegex();
|
||||
public ParserRegex Join { get; set; } = new ParserRegex();
|
||||
public ParserRegex Quit { get; set; } = new ParserRegex();
|
||||
public ParserRegex Kill { get; set; } = new ParserRegex();
|
||||
public ParserRegex Damage { get; set; } = new ParserRegex();
|
||||
public ParserRegex Action { get; set; } = new ParserRegex();
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,35 +0,0 @@
|
||||
using IW4MAdmin.Application.Misc;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Text.RegularExpressions;
|
||||
|
||||
namespace IW4MAdmin.Application.EventParsers
|
||||
{
|
||||
/// <summary>
|
||||
/// implementation of the IParserPatternMatcher for windows (really it's the only implementation)
|
||||
/// </summary>
|
||||
public class ParserPatternMatcher : IParserPatternMatcher
|
||||
{
|
||||
private Regex regex;
|
||||
|
||||
/// <inheritdoc/>
|
||||
public void Compile(string pattern)
|
||||
{
|
||||
regex = new Regex(pattern, RegexOptions.Compiled | RegexOptions.IgnoreCase);
|
||||
}
|
||||
|
||||
/// <inheritdoc/>
|
||||
public IMatchResult Match(string input)
|
||||
{
|
||||
var match = regex.Match(input);
|
||||
|
||||
return new ParserMatchResult()
|
||||
{
|
||||
Success = match.Success,
|
||||
Values = (match.Groups as IEnumerable<object>)?
|
||||
.Select(_item => _item.ToString()).ToArray() ?? new string[0]
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,35 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using System.Linq;
|
||||
using IW4MAdmin.Application.Plugin.Script;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Configuration;
|
||||
|
||||
namespace IW4MAdmin.Application.Extensions
|
||||
{
|
||||
public static class CommandExtensions
|
||||
{
|
||||
/// <summary>
|
||||
/// determines the command configuration name for given manager command
|
||||
/// </summary>
|
||||
/// <param name="command">command to determine config name for</param>
|
||||
/// <returns></returns>
|
||||
public static string CommandConfigNameForType(this IManagerCommand command)
|
||||
{
|
||||
return command.GetType() == typeof(ScriptCommand)
|
||||
? $"{char.ToUpper(command.Name[0])}{command.Name.Substring(1)}Command"
|
||||
: command.GetType().Name;
|
||||
}
|
||||
|
||||
public static IList<Map> FindMap(this Server server, string mapName) => server.Maps.Where(map =>
|
||||
map.Name.Equals(mapName, StringComparison.InvariantCultureIgnoreCase) ||
|
||||
map.Alias.Equals(mapName, StringComparison.InvariantCultureIgnoreCase)).ToList();
|
||||
|
||||
public static IList<Gametype> FindGametype(this DefaultSettings settings, string gameType, Server.Game? game = null) =>
|
||||
settings.Gametypes?.Where(gt => game == null || gt.Game == game)
|
||||
.SelectMany(gt => gt.Gametypes).Where(gt =>
|
||||
gt.Alias.Contains(gameType, StringComparison.CurrentCultureIgnoreCase) ||
|
||||
gt.Name.Contains(gameType, StringComparison.CurrentCultureIgnoreCase)).ToList();
|
||||
}
|
||||
}
|
||||
@ -1,28 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using Data.Models.Client.Stats;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
|
||||
namespace IW4MAdmin.Application.Extensions;
|
||||
|
||||
public static class ScriptPluginExtensions
|
||||
{
|
||||
public static IEnumerable<object> GetClientsBasicData(
|
||||
this DbSet<Data.Models.Client.EFClient> set, int[] clientIds)
|
||||
{
|
||||
return set.Where(client => clientIds.Contains(client.ClientId))
|
||||
.Select(client => new
|
||||
{
|
||||
client.ClientId,
|
||||
client.CurrentAlias,
|
||||
client.Level,
|
||||
client.NetworkId
|
||||
}).ToList();
|
||||
}
|
||||
|
||||
public static IEnumerable<object> GetClientsStatData(this DbSet<EFClientStatistics> set, int[] clientIds,
|
||||
double serverId)
|
||||
{
|
||||
return set.Where(stat => clientIds.Contains(stat.ClientId) && stat.ServerId == (long)serverId).ToList();
|
||||
}
|
||||
}
|
||||
@ -1,126 +0,0 @@
|
||||
using System;
|
||||
using System.IO;
|
||||
using System.Runtime.InteropServices;
|
||||
using Data.MigrationContext;
|
||||
using Microsoft.Data.Sqlite;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Microsoft.Extensions.Configuration;
|
||||
using Microsoft.Extensions.DependencyInjection;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using Serilog;
|
||||
using Serilog.Core;
|
||||
using Serilog.Events;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using ILogger = Serilog.ILogger;
|
||||
|
||||
namespace IW4MAdmin.Application.Extensions
|
||||
{
|
||||
public static class StartupExtensions
|
||||
{
|
||||
private static ILogger _defaultLogger;
|
||||
private static readonly LoggingLevelSwitch LevelSwitch = new();
|
||||
private static readonly LoggingLevelSwitch MicrosoftLevelSwitch = new();
|
||||
private static readonly LoggingLevelSwitch SystemLevelSwitch = new();
|
||||
|
||||
public static IServiceCollection AddBaseLogger(this IServiceCollection services,
|
||||
ApplicationConfiguration appConfig)
|
||||
{
|
||||
if (_defaultLogger == null)
|
||||
{
|
||||
var configuration = new ConfigurationBuilder()
|
||||
.AddJsonFile(Path.Join(Utilities.OperatingDirectory, "Configuration", "LoggingConfiguration.json"))
|
||||
.Build();
|
||||
|
||||
var loggerConfig = new LoggerConfiguration()
|
||||
.ReadFrom.Configuration(configuration);
|
||||
|
||||
LevelSwitch.MinimumLevel = Enum.Parse<LogEventLevel>(configuration["Serilog:MinimumLevel:Default"]);
|
||||
MicrosoftLevelSwitch.MinimumLevel = Enum.Parse<LogEventLevel>(configuration["Serilog:MinimumLevel:Override:Microsoft"]);
|
||||
SystemLevelSwitch.MinimumLevel = Enum.Parse<LogEventLevel>(configuration["Serilog:MinimumLevel:Override:System"]);
|
||||
|
||||
loggerConfig = loggerConfig.MinimumLevel.ControlledBy(LevelSwitch);
|
||||
loggerConfig = loggerConfig.MinimumLevel.Override("Microsoft", MicrosoftLevelSwitch)
|
||||
.MinimumLevel.Override("System", SystemLevelSwitch);
|
||||
|
||||
if (Utilities.IsDevelopment)
|
||||
{
|
||||
loggerConfig = loggerConfig.WriteTo.Console(
|
||||
outputTemplate:
|
||||
"[{Timestamp:HH:mm:ss} {Server} {Level:u3}] {Message:lj}{NewLine}{Exception}")
|
||||
.MinimumLevel.Override("Microsoft", LogEventLevel.Information)
|
||||
.MinimumLevel.Debug();
|
||||
}
|
||||
|
||||
_defaultLogger = loggerConfig.CreateLogger();
|
||||
}
|
||||
|
||||
services.AddSingleton((string context) =>
|
||||
{
|
||||
return context.ToLower() switch
|
||||
{
|
||||
"microsoft" => MicrosoftLevelSwitch,
|
||||
"system" => SystemLevelSwitch,
|
||||
_ => LevelSwitch
|
||||
};
|
||||
});
|
||||
services.AddLogging(builder => builder.AddSerilog(_defaultLogger, dispose: true));
|
||||
services.AddSingleton(new LoggerFactory()
|
||||
.AddSerilog(_defaultLogger, true));
|
||||
return services;
|
||||
}
|
||||
|
||||
public static IServiceCollection AddDatabaseContextOptions(this IServiceCollection services,
|
||||
ApplicationConfiguration appConfig)
|
||||
{
|
||||
var activeProvider = appConfig.DatabaseProvider?.ToLower();
|
||||
|
||||
if (string.IsNullOrEmpty(appConfig.ConnectionString) || activeProvider == "sqlite")
|
||||
{
|
||||
var currentPath = Utilities.OperatingDirectory;
|
||||
currentPath = !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
|
||||
? $"{Path.DirectorySeparatorChar}{currentPath}"
|
||||
: currentPath;
|
||||
|
||||
var connectionStringBuilder = new SqliteConnectionStringBuilder
|
||||
{DataSource = Path.Join(currentPath, "Database", "Database.db")};
|
||||
var connectionString = connectionStringBuilder.ToString();
|
||||
|
||||
services.AddSingleton(sp => (DbContextOptions) new DbContextOptionsBuilder<SqliteDatabaseContext>()
|
||||
.UseSqlite(connectionString)
|
||||
.UseLoggerFactory(sp.GetRequiredService<ILoggerFactory>())
|
||||
.EnableSensitiveDataLogging().Options);
|
||||
return services;
|
||||
}
|
||||
|
||||
switch (activeProvider)
|
||||
{
|
||||
case "mysql":
|
||||
var appendTimeout = !appConfig.ConnectionString.Contains("default command timeout",
|
||||
StringComparison.InvariantCultureIgnoreCase);
|
||||
var connectionString =
|
||||
appConfig.ConnectionString + (appendTimeout ? ";default command timeout=0" : "");
|
||||
services.AddSingleton(sp => (DbContextOptions) new DbContextOptionsBuilder<MySqlDatabaseContext>()
|
||||
.UseMySql(connectionString, ServerVersion.AutoDetect(connectionString),
|
||||
mysqlOptions => mysqlOptions.EnableRetryOnFailure())
|
||||
.UseLoggerFactory(sp.GetRequiredService<ILoggerFactory>()).Options);
|
||||
return services;
|
||||
case "postgresql":
|
||||
appendTimeout = !appConfig.ConnectionString.Contains("Command Timeout",
|
||||
StringComparison.InvariantCultureIgnoreCase);
|
||||
services.AddSingleton(sp =>
|
||||
(DbContextOptions) new DbContextOptionsBuilder<PostgresqlDatabaseContext>()
|
||||
.UseNpgsql(appConfig.ConnectionString + (appendTimeout ? ";Command Timeout=0" : ""),
|
||||
postgresqlOptions =>
|
||||
{
|
||||
postgresqlOptions.EnableRetryOnFailure();
|
||||
postgresqlOptions.SetPostgresVersion(new Version("12.9"));
|
||||
})
|
||||
.UseLoggerFactory(sp.GetRequiredService<ILoggerFactory>()).Options);
|
||||
return services;
|
||||
default:
|
||||
throw new ArgumentException($"No context available for {appConfig.DatabaseProvider}");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,34 +0,0 @@
|
||||
using System.Threading.Tasks;
|
||||
using IW4MAdmin.Application.Misc;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Factories
|
||||
{
|
||||
/// <summary>
|
||||
/// implementation of IConfigurationHandlerFactory
|
||||
/// provides base functionality to create configuration handlers
|
||||
/// </summary>
|
||||
public class ConfigurationHandlerFactory : IConfigurationHandlerFactory
|
||||
{
|
||||
/// <summary>
|
||||
/// creates a base configuration handler
|
||||
/// </summary>
|
||||
/// <typeparam name="T">base configuration type</typeparam>
|
||||
/// <param name="name">name of the config file</param>
|
||||
/// <returns></returns>
|
||||
public IConfigurationHandler<T> GetConfigurationHandler<T>(string name) where T : IBaseConfiguration
|
||||
{
|
||||
var handler = new BaseConfigurationHandler<T>(name);
|
||||
handler.BuildAsync().Wait();
|
||||
return handler;
|
||||
}
|
||||
|
||||
/// <inheritdoc/>
|
||||
public async Task<IConfigurationHandler<T>> GetConfigurationHandlerAsync<T>(string name) where T : IBaseConfiguration
|
||||
{
|
||||
var handler = new BaseConfigurationHandler<T>(name);
|
||||
await handler.BuildAsync();
|
||||
return handler;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,62 +0,0 @@
|
||||
using System;
|
||||
using Data.Abstractions;
|
||||
using Data.Context;
|
||||
using Data.MigrationContext;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using SharedLibraryCore.Configuration;
|
||||
|
||||
namespace IW4MAdmin.Application.Factories
|
||||
{
|
||||
/// <summary>
|
||||
/// implementation of the IDatabaseContextFactory interface
|
||||
/// </summary>
|
||||
public class DatabaseContextFactory : IDatabaseContextFactory
|
||||
{
|
||||
private readonly DbContextOptions _contextOptions;
|
||||
private readonly string _activeProvider;
|
||||
|
||||
public DatabaseContextFactory(ApplicationConfiguration appConfig, DbContextOptions contextOptions)
|
||||
{
|
||||
_contextOptions = contextOptions;
|
||||
_activeProvider = appConfig.DatabaseProvider?.ToLower();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// creates a new database context
|
||||
/// </summary>
|
||||
/// <param name="enableTracking">indicates if entity tracking should be enabled</param>
|
||||
/// <returns></returns>
|
||||
public DatabaseContext CreateContext(bool? enableTracking = true)
|
||||
{
|
||||
var context = BuildContext();
|
||||
|
||||
enableTracking ??= true;
|
||||
|
||||
if (enableTracking.Value)
|
||||
{
|
||||
context.ChangeTracker.AutoDetectChangesEnabled = true;
|
||||
context.ChangeTracker.LazyLoadingEnabled = true;
|
||||
context.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.TrackAll;
|
||||
}
|
||||
else
|
||||
{
|
||||
context.ChangeTracker.AutoDetectChangesEnabled = false;
|
||||
context.ChangeTracker.LazyLoadingEnabled = false;
|
||||
context.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;
|
||||
}
|
||||
|
||||
return context;
|
||||
}
|
||||
|
||||
private DatabaseContext BuildContext()
|
||||
{
|
||||
return _activeProvider switch
|
||||
{
|
||||
"sqlite" => new SqliteDatabaseContext(_contextOptions),
|
||||
"mysql" => new MySqlDatabaseContext(_contextOptions),
|
||||
"postgresql" => new PostgresqlDatabaseContext(_contextOptions),
|
||||
_ => throw new ArgumentException($"No context found for {_activeProvider}")
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,42 +0,0 @@
|
||||
using IW4MAdmin.Application.IO;
|
||||
using Microsoft.Extensions.DependencyInjection;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using System;
|
||||
using Microsoft.Extensions.Logging;
|
||||
|
||||
namespace IW4MAdmin.Application.Factories
|
||||
{
|
||||
public class GameLogReaderFactory : IGameLogReaderFactory
|
||||
{
|
||||
private readonly IServiceProvider _serviceProvider;
|
||||
|
||||
public GameLogReaderFactory(IServiceProvider serviceProvider)
|
||||
{
|
||||
_serviceProvider = serviceProvider;
|
||||
}
|
||||
|
||||
public IGameLogReader CreateGameLogReader(Uri[] logUris, IEventParser eventParser)
|
||||
{
|
||||
var baseUri = logUris[0];
|
||||
if (baseUri.Scheme == Uri.UriSchemeHttp || baseUri.Scheme == Uri.UriSchemeHttps)
|
||||
{
|
||||
return new GameLogReaderHttp(logUris, eventParser,
|
||||
_serviceProvider.GetRequiredService<ILogger<GameLogReaderHttp>>());
|
||||
}
|
||||
|
||||
if (baseUri.Scheme == Uri.UriSchemeFile)
|
||||
{
|
||||
return new GameLogReader(baseUri.LocalPath, eventParser,
|
||||
_serviceProvider.GetRequiredService<ILogger<GameLogReader>>());
|
||||
}
|
||||
|
||||
if (baseUri.Scheme == Uri.UriSchemeNetTcp)
|
||||
{
|
||||
return new NetworkGameLogReader(logUris, eventParser,
|
||||
_serviceProvider.GetRequiredService<ILogger<NetworkGameLogReader>>());
|
||||
}
|
||||
|
||||
throw new NotImplementedException($"No log reader implemented for Uri scheme \"{baseUri.Scheme}\"");
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,48 +0,0 @@
|
||||
using System;
|
||||
using Data.Abstractions;
|
||||
using Data.Models.Server;
|
||||
using Microsoft.Extensions.DependencyInjection;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Factories
|
||||
{
|
||||
/// <summary>
|
||||
/// implementation of IGameServerInstanceFactory
|
||||
/// </summary>
|
||||
internal class GameServerInstanceFactory : IGameServerInstanceFactory
|
||||
{
|
||||
private readonly ITranslationLookup _translationLookup;
|
||||
private readonly IMetaServiceV2 _metaService;
|
||||
private readonly IServiceProvider _serviceProvider;
|
||||
|
||||
/// <summary>
|
||||
/// base constructor
|
||||
/// </summary>
|
||||
/// <param name="translationLookup"></param>
|
||||
/// <param name="rconConnectionFactory"></param>
|
||||
public GameServerInstanceFactory(ITranslationLookup translationLookup,
|
||||
IMetaServiceV2 metaService,
|
||||
IServiceProvider serviceProvider)
|
||||
{
|
||||
_translationLookup = translationLookup;
|
||||
_metaService = metaService;
|
||||
_serviceProvider = serviceProvider;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// creates an IW4MServer instance
|
||||
/// </summary>
|
||||
/// <param name="config">server configuration</param>
|
||||
/// <param name="manager">application manager</param>
|
||||
/// <returns></returns>
|
||||
public Server CreateServer(ServerConfiguration config, IManager manager)
|
||||
{
|
||||
return new IW4MServer(config,
|
||||
_serviceProvider.GetRequiredService<CommandConfiguration>(), _translationLookup, _metaService,
|
||||
_serviceProvider, _serviceProvider.GetRequiredService<IClientNoticeMessageFormatter>(),
|
||||
_serviceProvider.GetRequiredService<ILookupCache<EFServer>>());
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,26 +0,0 @@
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using Microsoft.Extensions.DependencyInjection;
|
||||
using System;
|
||||
|
||||
namespace IW4MAdmin.Application.Factories
|
||||
{
|
||||
/// <summary>
|
||||
/// Implementation of the IParserRegexFactory
|
||||
/// </summary>
|
||||
public class ParserRegexFactory : IParserRegexFactory
|
||||
{
|
||||
private readonly IServiceProvider _serviceProvider;
|
||||
|
||||
/// <inheritdoc/>
|
||||
public ParserRegexFactory(IServiceProvider serviceProvider)
|
||||
{
|
||||
_serviceProvider = serviceProvider;
|
||||
}
|
||||
|
||||
/// <inheritdoc/>
|
||||
public ParserRegex CreateParserRegex()
|
||||
{
|
||||
return new ParserRegex(_serviceProvider.GetService<IParserPatternMatcher>());
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,46 +0,0 @@
|
||||
using System;
|
||||
using System.Net;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using System.Text;
|
||||
using Integrations.Cod;
|
||||
using Integrations.Source;
|
||||
using Integrations.Source.Interfaces;
|
||||
using Microsoft.Extensions.DependencyInjection;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SharedLibraryCore.Configuration;
|
||||
|
||||
namespace IW4MAdmin.Application.Factories
|
||||
{
|
||||
/// <summary>
|
||||
/// implementation of IRConConnectionFactory
|
||||
/// </summary>
|
||||
internal class RConConnectionFactory : IRConConnectionFactory
|
||||
{
|
||||
private static readonly Encoding GameEncoding = Encoding.GetEncoding("windows-1252");
|
||||
private readonly IServiceProvider _serviceProvider;
|
||||
|
||||
/// <summary>
|
||||
/// Base constructor
|
||||
/// </summary>
|
||||
/// <param name="logger"></param>
|
||||
public RConConnectionFactory(IServiceProvider serviceProvider)
|
||||
{
|
||||
_serviceProvider = serviceProvider;
|
||||
}
|
||||
|
||||
/// <inheritdoc/>
|
||||
public IRConConnection CreateConnection(IPEndPoint ipEndpoint, string password, string rconEngine)
|
||||
{
|
||||
return rconEngine switch
|
||||
{
|
||||
"COD" => new CodRConConnection(ipEndpoint, password,
|
||||
_serviceProvider.GetRequiredService<ILogger<CodRConConnection>>(), GameEncoding,
|
||||
_serviceProvider.GetRequiredService<ApplicationConfiguration>()?.ServerConnectionAttempts ?? 6),
|
||||
"Source" => new SourceRConConnection(
|
||||
_serviceProvider.GetRequiredService<ILogger<SourceRConConnection>>(),
|
||||
_serviceProvider.GetRequiredService<IRConClientFactory>(), ipEndpoint, password),
|
||||
_ => throw new ArgumentException($"No supported RCon engine available for '{rconEngine}'")
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,42 +0,0 @@
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Commands;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Models;
|
||||
using Data.Models.Client;
|
||||
using IW4MAdmin.Application.Plugin.Script;
|
||||
using Microsoft.Extensions.DependencyInjection;
|
||||
using Microsoft.Extensions.Logging;
|
||||
|
||||
namespace IW4MAdmin.Application.Factories
|
||||
{
|
||||
/// <summary>
|
||||
/// implementation of IScriptCommandFactory
|
||||
/// </summary>
|
||||
public class ScriptCommandFactory : IScriptCommandFactory
|
||||
{
|
||||
private readonly CommandConfiguration _config;
|
||||
private readonly ITranslationLookup _transLookup;
|
||||
private readonly IServiceProvider _serviceProvider;
|
||||
|
||||
public ScriptCommandFactory(CommandConfiguration config, ITranslationLookup transLookup, IServiceProvider serviceProvider)
|
||||
{
|
||||
_config = config;
|
||||
_transLookup = transLookup;
|
||||
_serviceProvider = serviceProvider;
|
||||
}
|
||||
|
||||
/// <inheritdoc/>
|
||||
public IManagerCommand CreateScriptCommand(string name, string alias, string description, string permission,
|
||||
bool isTargetRequired, IEnumerable<CommandArgument> args, Func<GameEvent, Task> executeAction, IEnumerable<Reference.Game> supportedGames)
|
||||
{
|
||||
var permissionEnum = Enum.Parse<EFClient.Permission>(permission);
|
||||
|
||||
return new ScriptCommand(name, alias, description, isTargetRequired, permissionEnum, args, executeAction,
|
||||
_config, _transLookup, _serviceProvider.GetRequiredService<ILogger<ScriptCommand>>(), supportedGames);
|
||||
}
|
||||
}
|
||||
}
|
||||
23
Application/GameEventHandler.cs
Normal file
23
Application/GameEventHandler.cs
Normal file
@ -0,0 +1,23 @@
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Events;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading;
|
||||
|
||||
namespace IW4MAdmin.Application
|
||||
{
|
||||
class GameEventHandler : IEventHandler
|
||||
{
|
||||
readonly IManager Manager;
|
||||
public GameEventHandler(IManager mgr)
|
||||
{
|
||||
Manager = mgr;
|
||||
}
|
||||
|
||||
public void AddEvent(GameEvent gameEvent)
|
||||
{
|
||||
((Manager as ApplicationManager).OnServerEvent)(this, new GameEventArgs(null, false, gameEvent));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,213 +0,0 @@
|
||||
using System;
|
||||
using System.Collections;
|
||||
using System.IO;
|
||||
using System.Linq;
|
||||
using System.Text.Json;
|
||||
using System.Text.Json.Serialization;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.IO;
|
||||
|
||||
public class BaseConfigurationHandlerV2<TConfigurationType> : IConfigurationHandlerV2<TConfigurationType>
|
||||
where TConfigurationType : class
|
||||
{
|
||||
private readonly ILogger<BaseConfigurationHandlerV2<TConfigurationType>> _logger;
|
||||
private readonly ConfigurationWatcher _watcher;
|
||||
|
||||
private readonly JsonSerializerOptions _serializerOptions = new()
|
||||
{
|
||||
WriteIndented = true,
|
||||
Converters =
|
||||
{
|
||||
new JsonStringEnumConverter()
|
||||
},
|
||||
Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping
|
||||
};
|
||||
|
||||
private readonly SemaphoreSlim _onIo = new(1, 1);
|
||||
private TConfigurationType _configurationInstance;
|
||||
private string _path = string.Empty;
|
||||
private event Action<string> FileUpdated;
|
||||
|
||||
public BaseConfigurationHandlerV2(ILogger<BaseConfigurationHandlerV2<TConfigurationType>> logger,
|
||||
ConfigurationWatcher watcher)
|
||||
{
|
||||
_logger = logger;
|
||||
_watcher = watcher;
|
||||
FileUpdated += OnFileUpdated;
|
||||
}
|
||||
|
||||
~BaseConfigurationHandlerV2()
|
||||
{
|
||||
FileUpdated -= OnFileUpdated;
|
||||
_watcher.Unregister(_path);
|
||||
}
|
||||
|
||||
public async Task<TConfigurationType> Get(string configurationName,
|
||||
TConfigurationType defaultConfiguration = default)
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(configurationName))
|
||||
{
|
||||
return defaultConfiguration;
|
||||
}
|
||||
|
||||
var cleanName = configurationName.Replace("\\", "").Replace("/", "");
|
||||
|
||||
if (string.IsNullOrWhiteSpace(configurationName))
|
||||
{
|
||||
return defaultConfiguration;
|
||||
}
|
||||
|
||||
_path = Path.Join(Utilities.OperatingDirectory, "Configuration", $"{cleanName}.json");
|
||||
TConfigurationType readConfiguration = null;
|
||||
|
||||
try
|
||||
{
|
||||
await _onIo.WaitAsync();
|
||||
await using var fileStream = File.OpenRead(_path);
|
||||
readConfiguration =
|
||||
await JsonSerializer.DeserializeAsync<TConfigurationType>(fileStream, _serializerOptions);
|
||||
await fileStream.DisposeAsync();
|
||||
_watcher.Register(_path, FileUpdated);
|
||||
|
||||
if (readConfiguration is null)
|
||||
{
|
||||
_logger.LogError("Could not parse configuration {Type} at {FileName}", typeof(TConfigurationType).Name,
|
||||
_path);
|
||||
|
||||
return defaultConfiguration;
|
||||
}
|
||||
}
|
||||
catch (FileNotFoundException)
|
||||
{
|
||||
if (defaultConfiguration is not null)
|
||||
{
|
||||
await InternalSet(defaultConfiguration, false);
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not read configuration file at {Path}", _path);
|
||||
return defaultConfiguration;
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (_onIo.CurrentCount == 0)
|
||||
{
|
||||
_onIo.Release(1);
|
||||
}
|
||||
}
|
||||
|
||||
return _configurationInstance ??= readConfiguration;
|
||||
}
|
||||
|
||||
public async Task Set(TConfigurationType configuration)
|
||||
{
|
||||
await InternalSet(configuration, true);
|
||||
}
|
||||
|
||||
public async Task Set()
|
||||
{
|
||||
if (_configurationInstance is not null)
|
||||
{
|
||||
await InternalSet(_configurationInstance, true);
|
||||
}
|
||||
}
|
||||
|
||||
public event Action<TConfigurationType> Updated;
|
||||
|
||||
private async Task InternalSet(TConfigurationType configuration, bool awaitSemaphore)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (awaitSemaphore)
|
||||
{
|
||||
await _onIo.WaitAsync();
|
||||
}
|
||||
|
||||
await using var fileStream = File.Create(_path);
|
||||
await JsonSerializer.SerializeAsync(fileStream, configuration, _serializerOptions);
|
||||
await fileStream.DisposeAsync();
|
||||
_configurationInstance = configuration;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not save configuration {Type} {Path}", configuration.GetType().Name, _path);
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (awaitSemaphore && _onIo.CurrentCount == 0)
|
||||
{
|
||||
_onIo.Release(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private async void OnFileUpdated(string filePath)
|
||||
{
|
||||
try
|
||||
{
|
||||
await _onIo.WaitAsync();
|
||||
await using var fileStream = File.OpenRead(_path);
|
||||
var readConfiguration =
|
||||
await JsonSerializer.DeserializeAsync<TConfigurationType>(fileStream, _serializerOptions);
|
||||
await fileStream.DisposeAsync();
|
||||
|
||||
if (readConfiguration is null)
|
||||
{
|
||||
_logger.LogWarning("Could not parse updated configuration {Type} at {Path}",
|
||||
typeof(TConfigurationType).Name, filePath);
|
||||
}
|
||||
else
|
||||
{
|
||||
CopyUpdatedProperties(readConfiguration);
|
||||
Updated?.Invoke(readConfiguration);
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogWarning(ex, "Could not parse updated configuration {Type} at {Path}",
|
||||
typeof(TConfigurationType).Name, filePath);
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (_onIo.CurrentCount == 0)
|
||||
{
|
||||
_onIo.Release(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void CopyUpdatedProperties(TConfigurationType newConfiguration)
|
||||
{
|
||||
if (_configurationInstance is null)
|
||||
{
|
||||
_configurationInstance = newConfiguration;
|
||||
return;
|
||||
}
|
||||
|
||||
_logger.LogDebug("Updating existing config with new values {Type} at {Path}", typeof(TConfigurationType).Name,
|
||||
_path);
|
||||
|
||||
if (_configurationInstance is IDictionary configDict && newConfiguration is IDictionary newConfigDict)
|
||||
{
|
||||
configDict.Clear();
|
||||
foreach (var key in newConfigDict.Keys)
|
||||
{
|
||||
configDict.Add(key, newConfigDict[key]);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
foreach (var property in _configurationInstance.GetType().GetProperties()
|
||||
.Where(prop => prop.CanRead && prop.CanWrite))
|
||||
{
|
||||
property.SetValue(_configurationInstance, property.GetValue(newConfiguration));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,60 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using SharedLibraryCore;
|
||||
|
||||
namespace IW4MAdmin.Application.IO;
|
||||
|
||||
public sealed class ConfigurationWatcher : IDisposable
|
||||
{
|
||||
private readonly FileSystemWatcher _watcher;
|
||||
private readonly Dictionary<string, Action<string>> _registeredActions = new();
|
||||
|
||||
public ConfigurationWatcher()
|
||||
{
|
||||
_watcher = new FileSystemWatcher
|
||||
{
|
||||
Path = Path.Join(Utilities.OperatingDirectory, "Configuration"),
|
||||
Filter = "*.json",
|
||||
NotifyFilter = NotifyFilters.LastWrite
|
||||
};
|
||||
|
||||
_watcher.Changed += WatcherOnChanged;
|
||||
_watcher.EnableRaisingEvents = true;
|
||||
}
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
_watcher.Changed -= WatcherOnChanged;
|
||||
_watcher.Dispose();
|
||||
}
|
||||
|
||||
public void Register(string fileName, Action<string> fileUpdated)
|
||||
{
|
||||
if (_registeredActions.ContainsKey(fileName))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
_registeredActions.Add(fileName, fileUpdated);
|
||||
}
|
||||
|
||||
public void Unregister(string fileName)
|
||||
{
|
||||
if (_registeredActions.ContainsKey(fileName))
|
||||
{
|
||||
_registeredActions.Remove(fileName);
|
||||
}
|
||||
}
|
||||
|
||||
private void WatcherOnChanged(object sender, FileSystemEventArgs eventArgs)
|
||||
{
|
||||
if (!_registeredActions.ContainsKey(eventArgs.FullPath) || eventArgs.ChangeType != WatcherChangeTypes.Changed ||
|
||||
new FileInfo(eventArgs.FullPath).Length == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
_registeredActions[eventArgs.FullPath].Invoke(eventArgs.FullPath);
|
||||
}
|
||||
}
|
||||
@ -1,35 +1,36 @@
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using System;
|
||||
using System.Linq;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using Serilog.Context;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
namespace IW4MAdmin.Application.IO
|
||||
{
|
||||
public class GameLogEventDetection
|
||||
class GameLogEventDetection
|
||||
{
|
||||
private long previousFileSize;
|
||||
private readonly Server _server;
|
||||
private readonly IGameLogReader _reader;
|
||||
private readonly bool _ignoreBots;
|
||||
private readonly ILogger _logger;
|
||||
Server Server;
|
||||
long PreviousFileSize;
|
||||
IGameLogReader Reader;
|
||||
readonly string GameLogFile;
|
||||
|
||||
public GameLogEventDetection(ILogger<GameLogEventDetection> logger, IW4MServer server, Uri[] gameLogUris, IGameLogReaderFactory gameLogReaderFactory)
|
||||
class EventState
|
||||
{
|
||||
_reader = gameLogReaderFactory.CreateGameLogReader(gameLogUris, server.EventParser);
|
||||
_server = server;
|
||||
_ignoreBots = server.Manager.GetApplicationSettings().Configuration()?.IgnoreBots ?? false;
|
||||
_logger = logger;
|
||||
public ILogger Log { get; set; }
|
||||
public string ServerId { get; set; }
|
||||
}
|
||||
|
||||
public GameLogEventDetection(Server server, string gameLogPath, Uri gameLogServerUri)
|
||||
{
|
||||
GameLogFile = gameLogPath;
|
||||
Reader = gameLogServerUri != null ? new GameLogReaderHttp(gameLogServerUri, gameLogPath, server.EventParser) : Reader = new GameLogReader(gameLogPath, server.EventParser);
|
||||
Server = server;
|
||||
}
|
||||
|
||||
public async Task PollForChanges()
|
||||
{
|
||||
while (!_server.Manager.CancellationToken.IsCancellationRequested)
|
||||
while (!Server.Manager.ShutdownRequested())
|
||||
{
|
||||
if (_server.IsInitialized)
|
||||
if (Server.IsInitialized)
|
||||
{
|
||||
try
|
||||
{
|
||||
@ -38,87 +39,39 @@ namespace IW4MAdmin.Application.IO
|
||||
|
||||
catch (Exception e)
|
||||
{
|
||||
using(LogContext.PushProperty("Server", _server.ToString()))
|
||||
{
|
||||
_logger.LogError(e, "Failed to update log event for {endpoint}", _server.EndPoint);
|
||||
}
|
||||
Server.Logger.WriteWarning($"Failed to update log event for {Server.EndPoint}");
|
||||
Server.Logger.WriteDebug($"Exception: {e.Message}");
|
||||
Server.Logger.WriteDebug($"StackTrace: {e.StackTrace}");
|
||||
}
|
||||
}
|
||||
|
||||
await Task.Delay(_reader.UpdateInterval, _server.Manager.CancellationToken);
|
||||
Thread.Sleep(Reader.UpdateInterval);
|
||||
}
|
||||
|
||||
_logger.LogDebug("Stopped polling for changes");
|
||||
}
|
||||
|
||||
public async Task UpdateLogEvents()
|
||||
private async Task UpdateLogEvents()
|
||||
{
|
||||
long fileSize = _reader.Length;
|
||||
long fileSize = Reader.Length;
|
||||
|
||||
if (previousFileSize == 0)
|
||||
{
|
||||
previousFileSize = fileSize;
|
||||
}
|
||||
if (PreviousFileSize == 0)
|
||||
PreviousFileSize = fileSize;
|
||||
|
||||
long fileDiff = fileSize - previousFileSize;
|
||||
long fileDiff = fileSize - PreviousFileSize;
|
||||
|
||||
// this makes the http log get pulled
|
||||
if (fileDiff < 1 && fileSize != -1)
|
||||
{
|
||||
previousFileSize = fileSize;
|
||||
return;
|
||||
}
|
||||
|
||||
var events = await _reader.ReadEventsFromLog(fileDiff, previousFileSize, _server);
|
||||
PreviousFileSize = fileSize;
|
||||
|
||||
foreach (var gameEvent in events)
|
||||
var events = await Reader.ReadEventsFromLog(Server, fileDiff, 0);
|
||||
|
||||
foreach (var ev in events)
|
||||
{
|
||||
try
|
||||
{
|
||||
gameEvent.Owner = _server;
|
||||
|
||||
// we don't want to add the event if ignoreBots is on and the event comes from a bot
|
||||
if (!_ignoreBots || (_ignoreBots && !((gameEvent.Origin?.IsBot ?? false) || (gameEvent.Target?.IsBot ?? false))))
|
||||
{
|
||||
if ((gameEvent.RequiredEntity & GameEvent.EventRequiredEntity.Origin) == GameEvent.EventRequiredEntity.Origin && gameEvent.Origin.NetworkId != Utilities.WORLD_ID)
|
||||
{
|
||||
gameEvent.Origin = _server.GetClientsAsList().First(_client => _client.NetworkId == gameEvent.Origin?.NetworkId);;
|
||||
}
|
||||
|
||||
if ((gameEvent.RequiredEntity & GameEvent.EventRequiredEntity.Target) == GameEvent.EventRequiredEntity.Target)
|
||||
{
|
||||
gameEvent.Target = _server.GetClientsAsList().First(_client => _client.NetworkId == gameEvent.Target?.NetworkId);
|
||||
}
|
||||
|
||||
if (gameEvent.Origin != null)
|
||||
{
|
||||
gameEvent.Origin.CurrentServer = _server;
|
||||
}
|
||||
|
||||
if (gameEvent.Target != null)
|
||||
{
|
||||
gameEvent.Target.CurrentServer = _server;
|
||||
}
|
||||
|
||||
_server.Manager.AddEvent(gameEvent);
|
||||
}
|
||||
}
|
||||
|
||||
catch (InvalidOperationException)
|
||||
{
|
||||
if (_ignoreBots)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
using(LogContext.PushProperty("Server", _server.ToString()))
|
||||
{
|
||||
_logger.LogError("Could not find client in client list when parsing event line {data}", gameEvent.Data);
|
||||
}
|
||||
}
|
||||
Server.Manager.GetEventHandler().AddEvent(ev);
|
||||
await ev.WaitAsync();
|
||||
}
|
||||
|
||||
previousFileSize = fileSize;
|
||||
PreviousFileSize = fileSize;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -3,79 +3,64 @@ using SharedLibraryCore.Interfaces;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
namespace IW4MAdmin.Application.IO
|
||||
{
|
||||
class GameLogReader : IGameLogReader
|
||||
{
|
||||
private readonly IEventParser _parser;
|
||||
private readonly string _logFile;
|
||||
private readonly ILogger _logger;
|
||||
IEventParser Parser;
|
||||
readonly string LogFile;
|
||||
|
||||
public long Length => new FileInfo(_logFile).Length;
|
||||
public long Length => new FileInfo(LogFile).Length;
|
||||
|
||||
public int UpdateInterval => 300;
|
||||
|
||||
public GameLogReader(string logFile, IEventParser parser, ILogger<GameLogReader> logger)
|
||||
public GameLogReader(string logFile, IEventParser parser)
|
||||
{
|
||||
_logFile = logFile;
|
||||
_parser = parser;
|
||||
_logger = logger;
|
||||
LogFile = logFile;
|
||||
Parser = parser;
|
||||
}
|
||||
|
||||
public async Task<IEnumerable<GameEvent>> ReadEventsFromLog(long fileSizeDiff, long startPosition, Server server = null)
|
||||
public async Task<ICollection<GameEvent>> ReadEventsFromLog(Server server, long fileSizeDiff, long startPosition)
|
||||
{
|
||||
// allocate the bytes for the new log lines
|
||||
List<string> logLines = new List<string>();
|
||||
|
||||
// open the file as a stream
|
||||
using (FileStream fs = new FileStream(_logFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
|
||||
using (var rd = new StreamReader(new FileStream(LogFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite), Utilities.EncodingType))
|
||||
{
|
||||
byte[] buff = new byte[fileSizeDiff];
|
||||
fs.Seek(startPosition, SeekOrigin.Begin);
|
||||
await fs.ReadAsync(buff, 0, (int)fileSizeDiff);
|
||||
var stringBuilder = new StringBuilder();
|
||||
char[] charBuff = Utilities.EncodingType.GetChars(buff);
|
||||
// todo: max async
|
||||
// take the old start position and go back the number of new characters
|
||||
rd.BaseStream.Seek(-fileSizeDiff, SeekOrigin.End);
|
||||
|
||||
foreach (char c in charBuff)
|
||||
string newLine;
|
||||
while (!string.IsNullOrEmpty(newLine = await rd.ReadLineAsync()))
|
||||
{
|
||||
if (c == '\n')
|
||||
{
|
||||
logLines.Add(stringBuilder.ToString());
|
||||
stringBuilder = new StringBuilder();
|
||||
}
|
||||
|
||||
else if (c != '\r')
|
||||
{
|
||||
stringBuilder.Append(c);
|
||||
}
|
||||
}
|
||||
|
||||
if (stringBuilder.Length > 0)
|
||||
{
|
||||
logLines.Add(stringBuilder.ToString());
|
||||
logLines.Add(newLine);
|
||||
}
|
||||
}
|
||||
|
||||
List<GameEvent> events = new List<GameEvent>();
|
||||
|
||||
// parse each line
|
||||
foreach (string eventLine in logLines.Where(_line => _line.Length > 0))
|
||||
foreach (string eventLine in logLines)
|
||||
{
|
||||
try
|
||||
if (eventLine.Length > 0)
|
||||
{
|
||||
var gameEvent = _parser.GenerateGameEvent(eventLine);
|
||||
events.Add(gameEvent);
|
||||
}
|
||||
try
|
||||
{
|
||||
// todo: catch elsewhere
|
||||
events.Add(Parser.GetEvent(server, eventLine));
|
||||
}
|
||||
|
||||
catch (Exception e)
|
||||
{
|
||||
_logger.LogError(e, "Could not properly parse event line {@eventLine}", eventLine);
|
||||
catch (Exception e)
|
||||
{
|
||||
server.Logger.WriteWarning("Could not properly parse event line");
|
||||
server.Logger.WriteDebug(e.Message);
|
||||
server.Logger.WriteDebug(eventLine);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -4,67 +4,66 @@ using SharedLibraryCore;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Net.Http;
|
||||
using System.Threading.Tasks;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
using static SharedLibraryCore.Utilities;
|
||||
|
||||
namespace IW4MAdmin.Application.IO
|
||||
{
|
||||
/// <summary>
|
||||
/// provides capability of reading log files over HTTP
|
||||
/// provides capibility of reading log files over HTTP
|
||||
/// </summary>
|
||||
class GameLogReaderHttp : IGameLogReader
|
||||
{
|
||||
private readonly IEventParser _eventParser;
|
||||
private readonly IGameLogServer _logServerApi;
|
||||
private readonly ILogger _logger;
|
||||
private readonly string _safeLogPath;
|
||||
private string lastKey = "next";
|
||||
readonly IEventParser Parser;
|
||||
readonly IGameLogServer Api;
|
||||
readonly string logPath;
|
||||
|
||||
public GameLogReaderHttp(Uri[] gameLogServerUris, IEventParser parser, ILogger<GameLogReaderHttp> logger)
|
||||
public GameLogReaderHttp(Uri gameLogServerUri, string logPath, IEventParser parser)
|
||||
{
|
||||
_eventParser = parser;
|
||||
_logServerApi = RestClient.For<IGameLogServer>(gameLogServerUris[0].ToString());
|
||||
_safeLogPath = gameLogServerUris[1].LocalPath.ToBase64UrlSafeString();
|
||||
_logger = logger;
|
||||
this.logPath = logPath.ToBase64UrlSafeString(); ;
|
||||
Parser = parser;
|
||||
Api = RestClient.For<IGameLogServer>(gameLogServerUri);
|
||||
}
|
||||
|
||||
public long Length => -1;
|
||||
|
||||
public int UpdateInterval => 500;
|
||||
public int UpdateInterval => 350;
|
||||
|
||||
public async Task<IEnumerable<GameEvent>> ReadEventsFromLog(long fileSizeDiff, long startPosition, Server server = null)
|
||||
public async Task<ICollection<GameEvent>> ReadEventsFromLog(Server server, long fileSizeDiff, long startPosition)
|
||||
{
|
||||
#if DEBUG == true
|
||||
server.Logger.WriteDebug($"Begin reading from http log");
|
||||
#endif
|
||||
var events = new List<GameEvent>();
|
||||
var response = await _logServerApi.Log(_safeLogPath, lastKey);
|
||||
lastKey = response.NextKey;
|
||||
string b64Path = logPath;
|
||||
var response = await Api.Log(b64Path);
|
||||
|
||||
if (!response.Success && string.IsNullOrEmpty(lastKey))
|
||||
if (!response.Success)
|
||||
{
|
||||
_logger.LogError("Could not get log server info of {logPath}", _safeLogPath);
|
||||
server.Logger.WriteError($"Could not get log server info of {logPath}/{b64Path} ({server.LogPath})");
|
||||
return events;
|
||||
}
|
||||
|
||||
else if (!string.IsNullOrWhiteSpace(response.Data))
|
||||
// parse each line
|
||||
foreach (string eventLine in response.Data.Split(Environment.NewLine))
|
||||
{
|
||||
// parse each line
|
||||
var lines = response.Data
|
||||
.Split(Environment.NewLine)
|
||||
.Where(_line => _line.Length > 0);
|
||||
|
||||
foreach (string eventLine in lines)
|
||||
if (eventLine.Length > 0)
|
||||
{
|
||||
try
|
||||
{
|
||||
// this trim end should hopefully fix the nasty runaway regex
|
||||
var gameEvent = _eventParser.GenerateGameEvent(eventLine.TrimEnd('\r'));
|
||||
events.Add(gameEvent);
|
||||
var e = Parser.GetEvent(server, eventLine);
|
||||
#if DEBUG == true
|
||||
server.Logger.WriteDebug($"Parsed event with id {e.Id} from http");
|
||||
#endif
|
||||
events.Add(e);
|
||||
}
|
||||
|
||||
catch (Exception e)
|
||||
{
|
||||
_logger.LogError(e, "Could not properly parse event line from http {eventLine}", eventLine);
|
||||
server.Logger.WriteWarning("Could not properly parse event line");
|
||||
server.Logger.WriteDebug(e.Message);
|
||||
server.Logger.WriteDebug(eventLine);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,163 +0,0 @@
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Net;
|
||||
using System.Net.Sockets;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using Integrations.Cod;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using Serilog.Context;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
namespace IW4MAdmin.Application.IO
|
||||
{
|
||||
/// <summary>
|
||||
/// provides capability of reading log files over udp
|
||||
/// </summary>
|
||||
class NetworkGameLogReader : IGameLogReader
|
||||
{
|
||||
private readonly IEventParser _eventParser;
|
||||
private readonly ILogger _logger;
|
||||
private readonly Uri _uri;
|
||||
private static readonly NetworkLogState State = new();
|
||||
private bool _stateRegistered;
|
||||
private CancellationToken _token;
|
||||
|
||||
public NetworkGameLogReader(IReadOnlyList<Uri> uris, IEventParser parser, ILogger<NetworkGameLogReader> logger)
|
||||
{
|
||||
_eventParser = parser;
|
||||
_uri = uris[0];
|
||||
_logger = logger;
|
||||
}
|
||||
|
||||
public long Length => -1;
|
||||
|
||||
public int UpdateInterval => 150;
|
||||
|
||||
public Task<IEnumerable<GameEvent>> ReadEventsFromLog(long fileSizeDiff, long startPosition,
|
||||
Server server = null)
|
||||
{
|
||||
// todo: other games might support this
|
||||
var serverEndpoint = (server?.RemoteConnection as CodRConConnection)?.Endpoint;
|
||||
|
||||
if (serverEndpoint is null)
|
||||
{
|
||||
return Task.FromResult(Enumerable.Empty<GameEvent>());
|
||||
}
|
||||
|
||||
if (!_stateRegistered && !State.EndPointExists(serverEndpoint))
|
||||
{
|
||||
try
|
||||
{
|
||||
var client = State.RegisterEndpoint(serverEndpoint, BuildLocalEndpoint()).Client;
|
||||
|
||||
_stateRegistered = true;
|
||||
_token = server.Manager.CancellationToken;
|
||||
|
||||
if (client == null)
|
||||
{
|
||||
using (LogContext.PushProperty("Server", server.ToString()))
|
||||
{
|
||||
_logger.LogInformation("Not registering {Name} socket because it is already bound",
|
||||
nameof(NetworkGameLogReader));
|
||||
}
|
||||
return Task.FromResult(Enumerable.Empty<GameEvent>());
|
||||
}
|
||||
|
||||
Task.Run(async () => await ReadNetworkData(client, _token), _token);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not register {Name} endpoint {Endpoint}",
|
||||
nameof(NetworkGameLogReader), _uri);
|
||||
throw;
|
||||
}
|
||||
}
|
||||
|
||||
var events = new List<GameEvent>();
|
||||
|
||||
foreach (var logData in State.GetServerLogData(serverEndpoint)
|
||||
.Select(log => Utilities.EncodingType.GetString(log)))
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(logData))
|
||||
{
|
||||
return Task.FromResult(Enumerable.Empty<GameEvent>());
|
||||
}
|
||||
|
||||
var lines = logData
|
||||
.Split('\n')
|
||||
.Where(line => line.Length > 0 && !line.Contains('ÿ'));
|
||||
|
||||
foreach (var eventLine in lines)
|
||||
{
|
||||
try
|
||||
{
|
||||
// this trim end should hopefully fix the nasty runaway regex
|
||||
var gameEvent = _eventParser.GenerateGameEvent(eventLine.TrimEnd('\r'));
|
||||
events.Add(gameEvent);
|
||||
}
|
||||
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not properly parse event line from http {EventLine}",
|
||||
eventLine);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return Task.FromResult((IEnumerable<GameEvent>)events);
|
||||
}
|
||||
|
||||
private async Task ReadNetworkData(UdpClient client, CancellationToken token)
|
||||
{
|
||||
while (!token.IsCancellationRequested)
|
||||
{
|
||||
// get more data
|
||||
IPEndPoint remoteEndpoint = null;
|
||||
byte[] bufferedData = null;
|
||||
|
||||
if (client == null)
|
||||
{
|
||||
// we already have a socket listening on this port for data, so we don't need to run another thread
|
||||
break;
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
var result = await client.ReceiveAsync(_token);
|
||||
remoteEndpoint = result.RemoteEndPoint;
|
||||
bufferedData = result.Buffer;
|
||||
}
|
||||
catch (OperationCanceledException)
|
||||
{
|
||||
_logger.LogDebug("Stopping network log receive");
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not receive lines for {LogReader}", nameof(NetworkGameLogReader));
|
||||
}
|
||||
|
||||
if (bufferedData != null)
|
||||
{
|
||||
State.QueueServerLogData(remoteEndpoint, bufferedData);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private IPEndPoint BuildLocalEndpoint()
|
||||
{
|
||||
try
|
||||
{
|
||||
return new IPEndPoint(Dns.GetHostAddresses(_uri.Host).First(), _uri.Port);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not setup {LogReader} endpoint", nameof(NetworkGameLogReader));
|
||||
throw;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,138 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Net;
|
||||
using System.Net.Sockets;
|
||||
using System.Threading;
|
||||
|
||||
namespace IW4MAdmin.Application.IO;
|
||||
|
||||
public class NetworkLogState : Dictionary<IPEndPoint, UdpClientState>
|
||||
{
|
||||
public UdpClientState RegisterEndpoint(IPEndPoint serverEndpoint, IPEndPoint localEndpoint)
|
||||
{
|
||||
try
|
||||
{
|
||||
lock (this)
|
||||
{
|
||||
if (!ContainsKey(serverEndpoint))
|
||||
{
|
||||
Add(serverEndpoint, new UdpClientState { Client = new UdpClient(localEndpoint) });
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (SocketException ex) when (ex.SocketErrorCode == SocketError.AddressAlreadyInUse)
|
||||
{
|
||||
lock (this)
|
||||
{
|
||||
// we don't add the udp client because it already exists (listening to multiple servers from one socket)
|
||||
Add(serverEndpoint, new UdpClientState());
|
||||
}
|
||||
}
|
||||
|
||||
return this[serverEndpoint];
|
||||
}
|
||||
|
||||
|
||||
public List<byte[]> GetServerLogData(IPEndPoint serverEndpoint)
|
||||
{
|
||||
try
|
||||
{
|
||||
var state = this[serverEndpoint];
|
||||
|
||||
if (state == null)
|
||||
{
|
||||
return new List<byte[]>();
|
||||
}
|
||||
|
||||
// it's possible that we could be trying to read and write to the queue simultaneously so we need to wait
|
||||
this[serverEndpoint].OnAction.Wait();
|
||||
|
||||
var data = new List<byte[]>();
|
||||
|
||||
while (this[serverEndpoint].AvailableLogData.Count > 0)
|
||||
{
|
||||
data.Add(this[serverEndpoint].AvailableLogData.Dequeue());
|
||||
}
|
||||
|
||||
return data;
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (this[serverEndpoint].OnAction.CurrentCount == 0)
|
||||
{
|
||||
this[serverEndpoint].OnAction.Release(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void QueueServerLogData(IPEndPoint serverEndpoint, byte[] data)
|
||||
{
|
||||
var endpoint = Keys.FirstOrDefault(key =>
|
||||
Equals(key.Address, serverEndpoint.Address) && key.Port == serverEndpoint.Port);
|
||||
|
||||
try
|
||||
{
|
||||
if (endpoint == null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// currently our expected start and end characters
|
||||
var startsWithPrefix = StartsWith(data, "ÿÿÿÿprint\n");
|
||||
var endsWithDelimiter = data[^1] == '\n';
|
||||
|
||||
// we have the data we expected
|
||||
if (!startsWithPrefix || !endsWithDelimiter)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// it's possible that we could be trying to read and write to the queue simultaneously so we need to wait
|
||||
this[endpoint].OnAction.Wait();
|
||||
this[endpoint].AvailableLogData.Enqueue(data);
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (endpoint != null && this[endpoint].OnAction.CurrentCount == 0)
|
||||
{
|
||||
this[endpoint].OnAction.Release(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public bool EndPointExists(IPEndPoint serverEndpoint)
|
||||
{
|
||||
lock (this)
|
||||
{
|
||||
return ContainsKey(serverEndpoint);
|
||||
}
|
||||
}
|
||||
|
||||
private static bool StartsWith(byte[] sourceArray, string match)
|
||||
{
|
||||
if (sourceArray is null)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
if (match.Length > sourceArray.Length)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
return !match.Where((t, i) => sourceArray[i] != (byte)t).Any();
|
||||
}
|
||||
}
|
||||
|
||||
public class UdpClientState
|
||||
{
|
||||
public UdpClient Client { get; set; }
|
||||
public Queue<byte[]> AvailableLogData { get; } = new();
|
||||
public SemaphoreSlim OnAction { get; } = new(1, 1);
|
||||
|
||||
~UdpClientState()
|
||||
{
|
||||
OnAction.Dispose();
|
||||
Client?.Dispose();
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,41 +1,35 @@
|
||||
using IW4MAdmin.Application.API.Master;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Globalization;
|
||||
using System.IO;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace IW4MAdmin.Application.Localization
|
||||
{
|
||||
public static class Configure
|
||||
public class Configure
|
||||
{
|
||||
public static ITranslationLookup Initialize(ILogger logger, IMasterApi apiInstance, ApplicationConfiguration applicationConfiguration)
|
||||
public static void Initialize(string customLocale = null)
|
||||
{
|
||||
var useLocalTranslation = applicationConfiguration?.UseLocalTranslations ?? true;
|
||||
var customLocale = applicationConfiguration?.EnableCustomLocale ?? false
|
||||
? (applicationConfiguration.CustomLocale ?? "en-US")
|
||||
: "en-US";
|
||||
var currentLocale = string.IsNullOrEmpty(customLocale) ? CultureInfo.CurrentCulture.Name : customLocale;
|
||||
var localizationFiles = Directory.GetFiles(Path.Join(Utilities.OperatingDirectory, "Localization"), $"*.{currentLocale}.json");
|
||||
string currentLocale = string.IsNullOrEmpty(customLocale) ? CultureInfo.CurrentCulture.Name : customLocale;
|
||||
string[] localizationFiles = Directory.GetFiles(Path.Join(Utilities.OperatingDirectory, "Localization"), $"*.{currentLocale}.json");
|
||||
|
||||
if (!useLocalTranslation)
|
||||
if (!Program.ServerManager.GetApplicationSettings()?.Configuration()?.UseLocalTranslations ?? false)
|
||||
{
|
||||
try
|
||||
{
|
||||
var localization = apiInstance.GetLocalization(currentLocale).Result;
|
||||
var api = Endpoint.Get();
|
||||
var localization = api.GetLocalization(currentLocale).Result;
|
||||
Utilities.CurrentLocalization = localization;
|
||||
return localization.LocalizationIndex;
|
||||
return;
|
||||
}
|
||||
|
||||
catch (Exception ex)
|
||||
catch (Exception)
|
||||
{
|
||||
// the online localization failed so will default to local files
|
||||
logger.LogWarning(ex, "Could not download latest translations");
|
||||
}
|
||||
}
|
||||
|
||||
@ -63,26 +57,22 @@ namespace IW4MAdmin.Application.Localization
|
||||
{
|
||||
var localizationContents = File.ReadAllText(filePath, Encoding.UTF8);
|
||||
var eachLocalizationFile = Newtonsoft.Json.JsonConvert.DeserializeObject<SharedLibraryCore.Localization.Layout>(localizationContents);
|
||||
if (eachLocalizationFile == null)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
foreach (var item in eachLocalizationFile.LocalizationIndex.Set)
|
||||
{
|
||||
if (!localizationDict.TryAdd(item.Key, item.Value))
|
||||
{
|
||||
logger.LogError("Could not add locale string {key} to localization", item.Key);
|
||||
Program.ServerManager.GetLogger(0).WriteError($"Could not add locale string {item.Key} to localization");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
string localizationFile = $"{Path.Join(Utilities.OperatingDirectory, "Localization")}{Path.DirectorySeparatorChar}IW4MAdmin.{currentLocale}-{currentLocale.ToUpper()}.json";
|
||||
|
||||
Utilities.CurrentLocalization = new SharedLibraryCore.Localization.Layout(localizationDict)
|
||||
{
|
||||
LocalizationName = currentLocale,
|
||||
};
|
||||
|
||||
return Utilities.CurrentLocalization.LocalizationIndex;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,550 +1,205 @@
|
||||
using IW4MAdmin.Application.API.Master;
|
||||
using IW4MAdmin.Application.EventParsers;
|
||||
using IW4MAdmin.Application.Factories;
|
||||
using IW4MAdmin.Application.Meta;
|
||||
using IW4MAdmin.Application.Migration;
|
||||
using IW4MAdmin.Application.Misc;
|
||||
using Microsoft.Extensions.DependencyInjection;
|
||||
using RestEase;
|
||||
using IW4MAdmin.Application.Migration;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Database.Models;
|
||||
using SharedLibraryCore.Dtos.Meta.Responses;
|
||||
using SharedLibraryCore.Exceptions;
|
||||
using SharedLibraryCore.Helpers;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using SharedLibraryCore.QueryHelper;
|
||||
using SharedLibraryCore.Repositories;
|
||||
using SharedLibraryCore.Services;
|
||||
using Stats.Dtos;
|
||||
using SharedLibraryCore.Localization;
|
||||
using System;
|
||||
using System.IO;
|
||||
using System.Linq;
|
||||
using System.Net.Http;
|
||||
using System.Text;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Abstractions;
|
||||
using Data.Helpers;
|
||||
using Integrations.Source.Extensions;
|
||||
using IW4MAdmin.Application.Alerts;
|
||||
using IW4MAdmin.Application.Extensions;
|
||||
using IW4MAdmin.Application.IO;
|
||||
using IW4MAdmin.Application.Localization;
|
||||
using IW4MAdmin.Application.Plugin;
|
||||
using IW4MAdmin.Application.Plugin.Script;
|
||||
using IW4MAdmin.Application.QueryHelpers;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
using IW4MAdmin.Plugins.Stats.Client.Abstractions;
|
||||
using IW4MAdmin.Plugins.Stats.Client;
|
||||
using Microsoft.Extensions.Hosting;
|
||||
using Stats.Client.Abstractions;
|
||||
using Stats.Client;
|
||||
using Stats.Config;
|
||||
using Stats.Helpers;
|
||||
using WebfrontCore.QueryHelpers.Models;
|
||||
|
||||
namespace IW4MAdmin.Application
|
||||
{
|
||||
public class Program
|
||||
{
|
||||
public static BuildNumber Version { get; } = BuildNumber.Parse(Utilities.GetVersionAsString());
|
||||
private static ApplicationManager _serverManager;
|
||||
private static Task _applicationTask;
|
||||
private static IServiceProvider _serviceProvider;
|
||||
static public double Version { get; private set; }
|
||||
static public ApplicationManager ServerManager;
|
||||
private static ManualResetEventSlim OnShutdownComplete = new ManualResetEventSlim();
|
||||
|
||||
/// <summary>
|
||||
/// entrypoint of the application
|
||||
/// </summary>
|
||||
/// <returns></returns>
|
||||
public static async Task Main(bool noConfirm = false, int? maxConcurrentRequests = 25, int? requestQueueLimit = 25)
|
||||
public static void Main(string[] args)
|
||||
{
|
||||
AppDomain.CurrentDomain.SetData("DataDirectory", Utilities.OperatingDirectory);
|
||||
AppDomain.CurrentDomain.AssemblyResolve += (sender, eventArgs) =>
|
||||
{
|
||||
var libraryName = eventArgs.Name.Split(",").First();
|
||||
|
||||
var overrides = new[] { nameof(SharedLibraryCore), nameof(Stats) };
|
||||
if (!overrides.Contains(libraryName))
|
||||
{
|
||||
return AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(asm => asm.FullName == eventArgs.Name);
|
||||
}
|
||||
// added to be a bit more permissive with plugin references
|
||||
return AppDomain.CurrentDomain.GetAssemblies()
|
||||
.FirstOrDefault(asm => asm.FullName?.StartsWith(libraryName) ?? false);
|
||||
};
|
||||
|
||||
if (noConfirm)
|
||||
{
|
||||
AppContext.SetSwitch("NoConfirmPrompt", true);
|
||||
}
|
||||
|
||||
Environment.SetEnvironmentVariable("MaxConcurrentRequests", (maxConcurrentRequests * Environment.ProcessorCount).ToString());
|
||||
Environment.SetEnvironmentVariable("RequestQueueLimit", requestQueueLimit.ToString());
|
||||
|
||||
Console.OutputEncoding = Encoding.UTF8;
|
||||
Console.ForegroundColor = ConsoleColor.Gray;
|
||||
|
||||
Console.CancelKeyPress += OnCancelKey;
|
||||
Version = Utilities.GetVersionAsDouble();
|
||||
|
||||
Console.WriteLine("=====================================================");
|
||||
Console.WriteLine(" IW4MAdmin");
|
||||
Console.WriteLine(" IW4M ADMIN");
|
||||
Console.WriteLine(" by RaidMax ");
|
||||
Console.WriteLine($" Version {Utilities.GetVersionAsString()}");
|
||||
Console.WriteLine("=====================================================");
|
||||
|
||||
await LaunchAsync();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// event callback executed when the control + c combination is detected
|
||||
/// gracefully stops the server manager and waits for all tasks to finish
|
||||
/// </summary>
|
||||
/// <param name="sender"></param>
|
||||
/// <param name="e"></param>
|
||||
private static async void OnCancelKey(object sender, ConsoleCancelEventArgs e)
|
||||
{
|
||||
if (_serverManager is not null)
|
||||
{
|
||||
await _serverManager.Stop();
|
||||
}
|
||||
|
||||
if (_applicationTask is not null)
|
||||
{
|
||||
await _applicationTask;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// task that initializes application and starts the application monitoring and runtime tasks
|
||||
/// </summary>
|
||||
/// <returns></returns>
|
||||
private static async Task LaunchAsync()
|
||||
{
|
||||
restart:
|
||||
ITranslationLookup translationLookup = null;
|
||||
var logger = BuildDefaultLogger<Program>(new ApplicationConfiguration());
|
||||
Utilities.DefaultLogger = logger;
|
||||
logger.LogInformation("Begin IW4MAdmin startup. Version is {Version}", Version);
|
||||
Index loc = null;
|
||||
|
||||
try
|
||||
{
|
||||
// do any needed housekeeping file/folder migrations
|
||||
ConfigurationMigration.MoveConfigFolder10518(null);
|
||||
ConfigurationMigration.CheckDirectories();
|
||||
ConfigurationMigration.RemoveObsoletePlugins20210322();
|
||||
ServerManager = ApplicationManager.GetInstance();
|
||||
var configuration = ServerManager.GetApplicationSettings().Configuration();
|
||||
|
||||
logger.LogDebug("Configuring services...");
|
||||
|
||||
var configHandler = new BaseConfigurationHandler<ApplicationConfiguration>("IW4MAdminSettings");
|
||||
await configHandler.BuildAsync();
|
||||
_serviceProvider = WebfrontCore.Program.InitializeServices(ConfigureServices,
|
||||
(configHandler.Configuration() ?? new ApplicationConfiguration()).WebfrontBindUrl);
|
||||
|
||||
_serverManager = (ApplicationManager)_serviceProvider.GetRequiredService<IManager>();
|
||||
translationLookup = _serviceProvider.GetRequiredService<ITranslationLookup>();
|
||||
|
||||
await _serverManager.Init();
|
||||
|
||||
_applicationTask = RunApplicationTasksAsync(logger, _serverManager, _serviceProvider);
|
||||
|
||||
await _applicationTask;
|
||||
logger.LogInformation("Shutdown completed successfully");
|
||||
}
|
||||
|
||||
catch (Exception e)
|
||||
{
|
||||
var failMessage = translationLookup == null
|
||||
? "Failed to initialize IW4MAdmin"
|
||||
: translationLookup["MANAGER_INIT_FAIL"];
|
||||
var exitMessage = translationLookup == null
|
||||
? "Press enter to exit..."
|
||||
: translationLookup["MANAGER_EXIT"];
|
||||
|
||||
logger.LogCritical(e, "Failed to initialize IW4MAdmin");
|
||||
Console.WriteLine(failMessage);
|
||||
|
||||
while (e.InnerException != null)
|
||||
if (configuration != null)
|
||||
{
|
||||
e = e.InnerException;
|
||||
}
|
||||
|
||||
if (e is ConfigurationException configException)
|
||||
{
|
||||
Console.WriteLine("{{fileName}} contains an error."
|
||||
.FormatExt(Path.GetFileName(configException.ConfigurationFileName)));
|
||||
|
||||
foreach (var error in configException.Errors)
|
||||
{
|
||||
Console.WriteLine(error);
|
||||
}
|
||||
Localization.Configure.Initialize(configuration.EnableCustomLocale ? (configuration.CustomLocale ?? "windows-1252") : "windows-1252");
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
Console.WriteLine(e.Message);
|
||||
Localization.Configure.Initialize();
|
||||
}
|
||||
|
||||
if (_serverManager is not null)
|
||||
loc = Utilities.CurrentLocalization.LocalizationIndex;
|
||||
Console.CancelKeyPress += new ConsoleCancelEventHandler(OnCancelKey);
|
||||
|
||||
CheckDirectories();
|
||||
// do any needed migrations
|
||||
// todo: move out
|
||||
ConfigurationMigration.MoveConfigFolder10518(null);
|
||||
|
||||
ServerManager.Logger.WriteInfo($"Version is {Version}");
|
||||
|
||||
var api = API.Master.Endpoint.Get();
|
||||
|
||||
var version = new API.Master.VersionInfo()
|
||||
{
|
||||
await _serverManager?.Stop();
|
||||
CurrentVersionStable = 99.99f
|
||||
};
|
||||
|
||||
try
|
||||
{
|
||||
version = api.GetVersion().Result;
|
||||
}
|
||||
|
||||
catch (Exception e)
|
||||
{
|
||||
ServerManager.Logger.WriteWarning(loc["MANAGER_VERSION_FAIL"]);
|
||||
while (e.InnerException != null)
|
||||
{
|
||||
e = e.InnerException;
|
||||
}
|
||||
|
||||
ServerManager.Logger.WriteDebug(e.Message);
|
||||
}
|
||||
|
||||
if (version.CurrentVersionStable == 99.99f)
|
||||
{
|
||||
Console.ForegroundColor = ConsoleColor.Red;
|
||||
Console.WriteLine(loc["MANAGER_VERSION_FAIL"]);
|
||||
Console.ForegroundColor = ConsoleColor.Gray;
|
||||
}
|
||||
|
||||
#if !PRERELEASE
|
||||
else if (version.CurrentVersionStable > Version)
|
||||
{
|
||||
Console.ForegroundColor = ConsoleColor.DarkYellow;
|
||||
Console.WriteLine($"IW4MAdmin {loc["MANAGER_VERSION_UPDATE"]} [v{version.CurrentVersionStable.ToString("0.0")}]");
|
||||
Console.WriteLine(loc["MANAGER_VERSION_CURRENT"].FormatExt($"[v{Version.ToString("0.0")}]"));
|
||||
Console.ForegroundColor = ConsoleColor.Gray;
|
||||
}
|
||||
#else
|
||||
else if (version.CurrentVersionPrerelease > Version)
|
||||
{
|
||||
Console.ForegroundColor = ConsoleColor.DarkYellow;
|
||||
Console.WriteLine($"IW4MAdmin-Prerelease {loc["MANAGER_VERSION_UPDATE"]} [v{version.CurrentVersionPrerelease.ToString("0.0")}-pr]");
|
||||
Console.WriteLine(loc["MANAGER_VERSION_CURRENT"].FormatExt($"[v{Version.ToString("0.0")}-pr]"));
|
||||
Console.ForegroundColor = ConsoleColor.Gray;
|
||||
}
|
||||
#endif
|
||||
else
|
||||
{
|
||||
Console.ForegroundColor = ConsoleColor.Green;
|
||||
Console.WriteLine(loc["MANAGER_VERSION_SUCCESS"]);
|
||||
Console.ForegroundColor = ConsoleColor.Gray;
|
||||
}
|
||||
|
||||
ServerManager.Init().Wait();
|
||||
|
||||
var consoleTask = Task.Run(async () =>
|
||||
{
|
||||
string userInput;
|
||||
var Origin = Utilities.IW4MAdminClient(ServerManager.Servers[0]);
|
||||
|
||||
do
|
||||
{
|
||||
userInput = Console.ReadLine();
|
||||
|
||||
if (userInput?.ToLower() == "quit")
|
||||
{
|
||||
ServerManager.Stop();
|
||||
}
|
||||
|
||||
if (ServerManager.Servers.Count == 0)
|
||||
{
|
||||
Console.WriteLine(loc["MANAGER_CONSOLE_NOSERV"]);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (userInput?.Length > 0)
|
||||
{
|
||||
GameEvent E = new GameEvent()
|
||||
{
|
||||
Type = GameEvent.EventType.Command,
|
||||
Data = userInput,
|
||||
Origin = Origin,
|
||||
Owner = ServerManager.Servers[0]
|
||||
};
|
||||
|
||||
ServerManager.GetEventHandler().AddEvent(E);
|
||||
await E.WaitAsync(30 * 1000);
|
||||
}
|
||||
Console.Write('>');
|
||||
|
||||
} while (ServerManager.Running);
|
||||
});
|
||||
}
|
||||
|
||||
catch (Exception e)
|
||||
{
|
||||
string failMessage = loc == null ? "Failed to initalize IW4MAdmin" : loc["MANAGER_INIT_FAIL"];
|
||||
string exitMessage = loc == null ? "Press any key to exit..." : loc["MANAGER_EXIT"];
|
||||
|
||||
Console.WriteLine(failMessage);
|
||||
while (e.InnerException != null)
|
||||
{
|
||||
e = e.InnerException;
|
||||
}
|
||||
Console.WriteLine(e.Message);
|
||||
Console.WriteLine(exitMessage);
|
||||
await Console.In.ReadAsync(new char[1], 0, 1);
|
||||
Console.ReadKey();
|
||||
return;
|
||||
}
|
||||
|
||||
if (_serverManager.IsRestartRequested)
|
||||
if (ServerManager.GetApplicationSettings().Configuration().EnableWebFront)
|
||||
{
|
||||
goto restart;
|
||||
Task.Run(() => WebfrontCore.Program.Init(ServerManager));
|
||||
}
|
||||
|
||||
OnShutdownComplete.Reset();
|
||||
ServerManager.Start();
|
||||
ServerManager.Logger.WriteVerbose(loc["MANAGER_SHUTDOWN_SUCCESS"]);
|
||||
OnShutdownComplete.Set();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// runs the core application tasks
|
||||
/// </summary>
|
||||
/// <returns></returns>
|
||||
private static Task RunApplicationTasksAsync(ILogger logger, ApplicationManager applicationManager,
|
||||
IServiceProvider serviceProvider)
|
||||
private static void OnCancelKey(object sender, ConsoleCancelEventArgs e)
|
||||
{
|
||||
var collectionService = serviceProvider.GetRequiredService<IServerDataCollector>();
|
||||
var versionChecker = serviceProvider.GetRequiredService<IMasterCommunication>();
|
||||
var masterCommunicator = serviceProvider.GetRequiredService<IMasterCommunication>();
|
||||
var webfrontLifetime = serviceProvider.GetRequiredService<IHostApplicationLifetime>();
|
||||
using var onWebfrontErrored = new ManualResetEventSlim();
|
||||
|
||||
var webfrontTask = _serverManager.GetApplicationSettings().Configuration().EnableWebFront
|
||||
? WebfrontCore.Program.GetWebHostTask(_serverManager.CancellationToken).ContinueWith(continuation =>
|
||||
{
|
||||
if (!continuation.IsFaulted)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
logger.LogCritical("Unable to start webfront task. {Message}",
|
||||
continuation.Exception?.InnerException?.Message);
|
||||
|
||||
logger.LogDebug(continuation.Exception, "Unable to start webfront task");
|
||||
|
||||
onWebfrontErrored.Set();
|
||||
|
||||
})
|
||||
: Task.CompletedTask;
|
||||
|
||||
if (_serverManager.GetApplicationSettings().Configuration().EnableWebFront)
|
||||
{
|
||||
try
|
||||
{
|
||||
onWebfrontErrored.Wait(webfrontLifetime.ApplicationStarted);
|
||||
}
|
||||
catch
|
||||
{
|
||||
// ignored when webfront successfully starts
|
||||
}
|
||||
|
||||
if (onWebfrontErrored.IsSet)
|
||||
{
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
}
|
||||
|
||||
// we want to run this one on a manual thread instead of letting the thread pool handle it,
|
||||
// because we can't exit early from waiting on console input, and it prevents us from restarting
|
||||
async void ReadInput() => await ReadConsoleInput(logger);
|
||||
|
||||
var inputThread = new Thread(ReadInput);
|
||||
inputThread.Start();
|
||||
|
||||
var tasks = new[]
|
||||
{
|
||||
applicationManager.Start(),
|
||||
versionChecker.CheckVersion(),
|
||||
webfrontTask,
|
||||
masterCommunicator.RunUploadStatus(_serverManager.CancellationToken),
|
||||
collectionService.BeginCollectionAsync(cancellationToken: _serverManager.CancellationToken)
|
||||
};
|
||||
|
||||
logger.LogDebug("Starting webfront and input tasks");
|
||||
return Task.WhenAll(tasks);
|
||||
ServerManager.Stop();
|
||||
OnShutdownComplete.Wait();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// reads input from the console and executes entered commands on the default server
|
||||
/// </summary>
|
||||
/// <returns></returns>
|
||||
private static async Task ReadConsoleInput(ILogger logger)
|
||||
static void CheckDirectories()
|
||||
{
|
||||
if (Console.IsInputRedirected)
|
||||
if (!Directory.Exists(Path.Join(Utilities.OperatingDirectory, "Plugins")))
|
||||
{
|
||||
logger.LogInformation("Disabling console input as it has been redirected");
|
||||
return;
|
||||
Directory.CreateDirectory(Path.Join(Utilities.OperatingDirectory, "Plugins"));
|
||||
}
|
||||
|
||||
EFClient origin = null;
|
||||
|
||||
try
|
||||
if (!Directory.Exists(Path.Join(Utilities.OperatingDirectory, "Database")))
|
||||
{
|
||||
while (!_serverManager.CancellationToken.IsCancellationRequested)
|
||||
{
|
||||
if (!_serverManager.IsInitialized)
|
||||
{
|
||||
await Task.Delay(1000);
|
||||
continue;
|
||||
}
|
||||
|
||||
var lastCommand = await Console.In.ReadLineAsync();
|
||||
|
||||
if (lastCommand == null)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
if (!lastCommand.Any())
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
var gameEvent = new GameEvent
|
||||
{
|
||||
Type = GameEvent.EventType.Command,
|
||||
Data = lastCommand,
|
||||
Origin = origin ??= Utilities.IW4MAdminClient(_serverManager.Servers.FirstOrDefault()),
|
||||
Owner = _serverManager.Servers[0]
|
||||
};
|
||||
|
||||
_serverManager.AddEvent(gameEvent);
|
||||
await gameEvent.WaitAsync(Utilities.DefaultCommandTimeout, _serverManager.CancellationToken);
|
||||
Console.Write('>');
|
||||
}
|
||||
}
|
||||
catch (OperationCanceledException)
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
private static IServiceCollection HandlePluginRegistration(ApplicationConfiguration appConfig,
|
||||
IServiceCollection serviceCollection,
|
||||
IMasterApi masterApi)
|
||||
{
|
||||
var defaultLogger = BuildDefaultLogger<Program>(appConfig);
|
||||
var pluginServiceProvider = new ServiceCollection()
|
||||
.AddBaseLogger(appConfig)
|
||||
.AddSingleton(appConfig)
|
||||
.AddSingleton(masterApi)
|
||||
.AddSingleton<IRemoteAssemblyHandler, RemoteAssemblyHandler>()
|
||||
.AddSingleton<IPluginImporter, PluginImporter>()
|
||||
.BuildServiceProvider();
|
||||
|
||||
var pluginImporter = pluginServiceProvider.GetRequiredService<IPluginImporter>();
|
||||
|
||||
// we need to register the rest client with regular collection
|
||||
serviceCollection.AddSingleton(masterApi);
|
||||
|
||||
// register the native commands
|
||||
foreach (var commandType in typeof(SharedLibraryCore.Commands.QuitCommand).Assembly.GetTypes()
|
||||
.Concat(typeof(Program).Assembly.GetTypes().Where(type => type.Namespace?.StartsWith("IW4MAdmin.Application.Commands") ?? false))
|
||||
.Where(command => command.BaseType == typeof(Command)))
|
||||
{
|
||||
defaultLogger.LogDebug("Registered native command type {Name}", commandType.Name);
|
||||
serviceCollection.AddSingleton(typeof(IManagerCommand), commandType);
|
||||
Directory.CreateDirectory(Path.Join(Utilities.OperatingDirectory, "Database"));
|
||||
}
|
||||
|
||||
// register the plugin implementations
|
||||
var (plugins, commands, configurations) = pluginImporter.DiscoverAssemblyPluginImplementations();
|
||||
foreach (var pluginType in plugins)
|
||||
if (!Directory.Exists(Path.Join(Utilities.OperatingDirectory, "Log")))
|
||||
{
|
||||
var isV2 = pluginType.GetInterface(nameof(IPluginV2), false) != null;
|
||||
|
||||
defaultLogger.LogDebug("Registering plugin type {Name}", pluginType.FullName);
|
||||
|
||||
serviceCollection.AddSingleton(!isV2 ? typeof(IPlugin) : typeof(IPluginV2), pluginType);
|
||||
|
||||
try
|
||||
{
|
||||
var registrationMethod = pluginType.GetMethod(nameof(IPluginV2.RegisterDependencies));
|
||||
registrationMethod?.Invoke(null, new object[] { serviceCollection });
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
defaultLogger.LogError(ex, "Could not register plugin of type {Type}", pluginType.Name);
|
||||
}
|
||||
Directory.CreateDirectory(Path.Join(Utilities.OperatingDirectory, "Log"));
|
||||
}
|
||||
|
||||
// register the plugin commands
|
||||
foreach (var commandType in commands)
|
||||
{
|
||||
defaultLogger.LogDebug("Registered plugin command type {Name}", commandType.FullName);
|
||||
serviceCollection.AddSingleton(typeof(IManagerCommand), commandType);
|
||||
}
|
||||
|
||||
foreach (var configurationType in configurations)
|
||||
{
|
||||
defaultLogger.LogDebug("Registered plugin config type {Name}", configurationType.Name);
|
||||
var configInstance = (IBaseConfiguration) Activator.CreateInstance(configurationType);
|
||||
var handlerType = typeof(BaseConfigurationHandler<>).MakeGenericType(configurationType);
|
||||
var handlerInstance = Activator.CreateInstance(handlerType, configInstance.Name());
|
||||
var genericInterfaceType = typeof(IConfigurationHandler<>).MakeGenericType(configurationType);
|
||||
|
||||
serviceCollection.AddSingleton(genericInterfaceType, handlerInstance);
|
||||
}
|
||||
|
||||
var scriptPlugins = pluginImporter.DiscoverScriptPlugins();
|
||||
|
||||
foreach (var scriptPlugin in scriptPlugins)
|
||||
{
|
||||
serviceCollection.AddSingleton(scriptPlugin.Item1, sp =>
|
||||
sp.GetRequiredService<IScriptPluginFactory>()
|
||||
.CreateScriptPlugin(scriptPlugin.Item1, scriptPlugin.Item2));
|
||||
}
|
||||
|
||||
// register any eventable types
|
||||
foreach (var assemblyType in typeof(Program).Assembly.GetTypes()
|
||||
.Where(asmType => typeof(IRegisterEvent).IsAssignableFrom(asmType))
|
||||
.Union(plugins.SelectMany(asm => asm.Assembly.GetTypes())
|
||||
.Distinct()
|
||||
.Where(asmType => typeof(IRegisterEvent).IsAssignableFrom(asmType))))
|
||||
{
|
||||
var instance = Activator.CreateInstance(assemblyType) as IRegisterEvent;
|
||||
serviceCollection.AddSingleton(instance);
|
||||
}
|
||||
|
||||
return serviceCollection;
|
||||
}
|
||||
|
||||
|
||||
/// <summary>
|
||||
/// Configures the dependency injection services
|
||||
/// </summary>
|
||||
private static void ConfigureServices(IServiceCollection serviceCollection)
|
||||
{
|
||||
// todo: this is a quick fix
|
||||
AppContext.SetSwitch("Npgsql.EnableLegacyTimestampBehavior", true);
|
||||
|
||||
serviceCollection.AddConfiguration<ApplicationConfiguration>("IW4MAdminSettings")
|
||||
.AddConfiguration<DefaultSettings>()
|
||||
.AddConfiguration<CommandConfiguration>()
|
||||
.AddConfiguration<StatsConfiguration>("StatsPluginSettings");
|
||||
|
||||
// for legacy purposes. update at some point
|
||||
var appConfigHandler = new BaseConfigurationHandler<ApplicationConfiguration>("IW4MAdminSettings");
|
||||
appConfigHandler.BuildAsync().GetAwaiter().GetResult();
|
||||
var commandConfigHandler = new BaseConfigurationHandler<CommandConfiguration>("CommandConfiguration");
|
||||
commandConfigHandler.BuildAsync().GetAwaiter().GetResult();
|
||||
|
||||
if (appConfigHandler.Configuration()?.MasterUrl == new Uri("http://api.raidmax.org:5000"))
|
||||
{
|
||||
appConfigHandler.Configuration().MasterUrl = new ApplicationConfiguration().MasterUrl;
|
||||
}
|
||||
|
||||
var appConfig = appConfigHandler.Configuration();
|
||||
var masterUri = Utilities.IsDevelopment
|
||||
? new Uri("http://127.0.0.1:8080")
|
||||
: appConfig?.MasterUrl ?? new ApplicationConfiguration().MasterUrl;
|
||||
var httpClient = new HttpClient
|
||||
{
|
||||
BaseAddress = masterUri,
|
||||
Timeout = TimeSpan.FromSeconds(15)
|
||||
};
|
||||
var masterRestClient = RestClient.For<IMasterApi>(httpClient);
|
||||
var translationLookup = Configure.Initialize(Utilities.DefaultLogger, masterRestClient, appConfig);
|
||||
|
||||
if (appConfig == null)
|
||||
{
|
||||
appConfig = (ApplicationConfiguration) new ApplicationConfiguration().Generate();
|
||||
appConfigHandler.Set(appConfig);
|
||||
appConfigHandler.Save().GetAwaiter().GetResult();
|
||||
}
|
||||
|
||||
// register override level names
|
||||
foreach (var (key, value) in appConfig.OverridePermissionLevelNames)
|
||||
{
|
||||
if (!Utilities.PermissionLevelOverrides.ContainsKey(key))
|
||||
{
|
||||
Utilities.PermissionLevelOverrides.Add(key, value);
|
||||
}
|
||||
}
|
||||
|
||||
// build the dependency list
|
||||
serviceCollection
|
||||
.AddBaseLogger(appConfig)
|
||||
.AddSingleton((IConfigurationHandler<ApplicationConfiguration>) appConfigHandler)
|
||||
.AddSingleton<IConfigurationHandler<CommandConfiguration>>(commandConfigHandler)
|
||||
.AddSingleton(serviceProvider =>
|
||||
serviceProvider.GetRequiredService<IConfigurationHandler<CommandConfiguration>>()
|
||||
.Configuration() ?? new CommandConfiguration())
|
||||
.AddSingleton<IPluginImporter, PluginImporter>()
|
||||
.AddSingleton<IMiddlewareActionHandler, MiddlewareActionHandler>()
|
||||
.AddSingleton<IRConConnectionFactory, RConConnectionFactory>()
|
||||
.AddSingleton<IGameServerInstanceFactory, GameServerInstanceFactory>()
|
||||
.AddSingleton<IConfigurationHandlerFactory, ConfigurationHandlerFactory>()
|
||||
.AddSingleton<IParserRegexFactory, ParserRegexFactory>()
|
||||
.AddSingleton<IDatabaseContextFactory, DatabaseContextFactory>()
|
||||
.AddSingleton<IGameLogReaderFactory, GameLogReaderFactory>()
|
||||
.AddSingleton<IScriptCommandFactory, ScriptCommandFactory>()
|
||||
.AddSingleton<IAuditInformationRepository, AuditInformationRepository>()
|
||||
.AddSingleton<IEntityService<EFClient>, ClientService>()
|
||||
#pragma warning disable CS0618
|
||||
.AddSingleton<IMetaService, MetaService>()
|
||||
#pragma warning restore CS0618
|
||||
.AddSingleton<IMetaServiceV2, MetaServiceV2>()
|
||||
.AddSingleton<ClientService>()
|
||||
.AddSingleton<PenaltyService>()
|
||||
.AddSingleton<ChangeHistoryService>()
|
||||
.AddSingleton<IMetaRegistration, MetaRegistration>()
|
||||
.AddSingleton<IScriptPluginServiceResolver, ScriptPluginServiceResolver>()
|
||||
.AddSingleton<IResourceQueryHelper<ClientPaginationRequest, ReceivedPenaltyResponse>,
|
||||
ReceivedPenaltyResourceQueryHelper>()
|
||||
.AddSingleton<IResourceQueryHelper<ClientPaginationRequest, AdministeredPenaltyResponse>,
|
||||
AdministeredPenaltyResourceQueryHelper>()
|
||||
.AddSingleton<IResourceQueryHelper<ClientPaginationRequest, UpdatedAliasResponse>,
|
||||
UpdatedAliasResourceQueryHelper>()
|
||||
.AddSingleton<IResourceQueryHelper<ChatSearchQuery, MessageResponse>, ChatResourceQueryHelper>()
|
||||
.AddSingleton<IResourceQueryHelper<ClientPaginationRequest, ConnectionHistoryResponse>, ConnectionsResourceQueryHelper>()
|
||||
.AddSingleton<IResourceQueryHelper<ClientPaginationRequest, PermissionLevelChangedResponse>, PermissionLevelChangedResourceQueryHelper>()
|
||||
.AddSingleton<IResourceQueryHelper<ClientResourceRequest, ClientResourceResponse>, ClientResourceQueryHelper>()
|
||||
.AddTransient<IParserPatternMatcher, ParserPatternMatcher>()
|
||||
.AddSingleton<IRemoteAssemblyHandler, RemoteAssemblyHandler>()
|
||||
.AddSingleton<IMasterCommunication, MasterCommunication>()
|
||||
.AddSingleton<IManager, ApplicationManager>()
|
||||
#pragma warning disable CS0612
|
||||
.AddSingleton<SharedLibraryCore.Interfaces.ILogger, Logger>()
|
||||
#pragma warning restore CS0612
|
||||
.AddSingleton<IClientNoticeMessageFormatter, ClientNoticeMessageFormatter>()
|
||||
.AddSingleton<IClientStatisticCalculator, HitCalculator>()
|
||||
.AddSingleton<IServerDistributionCalculator, ServerDistributionCalculator>()
|
||||
.AddSingleton<IWeaponNameParser, WeaponNameParser>()
|
||||
.AddSingleton<IHitInfoBuilder, HitInfoBuilder>()
|
||||
.AddSingleton(typeof(ILookupCache<>), typeof(LookupCache<>))
|
||||
.AddSingleton(typeof(IDataValueCache<,>), typeof(DataValueCache<,>))
|
||||
.AddSingleton<IServerDataViewer, ServerDataViewer>()
|
||||
.AddSingleton<IServerDataCollector, ServerDataCollector>()
|
||||
.AddSingleton<IGeoLocationService>(new GeoLocationService(Path.Join(".", "Resources", "GeoLite2-Country.mmdb")))
|
||||
.AddSingleton<IAlertManager, AlertManager>()
|
||||
#pragma warning disable CS0618
|
||||
.AddTransient<IScriptPluginTimerHelper, ScriptPluginTimerHelper>()
|
||||
#pragma warning restore CS0618
|
||||
.AddSingleton<IInteractionRegistration, InteractionRegistration>()
|
||||
.AddSingleton<IRemoteCommandService, RemoteCommandService>()
|
||||
.AddSingleton(new ConfigurationWatcher())
|
||||
.AddSingleton(typeof(IConfigurationHandlerV2<>), typeof(BaseConfigurationHandlerV2<>))
|
||||
.AddSingleton<IScriptPluginFactory, ScriptPluginFactory>()
|
||||
.AddSingleton(translationLookup)
|
||||
.AddDatabaseContextOptions(appConfig);
|
||||
|
||||
serviceCollection.AddSingleton<ICoreEventHandler, CoreEventHandler>();
|
||||
serviceCollection.AddSource();
|
||||
HandlePluginRegistration(appConfig, serviceCollection, masterRestClient);
|
||||
}
|
||||
|
||||
private static ILogger BuildDefaultLogger<T>(ApplicationConfiguration appConfig)
|
||||
{
|
||||
var collection = new ServiceCollection()
|
||||
.AddBaseLogger(appConfig)
|
||||
.BuildServiceProvider();
|
||||
|
||||
return collection.GetRequiredService<ILogger<T>>();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,67 +0,0 @@
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Abstractions;
|
||||
using Data.Models;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SharedLibraryCore.Dtos.Meta.Responses;
|
||||
using SharedLibraryCore.Helpers;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using SharedLibraryCore.QueryHelper;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
namespace IW4MAdmin.Application.Meta
|
||||
{
|
||||
/// <summary>
|
||||
/// implementation of IResourceQueryHelper
|
||||
/// query helper that retrieves administered penalties for provided client id
|
||||
/// </summary>
|
||||
public class AdministeredPenaltyResourceQueryHelper : IResourceQueryHelper<ClientPaginationRequest, AdministeredPenaltyResponse>
|
||||
{
|
||||
private readonly ILogger _logger;
|
||||
private readonly IDatabaseContextFactory _contextFactory;
|
||||
|
||||
public AdministeredPenaltyResourceQueryHelper(ILogger<AdministeredPenaltyResourceQueryHelper> logger, IDatabaseContextFactory contextFactory)
|
||||
{
|
||||
_contextFactory = contextFactory;
|
||||
_logger = logger;
|
||||
}
|
||||
|
||||
public async Task<ResourceQueryHelperResult<AdministeredPenaltyResponse>> QueryResource(ClientPaginationRequest query)
|
||||
{
|
||||
await using var ctx = _contextFactory.CreateContext(enableTracking: false);
|
||||
|
||||
var iqPenalties = ctx.Penalties.AsNoTracking()
|
||||
.Where(_penalty => query.ClientId == _penalty.PunisherId)
|
||||
.Where(_penalty => _penalty.When < query.Before)
|
||||
.OrderByDescending(_penalty => _penalty.When);
|
||||
|
||||
var penalties = await iqPenalties
|
||||
.Take(query.Count)
|
||||
.Select(_penalty => new AdministeredPenaltyResponse()
|
||||
{
|
||||
PenaltyId = _penalty.PenaltyId,
|
||||
Offense = _penalty.Offense,
|
||||
AutomatedOffense = _penalty.AutomatedOffense,
|
||||
ClientId = _penalty.OffenderId,
|
||||
OffenderName = _penalty.Offender.CurrentAlias.Name,
|
||||
OffenderClientId = _penalty.Offender.ClientId,
|
||||
PunisherClientId = _penalty.PunisherId,
|
||||
PunisherName = _penalty.Punisher.CurrentAlias.Name,
|
||||
PenaltyType = _penalty.Type,
|
||||
When = _penalty.When,
|
||||
ExpirationDate = _penalty.Expires,
|
||||
IsLinked = _penalty.OffenderId != query.ClientId,
|
||||
IsSensitive = _penalty.Type == EFPenalty.PenaltyType.Flag
|
||||
})
|
||||
.ToListAsync();
|
||||
|
||||
return new ResourceQueryHelperResult<AdministeredPenaltyResponse>
|
||||
{
|
||||
// todo: might need to do count at some point
|
||||
RetrievedResultCount = penalties.Count,
|
||||
Results = penalties
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,60 +0,0 @@
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Abstractions;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SharedLibraryCore.Dtos.Meta.Responses;
|
||||
using SharedLibraryCore.Helpers;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using SharedLibraryCore.QueryHelper;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
namespace IW4MAdmin.Application.Meta
|
||||
{
|
||||
public class
|
||||
ConnectionsResourceQueryHelper : IResourceQueryHelper<ClientPaginationRequest, ConnectionHistoryResponse>
|
||||
{
|
||||
private readonly ILogger _logger;
|
||||
private readonly IDatabaseContextFactory _contextFactory;
|
||||
|
||||
public ConnectionsResourceQueryHelper(ILogger<ConnectionsResourceQueryHelper> logger,
|
||||
IDatabaseContextFactory contextFactory)
|
||||
{
|
||||
_contextFactory = contextFactory;
|
||||
_logger = logger;
|
||||
}
|
||||
|
||||
public async Task<ResourceQueryHelperResult<ConnectionHistoryResponse>> QueryResource(
|
||||
ClientPaginationRequest query)
|
||||
{
|
||||
_logger.LogDebug("{Class} {@Request}", nameof(ConnectionsResourceQueryHelper), query);
|
||||
|
||||
await using var context = _contextFactory.CreateContext(enableTracking: false);
|
||||
|
||||
var iqConnections = context.ConnectionHistory.AsNoTracking()
|
||||
.Where(history => query.ClientId == history.ClientId)
|
||||
.Where(history => history.CreatedDateTime < query.Before)
|
||||
.OrderByDescending(history => history.CreatedDateTime);
|
||||
|
||||
var connections = await iqConnections.Select(history => new ConnectionHistoryResponse
|
||||
{
|
||||
MetaId = history.ClientConnectionId,
|
||||
ClientId = history.ClientId,
|
||||
Type = MetaType.ConnectionHistory,
|
||||
ShouldDisplay = true,
|
||||
When = history.CreatedDateTime,
|
||||
ServerName = history.Server.HostName,
|
||||
ConnectionType = history.ConnectionType
|
||||
})
|
||||
.ToListAsync();
|
||||
|
||||
_logger.LogDebug("{Class} retrieved {Number} items", nameof(ConnectionsResourceQueryHelper),
|
||||
connections.Count);
|
||||
|
||||
return new ResourceQueryHelperResult<ConnectionHistoryResponse>
|
||||
{
|
||||
Results = connections
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,206 +0,0 @@
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Database.Models;
|
||||
using SharedLibraryCore.Dtos.Meta.Responses;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using SharedLibraryCore.QueryHelper;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
namespace IW4MAdmin.Application.Meta
|
||||
{
|
||||
public class MetaRegistration : IMetaRegistration
|
||||
{
|
||||
private readonly ILogger _logger;
|
||||
private ITranslationLookup _transLookup;
|
||||
private readonly IMetaServiceV2 _metaService;
|
||||
private readonly IEntityService<EFClient> _clientEntityService;
|
||||
private readonly IResourceQueryHelper<ClientPaginationRequest, ReceivedPenaltyResponse> _receivedPenaltyHelper;
|
||||
|
||||
private readonly IResourceQueryHelper<ClientPaginationRequest, AdministeredPenaltyResponse>
|
||||
_administeredPenaltyHelper;
|
||||
|
||||
private readonly IResourceQueryHelper<ClientPaginationRequest, UpdatedAliasResponse> _updatedAliasHelper;
|
||||
|
||||
private readonly IResourceQueryHelper<ClientPaginationRequest, ConnectionHistoryResponse>
|
||||
_connectionHistoryHelper;
|
||||
|
||||
private readonly IResourceQueryHelper<ClientPaginationRequest, PermissionLevelChangedResponse>
|
||||
_permissionLevelHelper;
|
||||
|
||||
public MetaRegistration(ILogger<MetaRegistration> logger, IMetaServiceV2 metaService,
|
||||
ITranslationLookup transLookup, IEntityService<EFClient> clientEntityService,
|
||||
IResourceQueryHelper<ClientPaginationRequest, ReceivedPenaltyResponse> receivedPenaltyHelper,
|
||||
IResourceQueryHelper<ClientPaginationRequest, AdministeredPenaltyResponse> administeredPenaltyHelper,
|
||||
IResourceQueryHelper<ClientPaginationRequest, UpdatedAliasResponse> updatedAliasHelper,
|
||||
IResourceQueryHelper<ClientPaginationRequest, ConnectionHistoryResponse> connectionHistoryHelper,
|
||||
IResourceQueryHelper<ClientPaginationRequest, PermissionLevelChangedResponse> permissionLevelHelper)
|
||||
{
|
||||
_logger = logger;
|
||||
_transLookup = transLookup;
|
||||
_metaService = metaService;
|
||||
_clientEntityService = clientEntityService;
|
||||
_receivedPenaltyHelper = receivedPenaltyHelper;
|
||||
_administeredPenaltyHelper = administeredPenaltyHelper;
|
||||
_updatedAliasHelper = updatedAliasHelper;
|
||||
_connectionHistoryHelper = connectionHistoryHelper;
|
||||
_permissionLevelHelper = permissionLevelHelper;
|
||||
}
|
||||
|
||||
public void Register()
|
||||
{
|
||||
_metaService.AddRuntimeMeta<ClientPaginationRequest, InformationResponse>(MetaType.Information,
|
||||
GetProfileMeta);
|
||||
_metaService.AddRuntimeMeta<ClientPaginationRequest, ReceivedPenaltyResponse>(MetaType.ReceivedPenalty,
|
||||
GetReceivedPenaltiesMeta);
|
||||
_metaService.AddRuntimeMeta<ClientPaginationRequest, AdministeredPenaltyResponse>(MetaType.Penalized,
|
||||
GetAdministeredPenaltiesMeta);
|
||||
_metaService.AddRuntimeMeta<ClientPaginationRequest, UpdatedAliasResponse>(MetaType.AliasUpdate,
|
||||
GetUpdatedAliasMeta);
|
||||
_metaService.AddRuntimeMeta<ClientPaginationRequest, ConnectionHistoryResponse>(MetaType.ConnectionHistory,
|
||||
GetConnectionHistoryMeta);
|
||||
_metaService.AddRuntimeMeta<ClientPaginationRequest, PermissionLevelChangedResponse>(
|
||||
MetaType.PermissionLevel, GetPermissionLevelMeta);
|
||||
}
|
||||
|
||||
private async Task<IEnumerable<InformationResponse>> GetProfileMeta(ClientPaginationRequest request,
|
||||
CancellationToken cancellationToken = default)
|
||||
{
|
||||
var metaList = new List<InformationResponse>();
|
||||
var lastMapMeta =
|
||||
await _metaService.GetPersistentMeta("LastMapPlayed", request.ClientId, cancellationToken);
|
||||
|
||||
if (lastMapMeta != null)
|
||||
{
|
||||
metaList.Add(new InformationResponse()
|
||||
{
|
||||
ClientId = request.ClientId,
|
||||
MetaId = lastMapMeta.MetaId,
|
||||
Key = Utilities.CurrentLocalization.LocalizationIndex["WEBFRONT_CLIENT_META_LAST_MAP"],
|
||||
Value = lastMapMeta.Value,
|
||||
ShouldDisplay = true,
|
||||
Type = MetaType.Information,
|
||||
Order = 6
|
||||
});
|
||||
}
|
||||
|
||||
var lastServerMeta =
|
||||
await _metaService.GetPersistentMeta("LastServerPlayed", request.ClientId, cancellationToken);
|
||||
|
||||
if (lastServerMeta != null)
|
||||
{
|
||||
metaList.Add(new InformationResponse()
|
||||
{
|
||||
ClientId = request.ClientId,
|
||||
MetaId = lastServerMeta.MetaId,
|
||||
Key = Utilities.CurrentLocalization.LocalizationIndex["WEBFRONT_CLIENT_META_LAST_SERVER"],
|
||||
Value = lastServerMeta.Value,
|
||||
ShouldDisplay = true,
|
||||
Type = MetaType.Information,
|
||||
Order = 7
|
||||
});
|
||||
}
|
||||
|
||||
var client = await _clientEntityService.Get(request.ClientId);
|
||||
|
||||
if (client == null)
|
||||
{
|
||||
_logger.LogWarning("No client found with id {ClientId} when generating profile meta", request.ClientId);
|
||||
return metaList;
|
||||
}
|
||||
|
||||
metaList.Add(new InformationResponse()
|
||||
{
|
||||
ClientId = client.ClientId,
|
||||
Key = _transLookup["WEBFRONT_PROFILE_META_PLAY_TIME"],
|
||||
Value = TimeSpan.FromHours(client.TotalConnectionTime / 3600.0).HumanizeForCurrentCulture(),
|
||||
ShouldDisplay = true,
|
||||
Order = 8,
|
||||
Type = MetaType.Information
|
||||
});
|
||||
|
||||
metaList.Add(new InformationResponse()
|
||||
{
|
||||
ClientId = client.ClientId,
|
||||
Key = _transLookup["WEBFRONT_PROFILE_META_FIRST_SEEN"],
|
||||
Value = (DateTime.UtcNow - client.FirstConnection).HumanizeForCurrentCulture(),
|
||||
ShouldDisplay = true,
|
||||
Order = 9,
|
||||
Type = MetaType.Information
|
||||
});
|
||||
|
||||
metaList.Add(new InformationResponse()
|
||||
{
|
||||
ClientId = client.ClientId,
|
||||
Key = _transLookup["WEBFRONT_PROFILE_META_LAST_SEEN"],
|
||||
Value = (DateTime.UtcNow - client.LastConnection).HumanizeForCurrentCulture(),
|
||||
ShouldDisplay = true,
|
||||
Order = 10,
|
||||
Type = MetaType.Information
|
||||
});
|
||||
|
||||
metaList.Add(new InformationResponse()
|
||||
{
|
||||
ClientId = client.ClientId,
|
||||
Key = Utilities.CurrentLocalization.LocalizationIndex["WEBFRONT_CLIENT_META_CONNECTIONS"],
|
||||
Value = client.Connections.ToString("#,##0",
|
||||
new System.Globalization.CultureInfo(Utilities.CurrentLocalization.LocalizationName)),
|
||||
ShouldDisplay = true,
|
||||
Order = 11,
|
||||
Type = MetaType.Information
|
||||
});
|
||||
|
||||
metaList.Add(new InformationResponse()
|
||||
{
|
||||
ClientId = client.ClientId,
|
||||
Key = Utilities.CurrentLocalization.LocalizationIndex["WEBFRONT_CLIENT_META_MASKED"],
|
||||
Value = client.Masked
|
||||
? Utilities.CurrentLocalization.LocalizationIndex["WEBFRONT_CLIENT_META_TRUE"]
|
||||
: Utilities.CurrentLocalization.LocalizationIndex["WEBFRONT_CLIENT_META_FALSE"],
|
||||
IsSensitive = true,
|
||||
Order = 12,
|
||||
Type = MetaType.Information
|
||||
});
|
||||
|
||||
return metaList;
|
||||
}
|
||||
|
||||
private async Task<IEnumerable<ReceivedPenaltyResponse>> GetReceivedPenaltiesMeta(
|
||||
ClientPaginationRequest request, CancellationToken token = default)
|
||||
{
|
||||
var penalties = await _receivedPenaltyHelper.QueryResource(request);
|
||||
return penalties.Results;
|
||||
}
|
||||
|
||||
private async Task<IEnumerable<AdministeredPenaltyResponse>> GetAdministeredPenaltiesMeta(
|
||||
ClientPaginationRequest request, CancellationToken token = default)
|
||||
{
|
||||
var penalties = await _administeredPenaltyHelper.QueryResource(request);
|
||||
return penalties.Results;
|
||||
}
|
||||
|
||||
private async Task<IEnumerable<UpdatedAliasResponse>> GetUpdatedAliasMeta(ClientPaginationRequest request,
|
||||
CancellationToken token = default)
|
||||
{
|
||||
var aliases = await _updatedAliasHelper.QueryResource(request);
|
||||
return aliases.Results;
|
||||
}
|
||||
|
||||
private async Task<IEnumerable<ConnectionHistoryResponse>> GetConnectionHistoryMeta(
|
||||
ClientPaginationRequest request, CancellationToken token = default)
|
||||
{
|
||||
var connections = await _connectionHistoryHelper.QueryResource(request);
|
||||
return connections.Results;
|
||||
}
|
||||
|
||||
private async Task<IEnumerable<PermissionLevelChangedResponse>> GetPermissionLevelMeta(
|
||||
ClientPaginationRequest request, CancellationToken token = default)
|
||||
{
|
||||
var permissionChanges = await _permissionLevelHelper.QueryResource(request);
|
||||
return permissionChanges.Results;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,52 +0,0 @@
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Abstractions;
|
||||
using Data.Models;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using SharedLibraryCore.Dtos.Meta.Responses;
|
||||
using SharedLibraryCore.Helpers;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using SharedLibraryCore.QueryHelper;
|
||||
|
||||
namespace IW4MAdmin.Application.Meta;
|
||||
|
||||
public class
|
||||
PermissionLevelChangedResourceQueryHelper : IResourceQueryHelper<ClientPaginationRequest,
|
||||
PermissionLevelChangedResponse>
|
||||
{
|
||||
private readonly IDatabaseContextFactory _contextFactory;
|
||||
|
||||
public PermissionLevelChangedResourceQueryHelper(IDatabaseContextFactory contextFactory)
|
||||
{
|
||||
_contextFactory = contextFactory;
|
||||
}
|
||||
|
||||
public async Task<ResourceQueryHelperResult<PermissionLevelChangedResponse>> QueryResource(
|
||||
ClientPaginationRequest query)
|
||||
{
|
||||
await using var context = _contextFactory.CreateContext();
|
||||
|
||||
var auditEntries = context.EFChangeHistory.Where(change => change.TargetEntityId == query.ClientId)
|
||||
.Where(change => change.TypeOfChange == EFChangeHistory.ChangeType.Permission)
|
||||
.OrderByDescending(change => change.TimeChanged);
|
||||
|
||||
var audits = from change in auditEntries
|
||||
join client in context.Clients
|
||||
on change.OriginEntityId equals client.ClientId
|
||||
select new PermissionLevelChangedResponse
|
||||
{
|
||||
ChangedById = change.OriginEntityId,
|
||||
ChangedByName = client.CurrentAlias.Name,
|
||||
PreviousPermissionLevelValue = change.PreviousValue,
|
||||
CurrentPermissionLevelValue = change.CurrentValue,
|
||||
When = change.TimeChanged,
|
||||
ClientId = change.TargetEntityId,
|
||||
IsSensitive = true
|
||||
};
|
||||
|
||||
return new ResourceQueryHelperResult<PermissionLevelChangedResponse>
|
||||
{
|
||||
Results = await audits.Skip(query.Offset).Take(query.Count).ToListAsync()
|
||||
};
|
||||
}
|
||||
}
|
||||
@ -1,119 +0,0 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Abstractions;
|
||||
using Data.Models;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Dtos.Meta.Responses;
|
||||
using SharedLibraryCore.Helpers;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using SharedLibraryCore.QueryHelper;
|
||||
using SharedLibraryCore.Services;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
namespace IW4MAdmin.Application.Meta
|
||||
{
|
||||
/// <summary>
|
||||
/// implementation of IResourceQueryHelper
|
||||
/// used to pull in penalties applied to a given client id
|
||||
/// </summary>
|
||||
public class
|
||||
ReceivedPenaltyResourceQueryHelper : IResourceQueryHelper<ClientPaginationRequest, ReceivedPenaltyResponse>
|
||||
{
|
||||
private readonly ILogger _logger;
|
||||
private readonly IDatabaseContextFactory _contextFactory;
|
||||
private readonly ApplicationConfiguration _appConfig;
|
||||
|
||||
public ReceivedPenaltyResourceQueryHelper(ILogger<ReceivedPenaltyResourceQueryHelper> logger,
|
||||
IDatabaseContextFactory contextFactory, ApplicationConfiguration appConfig)
|
||||
{
|
||||
_contextFactory = contextFactory;
|
||||
_logger = logger;
|
||||
_appConfig = appConfig;
|
||||
}
|
||||
|
||||
public async Task<ResourceQueryHelperResult<ReceivedPenaltyResponse>> QueryResource(
|
||||
ClientPaginationRequest query)
|
||||
{
|
||||
var linkedPenaltyType = Utilities.LinkedPenaltyTypes();
|
||||
await using var ctx = _contextFactory.CreateContext(enableTracking: false);
|
||||
|
||||
var linkId = await ctx.Clients.AsNoTracking()
|
||||
.Where(_client => _client.ClientId == query.ClientId)
|
||||
.Select(_client => new { _client.AliasLinkId, _client.CurrentAliasId })
|
||||
.FirstOrDefaultAsync();
|
||||
|
||||
var iqPenalties = ctx.Penalties.AsNoTracking()
|
||||
.Where(_penalty => _penalty.OffenderId == query.ClientId ||
|
||||
linkedPenaltyType.Contains(_penalty.Type) && _penalty.LinkId == linkId.AliasLinkId);
|
||||
|
||||
IQueryable<EFPenalty> iqIpLinkedPenalties = null;
|
||||
IQueryable<EFPenalty> identifierPenalties = null;
|
||||
|
||||
if (!_appConfig.EnableImplicitAccountLinking)
|
||||
{
|
||||
var usedIps = await ctx.Aliases.AsNoTracking()
|
||||
.Where(alias =>
|
||||
(alias.LinkId == linkId.AliasLinkId || alias.AliasId == linkId.CurrentAliasId) &&
|
||||
alias.IPAddress != null)
|
||||
.Select(alias => alias.IPAddress).ToListAsync();
|
||||
|
||||
identifierPenalties = ctx.PenaltyIdentifiers.AsNoTracking().Where(identifier =>
|
||||
identifier.IPv4Address != null && usedIps.Contains(identifier.IPv4Address))
|
||||
.Select(id => id.Penalty);
|
||||
|
||||
var aliasedIds = await ctx.Aliases.AsNoTracking().Where(alias => usedIps.Contains(alias.IPAddress))
|
||||
.Select(alias => alias.LinkId)
|
||||
.ToListAsync();
|
||||
|
||||
iqIpLinkedPenalties = ctx.Penalties.AsNoTracking()
|
||||
.Where(penalty =>
|
||||
linkedPenaltyType.Contains(penalty.Type) && aliasedIds.Contains(penalty.LinkId ?? -1));
|
||||
}
|
||||
|
||||
var iqAllPenalties = iqPenalties;
|
||||
|
||||
if (iqIpLinkedPenalties != null)
|
||||
{
|
||||
iqAllPenalties = iqPenalties.Union(iqIpLinkedPenalties);
|
||||
}
|
||||
|
||||
if (identifierPenalties != null)
|
||||
{
|
||||
iqAllPenalties = iqPenalties.Union(identifierPenalties);
|
||||
}
|
||||
|
||||
var penalties = await iqAllPenalties
|
||||
.Where(_penalty => _penalty.When < query.Before)
|
||||
.OrderByDescending(_penalty => _penalty.When)
|
||||
.Take(query.Count)
|
||||
.Select(_penalty => new ReceivedPenaltyResponse()
|
||||
{
|
||||
PenaltyId = _penalty.PenaltyId,
|
||||
ClientId = query.ClientId,
|
||||
Offense = _penalty.Offense,
|
||||
AutomatedOffense = _penalty.AutomatedOffense,
|
||||
OffenderClientId = _penalty.OffenderId,
|
||||
OffenderName = _penalty.Offender.CurrentAlias.Name,
|
||||
PunisherClientId = _penalty.PunisherId,
|
||||
PunisherName = _penalty.Punisher.CurrentAlias.Name,
|
||||
PenaltyType = _penalty.Type,
|
||||
When = _penalty.When,
|
||||
ExpirationDate = _penalty.Expires,
|
||||
IsLinked = _penalty.OffenderId != query.ClientId,
|
||||
IsSensitive = _penalty.Type == EFPenalty.PenaltyType.Flag
|
||||
})
|
||||
.ToListAsync();
|
||||
|
||||
return new ResourceQueryHelperResult<ReceivedPenaltyResponse>
|
||||
{
|
||||
// todo: maybe actually count
|
||||
RetrievedResultCount = penalties.Count,
|
||||
Results = penalties.Distinct()
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,63 +0,0 @@
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Dtos.Meta.Responses;
|
||||
using SharedLibraryCore.Helpers;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using SharedLibraryCore.QueryHelper;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Abstractions;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
namespace IW4MAdmin.Application.Meta
|
||||
{
|
||||
/// <summary>
|
||||
/// implementation if IResrouceQueryHerlp
|
||||
/// used to pull alias changes for given client id
|
||||
/// </summary>
|
||||
public class UpdatedAliasResourceQueryHelper : IResourceQueryHelper<ClientPaginationRequest, UpdatedAliasResponse>
|
||||
{
|
||||
private readonly ILogger _logger;
|
||||
private readonly IDatabaseContextFactory _contextFactory;
|
||||
|
||||
public UpdatedAliasResourceQueryHelper(ILogger<UpdatedAliasResourceQueryHelper> logger, IDatabaseContextFactory contextFactory)
|
||||
{
|
||||
_logger = logger;
|
||||
_contextFactory = contextFactory;
|
||||
}
|
||||
|
||||
public async Task<ResourceQueryHelperResult<UpdatedAliasResponse>> QueryResource(ClientPaginationRequest query)
|
||||
{
|
||||
await using var ctx = _contextFactory.CreateContext(enableTracking: false);
|
||||
int linkId = ctx.Clients.First(_client => _client.ClientId == query.ClientId).AliasLinkId;
|
||||
|
||||
var iqAliasUpdates = ctx.Aliases
|
||||
.Where(_alias => _alias.LinkId == linkId)
|
||||
.Where(_alias => _alias.DateAdded < query.Before)
|
||||
.Where(_alias => _alias.IPAddress != null)
|
||||
.OrderByDescending(_alias => _alias.DateAdded)
|
||||
.Select(_alias => new UpdatedAliasResponse
|
||||
{
|
||||
MetaId = _alias.AliasId,
|
||||
Name = _alias.Name,
|
||||
IPAddress = _alias.IPAddress.ConvertIPtoString(),
|
||||
When = _alias.DateAdded,
|
||||
Type = MetaType.AliasUpdate,
|
||||
IsSensitive = true
|
||||
});
|
||||
|
||||
var result = (await iqAliasUpdates
|
||||
.Take(query.Count)
|
||||
.ToListAsync())
|
||||
.Distinct();
|
||||
|
||||
|
||||
return new ResourceQueryHelperResult<UpdatedAliasResponse>
|
||||
{
|
||||
Results = result, // we can potentially have duplicates
|
||||
RetrievedResultCount = result.Count()
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,8 +1,11 @@
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using System.Linq;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
using System.Text;
|
||||
using System.Text.RegularExpressions;
|
||||
|
||||
namespace IW4MAdmin.Application.Migration
|
||||
{
|
||||
@ -12,32 +15,6 @@ namespace IW4MAdmin.Application.Migration
|
||||
/// </summary>
|
||||
class ConfigurationMigration
|
||||
{
|
||||
/// <summary>
|
||||
/// ensures required directories are created
|
||||
/// </summary>
|
||||
public static void CheckDirectories()
|
||||
{
|
||||
if (!Directory.Exists(Path.Join(Utilities.OperatingDirectory, "Plugins")))
|
||||
{
|
||||
Directory.CreateDirectory(Path.Join(Utilities.OperatingDirectory, "Plugins"));
|
||||
}
|
||||
|
||||
if (!Directory.Exists(Path.Join(Utilities.OperatingDirectory, "Database")))
|
||||
{
|
||||
Directory.CreateDirectory(Path.Join(Utilities.OperatingDirectory, "Database"));
|
||||
}
|
||||
|
||||
if (!Directory.Exists(Path.Join(Utilities.OperatingDirectory, "Log")))
|
||||
{
|
||||
Directory.CreateDirectory(Path.Join(Utilities.OperatingDirectory, "Log"));
|
||||
}
|
||||
|
||||
if (!Directory.Exists(Path.Join(Utilities.OperatingDirectory, "Localization")))
|
||||
{
|
||||
Directory.CreateDirectory(Path.Join(Utilities.OperatingDirectory, "Localization"));
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// moves existing configs from the root folder into a configs folder
|
||||
/// </summary>
|
||||
@ -53,6 +30,7 @@ namespace IW4MAdmin.Application.Migration
|
||||
|
||||
if (!Directory.Exists(configDirectory))
|
||||
{
|
||||
log?.WriteDebug($"Creating directory for configs {configDirectory}");
|
||||
Directory.CreateDirectory(configDirectory);
|
||||
}
|
||||
|
||||
@ -62,6 +40,7 @@ namespace IW4MAdmin.Application.Migration
|
||||
|
||||
foreach (var configFile in configurationFiles)
|
||||
{
|
||||
log?.WriteDebug($"Moving config file {configFile}");
|
||||
string destinationPath = Path.Join("Configuration", configFile);
|
||||
if (!File.Exists(destinationPath))
|
||||
{
|
||||
@ -72,6 +51,7 @@ namespace IW4MAdmin.Application.Migration
|
||||
if (!File.Exists(Path.Join("Database", "Database.db")) &&
|
||||
File.Exists("Database.db"))
|
||||
{
|
||||
log?.WriteDebug("Moving database file");
|
||||
File.Move("Database.db", Path.Join("Database", "Database.db"));
|
||||
}
|
||||
}
|
||||
@ -85,20 +65,5 @@ namespace IW4MAdmin.Application.Migration
|
||||
config.ManualLogPath = null;
|
||||
}
|
||||
}
|
||||
|
||||
public static void RemoveObsoletePlugins20210322()
|
||||
{
|
||||
var files = new[] {"StatsWeb.dll", "StatsWeb.Views.dll", "IW4ScriptCommands.dll"};
|
||||
|
||||
foreach (var file in files)
|
||||
{
|
||||
var path = Path.Join(Utilities.OperatingDirectory, "Plugins", file);
|
||||
|
||||
if (File.Exists(path))
|
||||
{
|
||||
File.Delete(path);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,23 +0,0 @@
|
||||
using System;
|
||||
using System.Linq;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Abstractions;
|
||||
using Data.Models.Client.Stats;
|
||||
|
||||
namespace IW4MAdmin.Application.Migration
|
||||
{
|
||||
public static class DatabaseHousekeeping
|
||||
{
|
||||
private static readonly DateTime CutoffDate = DateTime.UtcNow.AddMonths(-6);
|
||||
|
||||
public static async Task RemoveOldRatings(IDatabaseContextFactory contextFactory, CancellationToken token)
|
||||
{
|
||||
await using var context = contextFactory.CreateContext();
|
||||
var dbSet = context.Set<EFRating>();
|
||||
var itemsToDelete = dbSet.Where(rating => rating.When <= CutoffDate);
|
||||
dbSet.RemoveRange(itemsToDelete);
|
||||
await context.SaveChangesAsync(token);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,12 +0,0 @@
|
||||
using System;
|
||||
using System.Threading;
|
||||
|
||||
namespace IW4MAdmin.Application.Misc;
|
||||
|
||||
public class AsyncResult : IAsyncResult
|
||||
{
|
||||
public object AsyncState { get; set; }
|
||||
public WaitHandle AsyncWaitHandle { get; set; }
|
||||
public bool CompletedSynchronously { get; set; }
|
||||
public bool IsCompleted { get; set; }
|
||||
}
|
||||
@ -1,110 +0,0 @@
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Exceptions;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using System;
|
||||
using System.IO;
|
||||
using System.Text.Json;
|
||||
using System.Text.Json.Serialization;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using JsonSerializer = System.Text.Json.JsonSerializer;
|
||||
|
||||
namespace IW4MAdmin.Application.Misc
|
||||
{
|
||||
/// <summary>
|
||||
/// default implementation of IConfigurationHandler
|
||||
/// </summary>
|
||||
/// <typeparam name="T">base configuration type</typeparam>
|
||||
public class BaseConfigurationHandler<T> : IConfigurationHandler<T> where T : IBaseConfiguration
|
||||
{
|
||||
private T _configuration;
|
||||
private readonly SemaphoreSlim _onSaving;
|
||||
private readonly JsonSerializerOptions _serializerOptions;
|
||||
|
||||
|
||||
public BaseConfigurationHandler(string fileName)
|
||||
{
|
||||
_serializerOptions = new JsonSerializerOptions
|
||||
{
|
||||
WriteIndented = true,
|
||||
Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping
|
||||
};
|
||||
_serializerOptions.Converters.Add(new JsonStringEnumConverter());
|
||||
_onSaving = new SemaphoreSlim(1, 1);
|
||||
FileName = Path.Join(Utilities.OperatingDirectory, "Configuration", $"{fileName}.json");
|
||||
}
|
||||
|
||||
public BaseConfigurationHandler() : this(typeof(T).Name)
|
||||
{
|
||||
}
|
||||
|
||||
~BaseConfigurationHandler()
|
||||
{
|
||||
_onSaving.Dispose();
|
||||
}
|
||||
|
||||
public string FileName { get; }
|
||||
|
||||
public async Task BuildAsync()
|
||||
{
|
||||
try
|
||||
{
|
||||
await _onSaving.WaitAsync();
|
||||
await using var fileStream = File.OpenRead(FileName);
|
||||
_configuration = await JsonSerializer.DeserializeAsync<T>(fileStream, _serializerOptions);
|
||||
await fileStream.DisposeAsync();
|
||||
}
|
||||
|
||||
catch (FileNotFoundException)
|
||||
{
|
||||
_configuration = default;
|
||||
}
|
||||
|
||||
catch (Exception e)
|
||||
{
|
||||
throw new ConfigurationException("Could not load configuration")
|
||||
{
|
||||
Errors = new[] { e.Message },
|
||||
ConfigurationFileName = FileName
|
||||
};
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (_onSaving.CurrentCount == 0)
|
||||
{
|
||||
_onSaving.Release(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public async Task Save()
|
||||
{
|
||||
try
|
||||
{
|
||||
await _onSaving.WaitAsync();
|
||||
|
||||
await using var fileStream = File.Create(FileName);
|
||||
await JsonSerializer.SerializeAsync(fileStream, _configuration, _serializerOptions);
|
||||
await fileStream.DisposeAsync();
|
||||
}
|
||||
|
||||
finally
|
||||
{
|
||||
if (_onSaving.CurrentCount == 0)
|
||||
{
|
||||
_onSaving.Release(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public T Configuration()
|
||||
{
|
||||
return _configuration;
|
||||
}
|
||||
|
||||
public void Set(T config)
|
||||
{
|
||||
_configuration = config;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,120 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using Data.Models;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Misc
|
||||
{
|
||||
/// <summary>
|
||||
/// implementation of IClientNoticeMessageFormatter
|
||||
/// </summary>
|
||||
public class ClientNoticeMessageFormatter : IClientNoticeMessageFormatter
|
||||
{
|
||||
private readonly ITranslationLookup _transLookup;
|
||||
private readonly ApplicationConfiguration _appConfig;
|
||||
|
||||
public ClientNoticeMessageFormatter(ITranslationLookup transLookup, ApplicationConfiguration appConfig)
|
||||
{
|
||||
_transLookup = transLookup;
|
||||
_appConfig = appConfig;
|
||||
}
|
||||
|
||||
public string BuildFormattedMessage(IRConParserConfiguration config, EFPenalty currentPenalty, EFPenalty originalPenalty = null)
|
||||
{
|
||||
var isNewLineSeparator = config.NoticeLineSeparator == Environment.NewLine;
|
||||
var penalty = originalPenalty ?? currentPenalty;
|
||||
var builder = new StringBuilder();
|
||||
// build the top level header
|
||||
var header = _transLookup[$"SERVER_{penalty.Type.ToString().ToUpper()}_TEXT"];
|
||||
builder.Append(header);
|
||||
builder.Append(config.NoticeLineSeparator);
|
||||
// build the reason
|
||||
var reason = _transLookup["GAME_MESSAGE_PENALTY_REASON"].FormatExt(penalty.Offense.FormatMessageForEngine(config));
|
||||
|
||||
if (isNewLineSeparator)
|
||||
{
|
||||
foreach (var splitReason in SplitOverMaxLength(reason, config.NoticeMaxCharactersPerLine))
|
||||
{
|
||||
builder.Append(splitReason);
|
||||
builder.Append(config.NoticeLineSeparator);
|
||||
}
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
builder.Append(reason);
|
||||
builder.Append(config.NoticeLineSeparator);
|
||||
}
|
||||
|
||||
if (penalty.Type == EFPenalty.PenaltyType.TempBan)
|
||||
{
|
||||
// build the time remaining if temporary
|
||||
var timeRemainingValue = penalty.Expires.HasValue
|
||||
? (penalty.Expires - DateTime.UtcNow).Value.HumanizeForCurrentCulture()
|
||||
: "--";
|
||||
var timeRemaining = _transLookup["GAME_MESSAGE_PENALTY_TIME_REMAINING"].FormatExt(timeRemainingValue);
|
||||
|
||||
if (isNewLineSeparator)
|
||||
{
|
||||
foreach (var splitReason in SplitOverMaxLength(timeRemaining, config.NoticeMaxCharactersPerLine))
|
||||
{
|
||||
builder.Append(splitReason);
|
||||
builder.Append(config.NoticeLineSeparator);
|
||||
}
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
builder.Append(timeRemaining);
|
||||
}
|
||||
}
|
||||
|
||||
if (penalty.Type == EFPenalty.PenaltyType.Ban)
|
||||
{
|
||||
// provide a place to appeal the ban (should always be specified but including a placeholder just incase)
|
||||
builder.Append(_transLookup["GAME_MESSAGE_PENALTY_APPEAL"].FormatExt(_appConfig.ContactUri ?? "--"));
|
||||
}
|
||||
|
||||
// final format looks something like:
|
||||
/*
|
||||
* You are permanently banned
|
||||
* Reason - toxic behavior
|
||||
* Visit example.com to appeal
|
||||
*/
|
||||
|
||||
return builder.ToString();
|
||||
}
|
||||
|
||||
private static IEnumerable<string> SplitOverMaxLength(string source, int maxCharactersPerLine)
|
||||
{
|
||||
if (source.Length <= maxCharactersPerLine)
|
||||
{
|
||||
return new[] {source};
|
||||
}
|
||||
|
||||
var segments = new List<string>();
|
||||
var currentLocation = 0;
|
||||
while (currentLocation < source.Length)
|
||||
{
|
||||
var nextLocation = currentLocation + maxCharactersPerLine;
|
||||
// there's probably a more efficient way to do this but this is readable
|
||||
segments.Add(string.Concat(
|
||||
source
|
||||
.Skip(currentLocation)
|
||||
.Take(Math.Min(maxCharactersPerLine, source.Length - currentLocation))));
|
||||
currentLocation = nextLocation;
|
||||
}
|
||||
|
||||
if (currentLocation < source.Length)
|
||||
{
|
||||
segments.Add(source.Substring(currentLocation, source.Length - currentLocation));
|
||||
}
|
||||
|
||||
return segments;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,13 +0,0 @@
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Misc;
|
||||
|
||||
public class GeoLocationResult : IGeoLocationResult
|
||||
{
|
||||
public string Country { get; set; }
|
||||
public string CountryCode { get; set; }
|
||||
public string Region { get; set; }
|
||||
public string ASN { get; set; }
|
||||
public string Timezone { get; set; }
|
||||
public string Organization { get; set; }
|
||||
}
|
||||
@ -1,40 +0,0 @@
|
||||
using System;
|
||||
using System.Threading.Tasks;
|
||||
using MaxMind.GeoIP2;
|
||||
using MaxMind.GeoIP2.Responses;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Misc;
|
||||
|
||||
public class GeoLocationService : IGeoLocationService
|
||||
{
|
||||
private readonly string _sourceAddress;
|
||||
|
||||
public GeoLocationService(string sourceAddress)
|
||||
{
|
||||
_sourceAddress = sourceAddress;
|
||||
}
|
||||
|
||||
public Task<IGeoLocationResult> Locate(string address)
|
||||
{
|
||||
CountryResponse country = null;
|
||||
|
||||
try
|
||||
{
|
||||
using var reader = new DatabaseReader(_sourceAddress);
|
||||
country = reader.Country(address);
|
||||
}
|
||||
catch
|
||||
{
|
||||
// ignored
|
||||
}
|
||||
|
||||
var response = new GeoLocationResult
|
||||
{
|
||||
Country = country?.Country.Name ?? "Unknown",
|
||||
CountryCode = country?.Country.IsoCode ?? ""
|
||||
};
|
||||
|
||||
return Task.FromResult((IGeoLocationResult)response);
|
||||
}
|
||||
}
|
||||
@ -1,171 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Concurrent;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Models;
|
||||
using IW4MAdmin.Application.Plugin.Script;
|
||||
using Microsoft.Extensions.DependencyInjection;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using InteractionRegistrationCallback =
|
||||
System.Func<int?, Data.Models.Reference.Game?, System.Threading.CancellationToken,
|
||||
System.Threading.Tasks.Task<SharedLibraryCore.Interfaces.IInteractionData>>;
|
||||
|
||||
namespace IW4MAdmin.Application.Misc;
|
||||
|
||||
public class InteractionRegistration : IInteractionRegistration
|
||||
{
|
||||
private readonly ILogger<InteractionRegistration> _logger;
|
||||
private readonly IServiceProvider _serviceProvider;
|
||||
private readonly ConcurrentDictionary<string, InteractionRegistrationCallback> _interactions = new();
|
||||
|
||||
public InteractionRegistration(ILogger<InteractionRegistration> logger, IServiceProvider serviceProvider)
|
||||
{
|
||||
_logger = logger;
|
||||
_serviceProvider = serviceProvider;
|
||||
}
|
||||
|
||||
public void RegisterScriptInteraction(string interactionName, string source, Delegate interactionRegistration)
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(source))
|
||||
{
|
||||
throw new ArgumentException("Script interaction source cannot be null");
|
||||
}
|
||||
|
||||
_logger.LogDebug("Registering script interaction {InteractionName} from {Source}", interactionName, source);
|
||||
|
||||
var plugin = _serviceProvider.GetRequiredService<IEnumerable<IPlugin>>()
|
||||
.FirstOrDefault(plugin => plugin.Name == source);
|
||||
|
||||
if (plugin is not ScriptPlugin scriptPlugin)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
Task<IInteractionData> WrappedDelegate(int? clientId, Reference.Game? game, CancellationToken token) =>
|
||||
Task.FromResult(
|
||||
scriptPlugin.WrapDelegate<IInteractionData>(interactionRegistration, token, clientId, game, token));
|
||||
|
||||
if (!_interactions.ContainsKey(interactionName))
|
||||
{
|
||||
_interactions.TryAdd(interactionName, WrappedDelegate);
|
||||
}
|
||||
else
|
||||
{
|
||||
_interactions[interactionName] = WrappedDelegate;
|
||||
}
|
||||
}
|
||||
|
||||
public void RegisterInteraction(string interactionName, InteractionRegistrationCallback interactionRegistration)
|
||||
{
|
||||
if (!_interactions.ContainsKey(interactionName))
|
||||
{
|
||||
_logger.LogDebug("Registering interaction {InteractionName}", interactionName);
|
||||
_interactions.TryAdd(interactionName, interactionRegistration);
|
||||
}
|
||||
else
|
||||
{
|
||||
_logger.LogDebug("Updating interaction {InteractionName}", interactionName);
|
||||
_interactions[interactionName] = interactionRegistration;
|
||||
}
|
||||
}
|
||||
|
||||
public void UnregisterInteraction(string interactionName)
|
||||
{
|
||||
if (!_interactions.ContainsKey(interactionName))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
_logger.LogDebug("Unregistering interaction {InteractionName}", interactionName);
|
||||
_interactions.TryRemove(interactionName, out _);
|
||||
}
|
||||
|
||||
public async Task<IEnumerable<IInteractionData>> GetInteractions(string interactionPrefix = null,
|
||||
int? clientId = null,
|
||||
Reference.Game? game = null, CancellationToken token = default)
|
||||
{
|
||||
return await GetInteractionsInternal(interactionPrefix, clientId, game, token);
|
||||
}
|
||||
|
||||
public async Task<string> ProcessInteraction(string interactionId, int originId, int? targetId = null,
|
||||
Reference.Game? game = null, IDictionary<string, string> meta = null, CancellationToken token = default)
|
||||
{
|
||||
if (!_interactions.ContainsKey(interactionId))
|
||||
{
|
||||
throw new ArgumentException($"Interaction with ID {interactionId} has not been registered");
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
var interaction = await _interactions[interactionId](targetId, game, token);
|
||||
|
||||
if (interaction.Action is not null)
|
||||
{
|
||||
return await interaction.Action(originId, targetId, game, meta, token);
|
||||
}
|
||||
|
||||
if (interaction.ScriptAction is not null)
|
||||
{
|
||||
foreach (var plugin in _serviceProvider.GetRequiredService<IEnumerable<IPlugin>>())
|
||||
{
|
||||
if (plugin is not ScriptPlugin scriptPlugin || scriptPlugin.Name != interaction.Source)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
return scriptPlugin.ExecuteAction<string>(interaction.ScriptAction, token, originId, targetId, game, meta,
|
||||
token);
|
||||
}
|
||||
|
||||
foreach (var plugin in _serviceProvider.GetRequiredService<IEnumerable<IPluginV2>>())
|
||||
{
|
||||
if (plugin is not ScriptPluginV2 scriptPlugin || scriptPlugin.Name != interaction.Source)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
return scriptPlugin
|
||||
.QueryWithErrorHandling(interaction.ScriptAction, originId, targetId, game, meta, token)
|
||||
?.ToString();
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogWarning(ex,
|
||||
"Could not process interaction for {InteractionName} and OriginId {ClientId}",
|
||||
interactionId, originId);
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
private async Task<IEnumerable<IInteractionData>> GetInteractionsInternal(string prefix = null,
|
||||
int? clientId = null, Reference.Game? game = null, CancellationToken token = default)
|
||||
{
|
||||
var interactions = _interactions
|
||||
.Where(interaction => string.IsNullOrWhiteSpace(prefix) || interaction.Key.StartsWith(prefix)).Select(
|
||||
async kvp =>
|
||||
{
|
||||
try
|
||||
{
|
||||
return await kvp.Value(clientId, game, token);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogWarning(ex,
|
||||
"Could not get interaction for {InteractionName} and ClientId {ClientId}",
|
||||
kvp.Key,
|
||||
clientId);
|
||||
return null;
|
||||
}
|
||||
});
|
||||
|
||||
return (await Task.WhenAll(interactions))
|
||||
.Where(interaction => interaction is not null)
|
||||
.ToList();
|
||||
}
|
||||
}
|
||||
@ -1,57 +0,0 @@
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
namespace IW4MAdmin.Application.Misc
|
||||
{
|
||||
/// <summary>
|
||||
/// dto class for handling log path generation
|
||||
/// </summary>
|
||||
public class LogPathGeneratorInfo
|
||||
{
|
||||
/// <summary>
|
||||
/// directory under the paths where data comes from by default
|
||||
/// <remarks>fs_basegame</remarks>
|
||||
/// </summary>
|
||||
public string BaseGameDirectory { get; set; } = "";
|
||||
|
||||
/// <summary>
|
||||
/// base game root path
|
||||
/// <remarks>fs_basepath</remarks>
|
||||
/// </summary>
|
||||
public string BasePathDirectory { get; set; } = "";
|
||||
|
||||
/// <summary>
|
||||
/// directory for local storage
|
||||
/// <remarks>fs_homepath</remarks>
|
||||
/// </summary>
|
||||
public string HomePathDirectory { get; set; } = "";
|
||||
|
||||
/// <summary>
|
||||
/// overide game directory
|
||||
/// <remarks>plugin driven</remarks>
|
||||
/// </summary>
|
||||
public string GameDirectory { get; set; } = "";
|
||||
|
||||
/// <summary>
|
||||
/// game director
|
||||
/// <remarks>fs_game</remarks>
|
||||
/// </summary>
|
||||
public string ModDirectory { get; set; } = "";
|
||||
|
||||
/// <summary>
|
||||
/// log file name
|
||||
/// <remarks>g_log</remarks>
|
||||
/// </summary>
|
||||
public string LogFile { get; set; } = "";
|
||||
|
||||
/// <summary>
|
||||
/// indicates if running on windows
|
||||
/// </summary>
|
||||
public bool IsWindows { get; set; } = true;
|
||||
|
||||
/// <summary>
|
||||
/// indicates that the game does not log to the mods folder (when mod is loaded),
|
||||
/// but rather always to the fs_basegame directory
|
||||
/// </summary>
|
||||
public bool IsOneLog { get; set; }
|
||||
}
|
||||
}
|
||||
@ -1,47 +1,124 @@
|
||||
using System;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using ILogger = SharedLibraryCore.Interfaces.ILogger;
|
||||
using SharedLibraryCore;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using System.Threading;
|
||||
|
||||
namespace IW4MAdmin.Application
|
||||
{
|
||||
[Obsolete]
|
||||
public class Logger : ILogger
|
||||
class Logger : SharedLibraryCore.Interfaces.ILogger
|
||||
{
|
||||
private readonly Microsoft.Extensions.Logging.ILogger _logger;
|
||||
|
||||
public Logger(ILogger<Logger> logger)
|
||||
enum LogType
|
||||
{
|
||||
_logger = logger;
|
||||
Verbose,
|
||||
Info,
|
||||
Debug,
|
||||
Warning,
|
||||
Error,
|
||||
Assert
|
||||
}
|
||||
|
||||
readonly string FileName;
|
||||
readonly SemaphoreSlim OnLogWriting;
|
||||
static readonly short MAX_LOG_FILES = 10;
|
||||
|
||||
public Logger(string fn)
|
||||
{
|
||||
FileName = Path.Join(Utilities.OperatingDirectory, "Log", $"{fn}.log");
|
||||
OnLogWriting = new SemaphoreSlim(1, 1);
|
||||
RotateLogs();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// rotates logs when log is initialized
|
||||
/// </summary>
|
||||
private void RotateLogs()
|
||||
{
|
||||
string maxLog = FileName + MAX_LOG_FILES;
|
||||
|
||||
if (File.Exists(maxLog))
|
||||
{
|
||||
File.Delete(maxLog);
|
||||
}
|
||||
|
||||
for (int i = MAX_LOG_FILES - 1; i >= 0; i--)
|
||||
{
|
||||
string logToMove = i == 0 ? FileName : FileName + i;
|
||||
string movedLogName = FileName + (i + 1);
|
||||
|
||||
if (File.Exists(logToMove))
|
||||
{
|
||||
File.Move(logToMove, movedLogName);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void Write(string msg, LogType type)
|
||||
{
|
||||
OnLogWriting.Wait();
|
||||
|
||||
string stringType = type.ToString();
|
||||
|
||||
try
|
||||
{
|
||||
stringType = Utilities.CurrentLocalization.LocalizationIndex[$"GLOBAL_{type.ToString().ToUpper()}"];
|
||||
}
|
||||
|
||||
catch (Exception) { }
|
||||
|
||||
string LogLine = $"[{DateTime.Now.ToString("MM.dd.yyy HH:mm:ss.fff")}] - {stringType}: {msg}";
|
||||
try
|
||||
{
|
||||
#if DEBUG
|
||||
// lets keep it simple and dispose of everything quickly as logging wont be that much (relatively)
|
||||
Console.WriteLine(LogLine);
|
||||
File.AppendAllText(FileName, LogLine + Environment.NewLine);
|
||||
#else
|
||||
if (type == LogType.Error || type == LogType.Verbose)
|
||||
Console.WriteLine(LogLine);
|
||||
//if (type != LogType.Debug)
|
||||
File.AppendAllText(FileName, $"{LogLine}{Environment.NewLine}");
|
||||
#endif
|
||||
}
|
||||
|
||||
catch (Exception ex)
|
||||
{
|
||||
Console.WriteLine("Well.. It looks like your machine can't event write to the log file. That's something else...");
|
||||
Console.WriteLine(ex.GetExceptionInfo());
|
||||
}
|
||||
|
||||
OnLogWriting.Release(1);
|
||||
}
|
||||
|
||||
public void WriteVerbose(string msg)
|
||||
{
|
||||
_logger.LogInformation(msg);
|
||||
Write(msg, LogType.Verbose);
|
||||
}
|
||||
|
||||
public void WriteDebug(string msg)
|
||||
{
|
||||
_logger.LogDebug(msg);
|
||||
Write(msg, LogType.Debug);
|
||||
}
|
||||
|
||||
public void WriteError(string msg)
|
||||
{
|
||||
_logger.LogError(msg);
|
||||
Write(msg, LogType.Error);
|
||||
}
|
||||
|
||||
public void WriteInfo(string msg)
|
||||
{
|
||||
WriteVerbose(msg);
|
||||
Write(msg, LogType.Info);
|
||||
}
|
||||
|
||||
public void WriteWarning(string msg)
|
||||
{
|
||||
_logger.LogWarning(msg);
|
||||
Write(msg, LogType.Warning);
|
||||
}
|
||||
|
||||
public void WriteAssert(bool condition, string msg)
|
||||
{
|
||||
throw new NotImplementedException();
|
||||
if (!condition)
|
||||
Write(msg, LogType.Assert);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,175 +0,0 @@
|
||||
using IW4MAdmin.Application.API.Master;
|
||||
using RestEase;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Helpers;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using System;
|
||||
using System.Linq;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
namespace IW4MAdmin.Application.Misc
|
||||
{
|
||||
/// <summary>
|
||||
/// implementation of IMasterCommunication
|
||||
/// talks to the master server
|
||||
/// </summary>
|
||||
class MasterCommunication : IMasterCommunication
|
||||
{
|
||||
private readonly ILogger _logger;
|
||||
private readonly ITranslationLookup _transLookup;
|
||||
private readonly IMasterApi _apiInstance;
|
||||
private readonly IManager _manager;
|
||||
private readonly ApplicationConfiguration _appConfig;
|
||||
private readonly BuildNumber _fallbackVersion = BuildNumber.Parse("99.99.99.99");
|
||||
private readonly int _apiVersion = 1;
|
||||
private bool _firstHeartBeat = true;
|
||||
private static readonly TimeSpan Interval = TimeSpan.FromSeconds(30);
|
||||
|
||||
public MasterCommunication(ILogger<MasterCommunication> logger, ApplicationConfiguration appConfig, ITranslationLookup translationLookup, IMasterApi apiInstance, IManager manager)
|
||||
{
|
||||
_logger = logger;
|
||||
_transLookup = translationLookup;
|
||||
_apiInstance = apiInstance;
|
||||
_appConfig = appConfig;
|
||||
_manager = manager;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// checks for latest version of the application
|
||||
/// notifies user if an update is available
|
||||
/// </summary>
|
||||
/// <returns></returns>
|
||||
public async Task CheckVersion()
|
||||
{
|
||||
var version = new VersionInfo()
|
||||
{
|
||||
CurrentVersionStable = _fallbackVersion
|
||||
};
|
||||
|
||||
try
|
||||
{
|
||||
version = await _apiInstance.GetVersion(_apiVersion);
|
||||
}
|
||||
|
||||
catch (Exception e)
|
||||
{
|
||||
_logger.LogWarning(e, "Unable to retrieve IW4MAdmin version information");
|
||||
}
|
||||
|
||||
if (version.CurrentVersionStable == _fallbackVersion)
|
||||
{
|
||||
Console.ForegroundColor = ConsoleColor.Red;
|
||||
Console.WriteLine(_transLookup["MANAGER_VERSION_FAIL"]);
|
||||
Console.ForegroundColor = ConsoleColor.Gray;
|
||||
}
|
||||
|
||||
#if !PRERELEASE
|
||||
else if (version.CurrentVersionStable > Program.Version)
|
||||
{
|
||||
Console.ForegroundColor = ConsoleColor.DarkYellow;
|
||||
Console.WriteLine($"IW4MAdmin {_transLookup["MANAGER_VERSION_UPDATE"]} [v{version.CurrentVersionStable.ToString()}]");
|
||||
Console.WriteLine(_transLookup["MANAGER_VERSION_CURRENT"].FormatExt($"[v{Program.Version.ToString()}]"));
|
||||
Console.ForegroundColor = ConsoleColor.Gray;
|
||||
}
|
||||
#else
|
||||
else if (version.CurrentVersionPrerelease > Program.Version)
|
||||
{
|
||||
Console.ForegroundColor = ConsoleColor.DarkYellow;
|
||||
Console.WriteLine($"IW4MAdmin-Prerelease {_transLookup["MANAGER_VERSION_UPDATE"]} [v{version.CurrentVersionPrerelease.ToString()}-pr]");
|
||||
Console.WriteLine(_transLookup["MANAGER_VERSION_CURRENT"].FormatExt($"[v{Program.Version.ToString()}-pr]"));
|
||||
Console.ForegroundColor = ConsoleColor.Gray;
|
||||
}
|
||||
#endif
|
||||
else
|
||||
{
|
||||
Console.ForegroundColor = ConsoleColor.Green;
|
||||
Console.WriteLine(_transLookup["MANAGER_VERSION_SUCCESS"]);
|
||||
Console.ForegroundColor = ConsoleColor.Gray;
|
||||
}
|
||||
}
|
||||
|
||||
public async Task RunUploadStatus(CancellationToken token)
|
||||
{
|
||||
while (!token.IsCancellationRequested)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (_manager.IsRunning)
|
||||
{
|
||||
await UploadStatus();
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogWarning("Could not send heartbeat - {Message}", ex.Message);
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
await Task.Delay(Interval, token);
|
||||
}
|
||||
catch
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private async Task UploadStatus()
|
||||
{
|
||||
if (_firstHeartBeat)
|
||||
{
|
||||
var token = await _apiInstance.Authenticate(new AuthenticationId
|
||||
{
|
||||
Id = _appConfig.Id
|
||||
});
|
||||
|
||||
_apiInstance.AuthorizationToken = $"Bearer {token.AccessToken}";
|
||||
}
|
||||
|
||||
var instance = new ApiInstance
|
||||
{
|
||||
Id = _appConfig.Id,
|
||||
Uptime = (int)(DateTime.UtcNow - (_manager as ApplicationManager).StartTime).TotalSeconds,
|
||||
Version = Program.Version,
|
||||
Servers = _manager.GetServers().Select(s =>
|
||||
new ApiServer()
|
||||
{
|
||||
ClientNum = s.ClientNum,
|
||||
Game = s.GameName.ToString(),
|
||||
Version = s.Version,
|
||||
Gametype = s.Gametype,
|
||||
Hostname = s.Hostname,
|
||||
Map = s.CurrentMap.Name,
|
||||
MaxClientNum = s.MaxClients,
|
||||
Id = s.EndPoint,
|
||||
Port = (short)s.ListenPort,
|
||||
IPAddress = s.ListenAddress
|
||||
}).ToList(),
|
||||
WebfrontUrl = _appConfig.WebfrontUrl
|
||||
};
|
||||
|
||||
Response<ResultMessage> response;
|
||||
|
||||
if (_firstHeartBeat)
|
||||
{
|
||||
response = await _apiInstance.AddInstance(instance);
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
response = await _apiInstance.UpdateInstance(instance.Id, instance);
|
||||
_firstHeartBeat = false;
|
||||
}
|
||||
|
||||
if (response.ResponseMessage.StatusCode != System.Net.HttpStatusCode.OK)
|
||||
{
|
||||
_logger.LogWarning("Non success response code from master is {StatusCode}, message is {Message}", response.ResponseMessage.StatusCode, response.StringContent);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,312 +0,0 @@
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using SharedLibraryCore.Database.Models;
|
||||
using SharedLibraryCore.Dtos;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using SharedLibraryCore.QueryHelper;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Abstractions;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
using Data.Models;
|
||||
|
||||
namespace IW4MAdmin.Application.Misc
|
||||
{
|
||||
/// <summary>
|
||||
/// implementation of IMetaService
|
||||
/// used to add and retrieve runtime and persistent meta
|
||||
/// </summary>
|
||||
[Obsolete("Use MetaServiceV2")]
|
||||
public class MetaService : IMetaService
|
||||
{
|
||||
private readonly IDictionary<MetaType, List<dynamic>> _metaActions;
|
||||
private readonly IDatabaseContextFactory _contextFactory;
|
||||
private readonly ILogger _logger;
|
||||
|
||||
public MetaService(ILogger<MetaService> logger, IDatabaseContextFactory contextFactory)
|
||||
{
|
||||
_logger = logger;
|
||||
_metaActions = new Dictionary<MetaType, List<dynamic>>();
|
||||
_contextFactory = contextFactory;
|
||||
}
|
||||
|
||||
public async Task AddPersistentMeta(string metaKey, string metaValue, EFClient client, EFMeta linkedMeta = null)
|
||||
{
|
||||
// this seems to happen if the client disconnects before they've had time to authenticate and be added
|
||||
if (client.ClientId < 1)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
await using var ctx = _contextFactory.CreateContext();
|
||||
|
||||
var existingMeta = await ctx.EFMeta
|
||||
.Where(_meta => _meta.Key == metaKey)
|
||||
.Where(_meta => _meta.ClientId == client.ClientId)
|
||||
.FirstOrDefaultAsync();
|
||||
|
||||
if (existingMeta != null)
|
||||
{
|
||||
existingMeta.Value = metaValue;
|
||||
existingMeta.Updated = DateTime.UtcNow;
|
||||
existingMeta.LinkedMetaId = linkedMeta?.MetaId;
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
ctx.EFMeta.Add(new EFMeta()
|
||||
{
|
||||
ClientId = client.ClientId,
|
||||
Created = DateTime.UtcNow,
|
||||
Key = metaKey,
|
||||
Value = metaValue,
|
||||
LinkedMetaId = linkedMeta?.MetaId
|
||||
});
|
||||
}
|
||||
|
||||
await ctx.SaveChangesAsync();
|
||||
}
|
||||
|
||||
public async Task SetPersistentMeta(string metaKey, string metaValue, int clientId)
|
||||
{
|
||||
await AddPersistentMeta(metaKey, metaValue, new EFClient { ClientId = clientId });
|
||||
}
|
||||
|
||||
public async Task IncrementPersistentMeta(string metaKey, int incrementAmount, int clientId)
|
||||
{
|
||||
var existingMeta = await GetPersistentMeta(metaKey, new EFClient { ClientId = clientId });
|
||||
|
||||
if (!long.TryParse(existingMeta?.Value ?? "0", out var existingValue))
|
||||
{
|
||||
existingValue = 0;
|
||||
}
|
||||
|
||||
var newValue = existingValue + incrementAmount;
|
||||
await SetPersistentMeta(metaKey, newValue.ToString(), clientId);
|
||||
}
|
||||
|
||||
public async Task DecrementPersistentMeta(string metaKey, int decrementAmount, int clientId)
|
||||
{
|
||||
await IncrementPersistentMeta(metaKey, -decrementAmount, clientId);
|
||||
}
|
||||
|
||||
public async Task AddPersistentMeta(string metaKey, string metaValue)
|
||||
{
|
||||
await using var ctx = _contextFactory.CreateContext();
|
||||
|
||||
var existingMeta = await ctx.EFMeta
|
||||
.Where(meta => meta.Key == metaKey)
|
||||
.Where(meta => meta.ClientId == null)
|
||||
.ToListAsync();
|
||||
|
||||
var matchValues = existingMeta
|
||||
.Where(meta => meta.Value == metaValue)
|
||||
.ToArray();
|
||||
|
||||
if (matchValues.Any())
|
||||
{
|
||||
foreach (var meta in matchValues)
|
||||
{
|
||||
_logger.LogDebug("Updating existing meta with key {key} and id {id}", meta.Key, meta.MetaId);
|
||||
meta.Value = metaValue;
|
||||
meta.Updated = DateTime.UtcNow;
|
||||
}
|
||||
|
||||
await ctx.SaveChangesAsync();
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
_logger.LogDebug("Adding new meta with key {key}", metaKey);
|
||||
|
||||
ctx.EFMeta.Add(new EFMeta()
|
||||
{
|
||||
Created = DateTime.UtcNow,
|
||||
Key = metaKey,
|
||||
Value = metaValue
|
||||
});
|
||||
|
||||
await ctx.SaveChangesAsync();
|
||||
}
|
||||
}
|
||||
|
||||
public async Task RemovePersistentMeta(string metaKey, EFClient client)
|
||||
{
|
||||
await using var context = _contextFactory.CreateContext();
|
||||
|
||||
var existingMeta = await context.EFMeta
|
||||
.FirstOrDefaultAsync(meta => meta.Key == metaKey && meta.ClientId == client.ClientId);
|
||||
|
||||
if (existingMeta == null)
|
||||
{
|
||||
_logger.LogDebug("No meta with key {key} found for client id {id}", metaKey, client.ClientId);
|
||||
return;
|
||||
}
|
||||
|
||||
_logger.LogDebug("Removing meta for key {key} with id {id}", metaKey, existingMeta.MetaId);
|
||||
context.EFMeta.Remove(existingMeta);
|
||||
await context.SaveChangesAsync();
|
||||
}
|
||||
|
||||
public async Task RemovePersistentMeta(string metaKey, string metaValue = null)
|
||||
{
|
||||
await using var context = _contextFactory.CreateContext(enableTracking: false);
|
||||
var existingMeta = await context.EFMeta
|
||||
.Where(meta => meta.Key == metaKey)
|
||||
.Where(meta => meta.ClientId == null)
|
||||
.ToListAsync();
|
||||
|
||||
if (metaValue == null)
|
||||
{
|
||||
_logger.LogDebug("Removing all meta for key {key} with ids [{ids}] ", metaKey, string.Join(", ", existingMeta.Select(meta => meta.MetaId)));
|
||||
existingMeta.ForEach(meta => context.Remove(existingMeta));
|
||||
await context.SaveChangesAsync();
|
||||
return;
|
||||
}
|
||||
|
||||
var foundMeta = existingMeta.FirstOrDefault(meta => meta.Value == metaValue);
|
||||
|
||||
if (foundMeta != null)
|
||||
{
|
||||
_logger.LogDebug("Removing meta for key {key} with id {id}", metaKey, foundMeta.MetaId);
|
||||
context.Remove(foundMeta);
|
||||
await context.SaveChangesAsync();
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<EFMeta> GetPersistentMeta(string metaKey, EFClient client)
|
||||
{
|
||||
await using var ctx = _contextFactory.CreateContext(enableTracking: false);
|
||||
|
||||
return await ctx.EFMeta
|
||||
.Where(_meta => _meta.Key == metaKey)
|
||||
.Where(_meta => _meta.ClientId == client.ClientId)
|
||||
.Select(_meta => new EFMeta()
|
||||
{
|
||||
MetaId = _meta.MetaId,
|
||||
Key = _meta.Key,
|
||||
ClientId = _meta.ClientId,
|
||||
Value = _meta.Value,
|
||||
LinkedMetaId = _meta.LinkedMetaId,
|
||||
LinkedMeta = _meta.LinkedMetaId != null ? new EFMeta()
|
||||
{
|
||||
MetaId = _meta.LinkedMeta.MetaId,
|
||||
Key = _meta.LinkedMeta.Key,
|
||||
Value = _meta.LinkedMeta.Value
|
||||
} : null
|
||||
})
|
||||
.FirstOrDefaultAsync();
|
||||
}
|
||||
|
||||
public async Task<IEnumerable<EFMeta>> GetPersistentMeta(string metaKey)
|
||||
{
|
||||
await using var context = _contextFactory.CreateContext(enableTracking: false);
|
||||
return await context.EFMeta
|
||||
.Where(meta => meta.Key == metaKey)
|
||||
.Where(meta => meta.ClientId == null)
|
||||
.Select(meta => new EFMeta
|
||||
{
|
||||
MetaId = meta.MetaId,
|
||||
Key = meta.Key,
|
||||
ClientId = meta.ClientId,
|
||||
Value = meta.Value,
|
||||
})
|
||||
.ToListAsync();
|
||||
}
|
||||
|
||||
public void AddRuntimeMeta<T, V>(MetaType metaKey, Func<T, Task<IEnumerable<V>>> metaAction) where T : PaginationRequest where V : IClientMeta
|
||||
{
|
||||
if (!_metaActions.ContainsKey(metaKey))
|
||||
{
|
||||
_metaActions.Add(metaKey, new List<dynamic>() { metaAction });
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
_metaActions[metaKey].Add(metaAction);
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<IEnumerable<IClientMeta>> GetRuntimeMeta(ClientPaginationRequest request)
|
||||
{
|
||||
var metas = await Task.WhenAll(_metaActions.Where(kvp => kvp.Key != MetaType.Information)
|
||||
.Select(async kvp => await kvp.Value[0](request)));
|
||||
|
||||
return metas.SelectMany(m => (IEnumerable<IClientMeta>)m)
|
||||
.OrderByDescending(m => m.When)
|
||||
.Take(request.Count)
|
||||
.ToList();
|
||||
}
|
||||
|
||||
public async Task<IEnumerable<T>> GetRuntimeMeta<T>(ClientPaginationRequest request, MetaType metaType) where T : IClientMeta
|
||||
{
|
||||
if (metaType == MetaType.Information)
|
||||
{
|
||||
var allMeta = new List<T>();
|
||||
|
||||
var completedMeta = await Task.WhenAll(_metaActions[metaType].Select(async individualMetaRegistration =>
|
||||
(IEnumerable<T>)await individualMetaRegistration(request)));
|
||||
|
||||
allMeta.AddRange(completedMeta.SelectMany(meta => meta));
|
||||
|
||||
return ProcessInformationMeta(allMeta);
|
||||
}
|
||||
|
||||
var meta = await _metaActions[metaType][0](request) as IEnumerable<T>;
|
||||
|
||||
return meta;
|
||||
}
|
||||
|
||||
private static IEnumerable<T> ProcessInformationMeta<T>(IEnumerable<T> meta) where T : IClientMeta
|
||||
{
|
||||
var table = new List<List<T>>();
|
||||
var metaWithColumn = meta
|
||||
.Where(_meta => _meta.Column != null);
|
||||
|
||||
var columnGrouping = metaWithColumn
|
||||
.GroupBy(_meta => _meta.Column);
|
||||
|
||||
var metaToSort = meta.Except(metaWithColumn).ToList();
|
||||
|
||||
foreach (var metaItem in columnGrouping)
|
||||
{
|
||||
table.Add(new List<T>(metaItem));
|
||||
}
|
||||
|
||||
while (metaToSort.Count > 0)
|
||||
{
|
||||
var sortingMeta = metaToSort.First();
|
||||
|
||||
int indexOfSmallestColumn()
|
||||
{
|
||||
int index = 0;
|
||||
int smallestColumnSize = int.MaxValue;
|
||||
for (int i = 0; i < table.Count; i++)
|
||||
{
|
||||
if (table[i].Count < smallestColumnSize)
|
||||
{
|
||||
smallestColumnSize = table[i].Count;
|
||||
index = i;
|
||||
}
|
||||
}
|
||||
return index;
|
||||
}
|
||||
|
||||
int columnIndex = indexOfSmallestColumn();
|
||||
|
||||
sortingMeta.Column = columnIndex;
|
||||
sortingMeta.Order = columnGrouping
|
||||
.First(_group => _group.Key == columnIndex)
|
||||
.Count();
|
||||
|
||||
table[columnIndex].Add(sortingMeta);
|
||||
|
||||
metaToSort.Remove(sortingMeta);
|
||||
}
|
||||
|
||||
return meta;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,453 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Text.Json;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Abstractions;
|
||||
using Data.Models;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SharedLibraryCore.Dtos;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using SharedLibraryCore.QueryHelper;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
namespace IW4MAdmin.Application.Misc;
|
||||
|
||||
public class MetaServiceV2 : IMetaServiceV2
|
||||
{
|
||||
private readonly IDictionary<MetaType, List<dynamic>> _metaActions;
|
||||
private readonly IDatabaseContextFactory _contextFactory;
|
||||
private readonly ILogger _logger;
|
||||
|
||||
public MetaServiceV2(ILogger<MetaServiceV2> logger, IDatabaseContextFactory contextFactory, IServiceProvider serviceProvider)
|
||||
{
|
||||
_logger = logger;
|
||||
_metaActions = new Dictionary<MetaType, List<dynamic>>();
|
||||
_contextFactory = contextFactory;
|
||||
}
|
||||
|
||||
public async Task SetPersistentMeta(string metaKey, string metaValue, int clientId,
|
||||
CancellationToken token = default)
|
||||
{
|
||||
if (!ValidArgs(metaKey, clientId))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
await using var context = _contextFactory.CreateContext();
|
||||
|
||||
var existingMeta = await context.EFMeta
|
||||
.Where(meta => meta.Key == metaKey)
|
||||
.Where(meta => meta.ClientId == clientId)
|
||||
.FirstOrDefaultAsync(token);
|
||||
|
||||
if (existingMeta != null)
|
||||
{
|
||||
_logger.LogDebug("Updating existing meta with key {Key} and id {Id}", existingMeta.Key,
|
||||
existingMeta.MetaId);
|
||||
existingMeta.Value = metaValue;
|
||||
existingMeta.Updated = DateTime.UtcNow;
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
_logger.LogDebug("Adding new meta with key {Key}", metaKey);
|
||||
context.EFMeta.Add(new EFMeta
|
||||
{
|
||||
ClientId = clientId,
|
||||
Created = DateTime.UtcNow,
|
||||
Key = metaKey,
|
||||
Value = metaValue,
|
||||
});
|
||||
}
|
||||
|
||||
await context.SaveChangesAsync(token);
|
||||
}
|
||||
|
||||
public async Task SetPersistentMetaValue<T>(string metaKey, T metaValue, int clientId,
|
||||
CancellationToken token = default) where T : class
|
||||
{
|
||||
if (!ValidArgs(metaKey, clientId))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
string serializedValue;
|
||||
|
||||
try
|
||||
{
|
||||
serializedValue = JsonSerializer.Serialize(metaValue);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not serialize meta with key {Key}", metaKey);
|
||||
return;
|
||||
}
|
||||
|
||||
await SetPersistentMeta(metaKey, serializedValue, clientId, token);
|
||||
}
|
||||
|
||||
public async Task SetPersistentMetaForLookupKey(string metaKey, string lookupKey, int lookupId, int clientId,
|
||||
CancellationToken token = default)
|
||||
{
|
||||
if (!ValidArgs(metaKey, clientId))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
await using var context = _contextFactory.CreateContext();
|
||||
|
||||
var lookupMeta = await context.EFMeta.FirstOrDefaultAsync(meta => meta.Key == lookupKey, token);
|
||||
|
||||
if (lookupMeta is null)
|
||||
{
|
||||
_logger.LogWarning("No lookup meta exists for metaKey {MetaKey} and lookupKey {LookupKey}", metaKey,
|
||||
lookupKey);
|
||||
return;
|
||||
}
|
||||
|
||||
var lookupValues = JsonSerializer.Deserialize<List<LookupValue<string>>>(lookupMeta.Value);
|
||||
|
||||
if (lookupValues is null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
var foundLookup = lookupValues.FirstOrDefault(value => value.Id == lookupId);
|
||||
|
||||
if (foundLookup is null)
|
||||
{
|
||||
_logger.LogWarning("No lookup meta found for provided lookup id {MetaKey}, {LookupKey}, {LookupId}",
|
||||
metaKey, lookupKey, lookupId);
|
||||
return;
|
||||
}
|
||||
|
||||
_logger.LogDebug("Setting meta for lookup {MetaKey}, {LookupKey}, {LookupId}",
|
||||
metaKey, lookupKey, lookupId);
|
||||
|
||||
await SetPersistentMeta(metaKey, lookupId.ToString(), clientId, token);
|
||||
}
|
||||
|
||||
public async Task IncrementPersistentMeta(string metaKey, int incrementAmount, int clientId,
|
||||
CancellationToken token = default)
|
||||
{
|
||||
if (!ValidArgs(metaKey, clientId))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
var existingMeta = await GetPersistentMeta(metaKey, clientId, token);
|
||||
|
||||
if (!long.TryParse(existingMeta?.Value ?? "0", out var existingValue))
|
||||
{
|
||||
existingValue = 0;
|
||||
}
|
||||
|
||||
var newValue = existingValue + incrementAmount;
|
||||
await SetPersistentMeta(metaKey, newValue.ToString(), clientId, token);
|
||||
}
|
||||
|
||||
public async Task DecrementPersistentMeta(string metaKey, int decrementAmount, int clientId,
|
||||
CancellationToken token = default)
|
||||
{
|
||||
await IncrementPersistentMeta(metaKey, -decrementAmount, clientId, token);
|
||||
}
|
||||
|
||||
public async Task<EFMeta> GetPersistentMeta(string metaKey, int clientId, CancellationToken token = default)
|
||||
{
|
||||
if (!ValidArgs(metaKey, clientId))
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
await using var ctx = _contextFactory.CreateContext(enableTracking: false);
|
||||
|
||||
return await ctx.EFMeta
|
||||
.Where(meta => meta.Key == metaKey)
|
||||
.Where(meta => meta.ClientId == clientId)
|
||||
.Select(meta => new EFMeta
|
||||
{
|
||||
MetaId = meta.MetaId,
|
||||
Key = meta.Key,
|
||||
ClientId = meta.ClientId,
|
||||
Value = meta.Value,
|
||||
})
|
||||
.FirstOrDefaultAsync(token);
|
||||
}
|
||||
|
||||
public async Task<T> GetPersistentMetaValue<T>(string metaKey, int clientId, CancellationToken token = default)
|
||||
where T : class
|
||||
{
|
||||
var meta = await GetPersistentMeta(metaKey, clientId, token);
|
||||
|
||||
if (meta is null)
|
||||
{
|
||||
return default;
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
return JsonSerializer.Deserialize<T>(meta.Value);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not deserialize meta with key {Key} and value {Value}", metaKey, meta.Value);
|
||||
return default;
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<EFMeta> GetPersistentMetaByLookup(string metaKey, string lookupKey, int clientId,
|
||||
CancellationToken token = default)
|
||||
{
|
||||
await using var context = _contextFactory.CreateContext();
|
||||
|
||||
var metaValue = await GetPersistentMeta(metaKey, clientId, token);
|
||||
|
||||
if (metaValue is null)
|
||||
{
|
||||
_logger.LogDebug("No meta exists for key {Key}, clientId {ClientId}", metaKey, clientId);
|
||||
return default;
|
||||
}
|
||||
|
||||
var lookupMeta = await context.EFMeta.FirstOrDefaultAsync(meta => meta.Key == lookupKey, token);
|
||||
|
||||
if (lookupMeta is null)
|
||||
{
|
||||
_logger.LogWarning("No lookup meta exists for metaKey {MetaKey} and lookupKey {LookupKey}", metaKey,
|
||||
lookupKey);
|
||||
return default;
|
||||
}
|
||||
|
||||
var lookupId = int.Parse(metaValue.Value);
|
||||
var lookupValues = JsonSerializer.Deserialize<List<LookupValue<string>>>(lookupMeta.Value);
|
||||
|
||||
if (lookupValues is null)
|
||||
{
|
||||
return default;
|
||||
}
|
||||
|
||||
var foundLookup = lookupValues.FirstOrDefault(value => value.Id == lookupId);
|
||||
|
||||
if (foundLookup is not null)
|
||||
{
|
||||
return new EFMeta
|
||||
{
|
||||
Created = metaValue.Created,
|
||||
Updated = metaValue.Updated,
|
||||
Extra = metaValue.Extra,
|
||||
MetaId = metaValue.MetaId,
|
||||
Value = foundLookup.Value
|
||||
};
|
||||
}
|
||||
|
||||
_logger.LogWarning("No lookup meta found for provided lookup id {MetaKey}, {LookupKey}, {LookupId}",
|
||||
metaKey, lookupKey, lookupId);
|
||||
return default;
|
||||
}
|
||||
|
||||
public async Task RemovePersistentMeta(string metaKey, int clientId, CancellationToken token = default)
|
||||
{
|
||||
if (!ValidArgs(metaKey, clientId))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
await using var context = _contextFactory.CreateContext();
|
||||
|
||||
var existingMeta = await context.EFMeta
|
||||
.FirstOrDefaultAsync(meta => meta.Key == metaKey && meta.ClientId == clientId, token);
|
||||
|
||||
if (existingMeta == null)
|
||||
{
|
||||
_logger.LogDebug("No meta with key {Key} found for client id {Id}", metaKey, clientId);
|
||||
return;
|
||||
}
|
||||
|
||||
_logger.LogDebug("Removing meta for key {Key} with id {Id}", metaKey, existingMeta.MetaId);
|
||||
context.EFMeta.Remove(existingMeta);
|
||||
await context.SaveChangesAsync(token);
|
||||
}
|
||||
|
||||
public async Task SetPersistentMeta(string metaKey, string metaValue, CancellationToken token = default)
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(metaKey))
|
||||
{
|
||||
_logger.LogWarning("Cannot save meta with no key");
|
||||
return;
|
||||
}
|
||||
|
||||
await using var ctx = _contextFactory.CreateContext();
|
||||
|
||||
var existingMeta = await ctx.EFMeta
|
||||
.Where(meta => meta.Key == metaKey)
|
||||
.Where(meta => meta.ClientId == null)
|
||||
.FirstOrDefaultAsync(token);
|
||||
|
||||
if (existingMeta is not null)
|
||||
{
|
||||
_logger.LogDebug("Updating existing meta with key {Key} and id {Id}", existingMeta.Key,
|
||||
existingMeta.MetaId);
|
||||
|
||||
existingMeta.Value = metaValue;
|
||||
existingMeta.Updated = DateTime.UtcNow;
|
||||
|
||||
await ctx.SaveChangesAsync(token);
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
_logger.LogDebug("Adding new meta with key {Key}", metaKey);
|
||||
|
||||
ctx.EFMeta.Add(new EFMeta
|
||||
{
|
||||
Created = DateTime.UtcNow,
|
||||
Key = metaKey,
|
||||
Value = metaValue
|
||||
});
|
||||
|
||||
await ctx.SaveChangesAsync(token);
|
||||
}
|
||||
}
|
||||
|
||||
public async Task SetPersistentMetaValue<T>(string metaKey, T metaValue, CancellationToken token = default)
|
||||
where T : class
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(metaKey))
|
||||
{
|
||||
_logger.LogWarning("Meta key is null, not setting");
|
||||
return;
|
||||
}
|
||||
|
||||
if (metaValue is null)
|
||||
{
|
||||
_logger.LogWarning("Meta value is null, not setting");
|
||||
return;
|
||||
}
|
||||
|
||||
string serializedMeta;
|
||||
try
|
||||
{
|
||||
serializedMeta = JsonSerializer.Serialize(metaValue);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not serialize meta with {Key} and value {Value}", metaKey, metaValue);
|
||||
return;
|
||||
}
|
||||
|
||||
await SetPersistentMeta(metaKey, serializedMeta, token);
|
||||
}
|
||||
|
||||
public async Task<EFMeta> GetPersistentMeta(string metaKey, CancellationToken token = default)
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(metaKey))
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
await using var context = _contextFactory.CreateContext(false);
|
||||
return await context.EFMeta.FirstOrDefaultAsync(meta => meta.Key == metaKey, token);
|
||||
}
|
||||
|
||||
public async Task<T> GetPersistentMetaValue<T>(string metaKey, CancellationToken token = default) where T : class
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(metaKey))
|
||||
{
|
||||
return default;
|
||||
}
|
||||
|
||||
var meta = await GetPersistentMeta(metaKey, token);
|
||||
|
||||
if (meta is null)
|
||||
{
|
||||
return default;
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
return JsonSerializer.Deserialize<T>(meta.Value);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not serialize meta with key {Key} and value {Value}", metaKey, meta.Value);
|
||||
return default;
|
||||
}
|
||||
}
|
||||
|
||||
public async Task RemovePersistentMeta(string metaKey, CancellationToken token = default)
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(metaKey))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
await using var context = _contextFactory.CreateContext(enableTracking: false);
|
||||
|
||||
var existingMeta = await context.EFMeta
|
||||
.Where(meta => meta.Key == metaKey)
|
||||
.Where(meta => meta.ClientId == null)
|
||||
.FirstOrDefaultAsync(token);
|
||||
|
||||
if (existingMeta != null)
|
||||
{
|
||||
_logger.LogDebug("Removing meta for key {Key} with id {Id}", metaKey, existingMeta.MetaId);
|
||||
context.Remove(existingMeta);
|
||||
await context.SaveChangesAsync(token);
|
||||
}
|
||||
}
|
||||
|
||||
public void AddRuntimeMeta<T, TReturnType>(MetaType metaKey,
|
||||
Func<T, CancellationToken, Task<IEnumerable<TReturnType>>> metaAction)
|
||||
where T : PaginationRequest where TReturnType : IClientMeta
|
||||
{
|
||||
if (!_metaActions.ContainsKey(metaKey))
|
||||
{
|
||||
_metaActions.Add(metaKey, new List<dynamic> { metaAction });
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
_metaActions[metaKey].Add(metaAction);
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<IEnumerable<IClientMeta>> GetRuntimeMeta(ClientPaginationRequest request, CancellationToken token = default)
|
||||
{
|
||||
var metas = await Task.WhenAll(_metaActions.Where(kvp => kvp.Key != MetaType.Information)
|
||||
.Select(async kvp => await kvp.Value[0](request, token)));
|
||||
|
||||
return metas.SelectMany(m => (IEnumerable<IClientMeta>)m)
|
||||
.OrderByDescending(m => m.When)
|
||||
.Take(request.Count)
|
||||
.ToList();
|
||||
}
|
||||
|
||||
public async Task<IEnumerable<T>> GetRuntimeMeta<T>(ClientPaginationRequest request, MetaType metaType, CancellationToken token = default)
|
||||
where T : IClientMeta
|
||||
{
|
||||
if (metaType == MetaType.Information)
|
||||
{
|
||||
var allMeta = new List<T>();
|
||||
|
||||
var completedMeta = await Task.WhenAll(_metaActions[metaType].Select(async individualMetaRegistration =>
|
||||
(IEnumerable<T>)await individualMetaRegistration(request, token)));
|
||||
|
||||
allMeta.AddRange(completedMeta.SelectMany(meta => meta));
|
||||
|
||||
return ProcessInformationMeta(allMeta);
|
||||
}
|
||||
|
||||
var meta = await _metaActions[metaType][0](request, token) as IEnumerable<T>;
|
||||
|
||||
return meta;
|
||||
}
|
||||
|
||||
private static IEnumerable<T> ProcessInformationMeta<T>(IEnumerable<T> meta) where T : IClientMeta
|
||||
{
|
||||
return meta;
|
||||
}
|
||||
|
||||
private static bool ValidArgs(string key, int clientId) => !string.IsNullOrWhiteSpace(key) && clientId > 0;
|
||||
}
|
||||
@ -1,74 +0,0 @@
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Threading.Tasks;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
namespace IW4MAdmin.Application.Misc
|
||||
{
|
||||
class MiddlewareActionHandler : IMiddlewareActionHandler
|
||||
{
|
||||
private readonly IDictionary<string, IList<object>> _actions;
|
||||
private readonly ILogger _logger;
|
||||
|
||||
public MiddlewareActionHandler(ILogger<MiddlewareActionHandler> logger)
|
||||
{
|
||||
_actions = new Dictionary<string, IList<object>>();
|
||||
_logger = logger;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Executes the action with the given name
|
||||
/// </summary>
|
||||
/// <typeparam name="T">Execution return type</typeparam>
|
||||
/// <param name="value">Input value</param>
|
||||
/// <param name="name">Name of action to execute</param>
|
||||
/// <returns></returns>
|
||||
public async Task<T> Execute<T>(T value, string name = null)
|
||||
{
|
||||
string key = string.IsNullOrEmpty(name) ? typeof(T).ToString() : name;
|
||||
|
||||
if (_actions.ContainsKey(key))
|
||||
{
|
||||
foreach (var action in _actions[key])
|
||||
{
|
||||
try
|
||||
{
|
||||
value = await ((IMiddlewareAction<T>)action).Invoke(value);
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
_logger.LogWarning(e, "Failed to invoke middleware action {name}", name);
|
||||
}
|
||||
}
|
||||
|
||||
return value;
|
||||
}
|
||||
|
||||
return value;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Registers an action by name
|
||||
/// </summary>
|
||||
/// <typeparam name="T"></typeparam>
|
||||
/// <param name="actionType">Action type specifier</param>
|
||||
/// <param name="action">Action to perform</param>
|
||||
/// <param name="name">Name of action</param>
|
||||
public void Register<T>(T actionType, IMiddlewareAction<T> action, string name = null)
|
||||
{
|
||||
string key = string.IsNullOrEmpty(name) ? typeof(T).ToString() : name;
|
||||
|
||||
if (_actions.ContainsKey(key))
|
||||
{
|
||||
_actions[key].Add(action);
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
_actions.Add(key, new[] { action });
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,21 +0,0 @@
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Misc
|
||||
{
|
||||
/// <summary>
|
||||
/// implementation of the IMatchResult
|
||||
/// used to hold matching results
|
||||
/// </summary>
|
||||
public class ParserMatchResult : IMatchResult
|
||||
{
|
||||
/// <summary>
|
||||
/// array of matched pattern groups
|
||||
/// </summary>
|
||||
public string[] Values { get; set; }
|
||||
|
||||
/// <summary>
|
||||
/// indicates if the match succeeded
|
||||
/// </summary>
|
||||
public bool Success { get; set; }
|
||||
}
|
||||
}
|
||||
@ -1,76 +0,0 @@
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Reflection;
|
||||
using System.Security.Cryptography;
|
||||
using System.Text;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
namespace IW4MAdmin.Application.Misc
|
||||
{
|
||||
public class RemoteAssemblyHandler : IRemoteAssemblyHandler
|
||||
{
|
||||
private const int KeyLength = 32;
|
||||
private const int TagLength = 16;
|
||||
private const int NonceLength = 12;
|
||||
private const int IterationCount = 10000;
|
||||
|
||||
private readonly ApplicationConfiguration _appconfig;
|
||||
private readonly ILogger _logger;
|
||||
|
||||
public RemoteAssemblyHandler(ILogger<RemoteAssemblyHandler> logger, ApplicationConfiguration appconfig)
|
||||
{
|
||||
_appconfig = appconfig;
|
||||
_logger = logger;
|
||||
}
|
||||
|
||||
public IEnumerable<Assembly> DecryptAssemblies(string[] encryptedAssemblies)
|
||||
{
|
||||
return DecryptContent(encryptedAssemblies)
|
||||
.Select(Assembly.Load);
|
||||
}
|
||||
|
||||
public IEnumerable<string> DecryptScripts(string[] encryptedScripts)
|
||||
{
|
||||
return DecryptContent(encryptedScripts).Select(decryptedScript => Encoding.UTF8.GetString(decryptedScript));
|
||||
}
|
||||
|
||||
private IEnumerable<byte[]> DecryptContent(string[] content)
|
||||
{
|
||||
if (string.IsNullOrEmpty(_appconfig.Id) || string.IsNullOrWhiteSpace(_appconfig.SubscriptionId))
|
||||
{
|
||||
_logger.LogWarning($"{nameof(_appconfig.Id)} and {nameof(_appconfig.SubscriptionId)} must be provided to attempt loading remote assemblies/scripts");
|
||||
return Array.Empty<byte[]>();
|
||||
}
|
||||
|
||||
var assemblies = content.Select(piece =>
|
||||
{
|
||||
var byteContent = Convert.FromBase64String(piece);
|
||||
var encryptedContent = byteContent.Take(byteContent.Length - (TagLength + NonceLength)).ToArray();
|
||||
var tag = byteContent.Skip(byteContent.Length - (TagLength + NonceLength)).Take(TagLength).ToArray();
|
||||
var nonce = byteContent.Skip(byteContent.Length - NonceLength).Take(NonceLength).ToArray();
|
||||
var decryptedContent = new byte[encryptedContent.Length];
|
||||
|
||||
var keyGen = new Rfc2898DeriveBytes(Encoding.UTF8.GetBytes(_appconfig.SubscriptionId), Encoding.UTF8.GetBytes(_appconfig.Id), IterationCount, HashAlgorithmName.SHA512);
|
||||
var encryption = new AesGcm(keyGen.GetBytes(KeyLength));
|
||||
|
||||
try
|
||||
{
|
||||
encryption.Decrypt(nonce, encryptedContent, tag, decryptedContent);
|
||||
}
|
||||
|
||||
catch (CryptographicException ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not decrypt remote plugin assemblies");
|
||||
}
|
||||
|
||||
return decryptedContent;
|
||||
});
|
||||
|
||||
return assemblies.ToArray();
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,109 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Dtos;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using SharedLibraryCore.Services;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
namespace IW4MAdmin.Application.Misc;
|
||||
|
||||
public class RemoteCommandService : IRemoteCommandService
|
||||
{
|
||||
private readonly ILogger _logger;
|
||||
private readonly ApplicationConfiguration _appConfig;
|
||||
private readonly ClientService _clientService;
|
||||
|
||||
public RemoteCommandService(ILogger<RemoteCommandService> logger, ApplicationConfiguration appConfig, ClientService clientService)
|
||||
{
|
||||
_logger = logger;
|
||||
_appConfig = appConfig;
|
||||
_clientService = clientService;
|
||||
}
|
||||
|
||||
public async Task<IEnumerable<CommandResponseInfo>> Execute(int originId, int? targetId, string command,
|
||||
IEnumerable<string> arguments, Server server)
|
||||
{
|
||||
var (_, result) = await ExecuteWithResult(originId, targetId, command, arguments, server);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
public async Task<(bool, IEnumerable<CommandResponseInfo>)> ExecuteWithResult(int originId, int? targetId, string command,
|
||||
IEnumerable<string> arguments, Server server)
|
||||
{
|
||||
if (originId < 1)
|
||||
{
|
||||
_logger.LogWarning("Not executing command {Command} for {Originid} because origin id is invalid", command,
|
||||
originId);
|
||||
return (false, Enumerable.Empty<CommandResponseInfo>());
|
||||
}
|
||||
|
||||
var client = await _clientService.Get(originId);
|
||||
client.CurrentServer = server;
|
||||
|
||||
command += $" {(targetId.HasValue ? $"@{targetId} " : "")}{string.Join(" ", arguments ?? Enumerable.Empty<string>())}";
|
||||
|
||||
var remoteEvent = new GameEvent
|
||||
{
|
||||
Type = GameEvent.EventType.Command,
|
||||
Data = command.StartsWith(_appConfig.CommandPrefix) ||
|
||||
command.StartsWith(_appConfig.BroadcastCommandPrefix)
|
||||
? command
|
||||
: $"{_appConfig.CommandPrefix}{command}",
|
||||
Origin = client,
|
||||
Owner = server,
|
||||
IsRemote = true,
|
||||
CorrelationId = Guid.NewGuid()
|
||||
};
|
||||
|
||||
server.Manager.AddEvent(remoteEvent);
|
||||
CommandResponseInfo[] response;
|
||||
|
||||
try
|
||||
{
|
||||
// wait for the event to process
|
||||
var completedEvent =
|
||||
await remoteEvent.WaitAsync(Utilities.DefaultCommandTimeout, server.Manager.CancellationToken);
|
||||
|
||||
if (completedEvent.FailReason == GameEvent.EventFailReason.Timeout)
|
||||
{
|
||||
response = new[]
|
||||
{
|
||||
new CommandResponseInfo
|
||||
{
|
||||
ClientId = client.ClientId,
|
||||
Response = Utilities.CurrentLocalization.LocalizationIndex["SERVER_ERROR_COMMAND_TIMEOUT"]
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
response = completedEvent.Output.Select(output => new CommandResponseInfo()
|
||||
{
|
||||
Response = output,
|
||||
ClientId = client.ClientId
|
||||
}).ToArray();
|
||||
}
|
||||
}
|
||||
|
||||
catch (OperationCanceledException)
|
||||
{
|
||||
response = new[]
|
||||
{
|
||||
new CommandResponseInfo
|
||||
{
|
||||
ClientId = client.ClientId,
|
||||
Response = Utilities.CurrentLocalization.LocalizationIndex["COMMANDS_RESTART_SUCCESS"]
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
return (!remoteEvent.Failed, response);
|
||||
}
|
||||
}
|
||||
@ -1,150 +0,0 @@
|
||||
using Newtonsoft.Json;
|
||||
using Newtonsoft.Json.Linq;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Database.Models;
|
||||
using System;
|
||||
using System.Net;
|
||||
using Data.Models;
|
||||
using static SharedLibraryCore.Database.Models.EFClient;
|
||||
using static SharedLibraryCore.GameEvent;
|
||||
|
||||
namespace IW4MAdmin.Application.Misc
|
||||
{
|
||||
class IPAddressConverter : JsonConverter
|
||||
{
|
||||
public override bool CanConvert(Type objectType)
|
||||
{
|
||||
return (objectType == typeof(IPAddress));
|
||||
}
|
||||
|
||||
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
|
||||
{
|
||||
writer.WriteValue(value.ToString());
|
||||
}
|
||||
|
||||
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
|
||||
{
|
||||
return IPAddress.Parse((string)reader.Value);
|
||||
}
|
||||
}
|
||||
|
||||
class IPEndPointConverter : JsonConverter
|
||||
{
|
||||
public override bool CanConvert(Type objectType)
|
||||
{
|
||||
return (objectType == typeof(IPEndPoint));
|
||||
}
|
||||
|
||||
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
|
||||
{
|
||||
IPEndPoint ep = (IPEndPoint)value;
|
||||
JObject jo = new JObject();
|
||||
jo.Add("Address", JToken.FromObject(ep.Address, serializer));
|
||||
jo.Add("Port", ep.Port);
|
||||
jo.WriteTo(writer);
|
||||
}
|
||||
|
||||
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
|
||||
{
|
||||
JObject jo = JObject.Load(reader);
|
||||
IPAddress address = jo["Address"].ToObject<IPAddress>(serializer);
|
||||
int port = (int)jo["Port"];
|
||||
return new IPEndPoint(address, port);
|
||||
}
|
||||
}
|
||||
|
||||
class ClientEntityConverter : JsonConverter
|
||||
{
|
||||
public override bool CanConvert(Type objectType) => objectType == typeof(EFClient);
|
||||
|
||||
public override object ReadJson(JsonReader reader, Type objectType,object existingValue, JsonSerializer serializer)
|
||||
{
|
||||
if (reader.Value == null)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
var jsonObject = JObject.Load(reader);
|
||||
|
||||
return new EFClient
|
||||
{
|
||||
NetworkId = (long)jsonObject["NetworkId"],
|
||||
ClientNumber = (int)jsonObject["ClientNumber"],
|
||||
State = Enum.Parse<ClientState>(jsonObject["state"].ToString()),
|
||||
CurrentAlias = new EFAlias()
|
||||
{
|
||||
IPAddress = (int?)jsonObject["IPAddress"],
|
||||
Name = jsonObject["Name"].ToString()
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
|
||||
{
|
||||
var client = value as EFClient;
|
||||
var jsonObject = new JObject
|
||||
{
|
||||
{ "NetworkId", client.NetworkId },
|
||||
{ "ClientNumber", client.ClientNumber },
|
||||
{ "IPAddress", client.CurrentAlias?.IPAddress },
|
||||
{ "Name", client.CurrentAlias?.Name },
|
||||
{ "State", (int)client.State }
|
||||
};
|
||||
|
||||
jsonObject.WriteTo(writer);
|
||||
}
|
||||
}
|
||||
|
||||
class GameEventConverter : JsonConverter
|
||||
{
|
||||
public override bool CanConvert(Type objectType) =>objectType == typeof(GameEvent);
|
||||
|
||||
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
|
||||
{
|
||||
var jsonObject = JObject.Load(reader);
|
||||
|
||||
return new GameEvent
|
||||
{
|
||||
Type = Enum.Parse<EventType>(jsonObject["Type"].ToString()),
|
||||
Subtype = jsonObject["Subtype"]?.ToString(),
|
||||
Source = Enum.Parse<EventSource>(jsonObject["Source"].ToString()),
|
||||
RequiredEntity = Enum.Parse<EventRequiredEntity>(jsonObject["RequiredEntity"].ToString()),
|
||||
Data = jsonObject["Data"].ToString(),
|
||||
Message = jsonObject["Message"].ToString(),
|
||||
GameTime = (int?)jsonObject["GameTime"],
|
||||
Origin = jsonObject["Origin"]?.ToObject<EFClient>(serializer),
|
||||
Target = jsonObject["Target"]?.ToObject<EFClient>(serializer),
|
||||
ImpersonationOrigin = jsonObject["ImpersonationOrigin"]?.ToObject<EFClient>(serializer),
|
||||
IsRemote = (bool)jsonObject["IsRemote"],
|
||||
Extra = null, // fix
|
||||
Time = (DateTime)jsonObject["Time"],
|
||||
IsBlocking = (bool)jsonObject["IsBlocking"]
|
||||
};
|
||||
}
|
||||
|
||||
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
|
||||
{
|
||||
var gameEvent = value as GameEvent;
|
||||
|
||||
var jsonObject = new JObject
|
||||
{
|
||||
{ "Type", (int)gameEvent.Type },
|
||||
{ "Subtype", gameEvent.Subtype },
|
||||
{ "Source", (int)gameEvent.Source },
|
||||
{ "RequiredEntity", (int)gameEvent.RequiredEntity },
|
||||
{ "Data", gameEvent.Data },
|
||||
{ "Message", gameEvent.Message },
|
||||
{ "GameTime", gameEvent.GameTime },
|
||||
{ "Origin", gameEvent.Origin != null ? JToken.FromObject(gameEvent.Origin, serializer) : null },
|
||||
{ "Target", gameEvent.Target != null ? JToken.FromObject(gameEvent.Target, serializer) : null },
|
||||
{ "ImpersonationOrigin", gameEvent.ImpersonationOrigin != null ? JToken.FromObject(gameEvent.ImpersonationOrigin, serializer) : null},
|
||||
{ "IsRemote", gameEvent.IsRemote },
|
||||
{ "Extra", gameEvent.Extra?.ToString() },
|
||||
{ "Time", gameEvent.Time },
|
||||
{ "IsBlocking", gameEvent.IsBlocking }
|
||||
};
|
||||
|
||||
jsonObject.WriteTo(writer);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,143 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Abstractions;
|
||||
using Data.Models;
|
||||
using Data.Models.Client;
|
||||
using Data.Models.Client.Stats.Reference;
|
||||
using Data.Models.Server;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Events.Management;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using SharedLibraryCore.Interfaces.Events;
|
||||
|
||||
namespace IW4MAdmin.Application.Misc
|
||||
{
|
||||
/// <inheritdoc/>
|
||||
public class ServerDataCollector : IServerDataCollector
|
||||
{
|
||||
private readonly ILogger _logger;
|
||||
private readonly IManager _manager;
|
||||
private readonly IDatabaseContextFactory _contextFactory;
|
||||
private readonly ApplicationConfiguration _appConfig;
|
||||
|
||||
private bool _inProgress;
|
||||
private TimeSpan _period;
|
||||
|
||||
public ServerDataCollector(ILogger<ServerDataCollector> logger, ApplicationConfiguration appConfig,
|
||||
IManager manager, IDatabaseContextFactory contextFactory)
|
||||
{
|
||||
_logger = logger;
|
||||
_appConfig = appConfig;
|
||||
_manager = manager;
|
||||
_contextFactory = contextFactory;
|
||||
|
||||
IManagementEventSubscriptions.ClientStateAuthorized += SaveConnectionInfo;
|
||||
IManagementEventSubscriptions.ClientStateDisposed += SaveConnectionInfo;
|
||||
}
|
||||
|
||||
public async Task BeginCollectionAsync(TimeSpan? period = null, CancellationToken cancellationToken = default)
|
||||
{
|
||||
if (_inProgress)
|
||||
{
|
||||
throw new InvalidOperationException($"{nameof(ServerDataCollector)} is already collecting data");
|
||||
}
|
||||
|
||||
_logger.LogDebug("Initializing data collection with {Name}", nameof(ServerDataCollector));
|
||||
_inProgress = true;
|
||||
_period = period ?? (Utilities.IsDevelopment
|
||||
? TimeSpan.FromMinutes(1)
|
||||
: _appConfig.ServerDataCollectionInterval);
|
||||
|
||||
while (!cancellationToken.IsCancellationRequested)
|
||||
{
|
||||
try
|
||||
{
|
||||
await Task.Delay(_period, cancellationToken);
|
||||
_logger.LogDebug("{Name} is collecting server data", nameof(ServerDataCollector));
|
||||
|
||||
var data = await BuildCollectionData(cancellationToken);
|
||||
await SaveData(data, cancellationToken);
|
||||
}
|
||||
catch (TaskCanceledException)
|
||||
{
|
||||
_logger.LogInformation("Shutdown requested for {Name}", nameof(ServerDataCollector));
|
||||
return;
|
||||
}
|
||||
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Unexpected error encountered collecting server data for {Name}",
|
||||
nameof(ServerDataCollector));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private async Task<IEnumerable<EFServerSnapshot>> BuildCollectionData(CancellationToken token)
|
||||
{
|
||||
var data = await Task.WhenAll(_manager.GetServers()
|
||||
.Select(async server => new EFServerSnapshot
|
||||
{
|
||||
CapturedAt = DateTime.UtcNow,
|
||||
PeriodBlock = (int) (DateTimeOffset.UtcNow - DateTimeOffset.UnixEpoch).TotalMinutes,
|
||||
ServerId = await server.GetIdForServer(),
|
||||
MapId = await GetOrCreateMap(server.CurrentMap.Name, (Reference.Game) server.GameName, token),
|
||||
ClientCount = server.ClientNum,
|
||||
ConnectionInterrupted = server.Throttled,
|
||||
}));
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
private async Task<int> GetOrCreateMap(string mapName, Reference.Game game, CancellationToken token)
|
||||
{
|
||||
await using var context = _contextFactory.CreateContext();
|
||||
var existingMap =
|
||||
await context.Maps.FirstOrDefaultAsync(map => map.Name == mapName && map.Game == game, token);
|
||||
|
||||
if (existingMap != null)
|
||||
{
|
||||
return existingMap.MapId;
|
||||
}
|
||||
|
||||
var newMap = new EFMap
|
||||
{
|
||||
Name = mapName,
|
||||
Game = game
|
||||
};
|
||||
|
||||
context.Maps.Add(newMap);
|
||||
await context.SaveChangesAsync(token);
|
||||
|
||||
return newMap.MapId;
|
||||
}
|
||||
|
||||
private async Task SaveData(IEnumerable<EFServerSnapshot> snapshots, CancellationToken token)
|
||||
{
|
||||
await using var context = _contextFactory.CreateContext();
|
||||
context.ServerSnapshots.AddRange(snapshots);
|
||||
await context.SaveChangesAsync(token);
|
||||
}
|
||||
|
||||
private async Task SaveConnectionInfo(ClientStateEvent stateEvent, CancellationToken token)
|
||||
{
|
||||
await using var context = _contextFactory.CreateContext(enableTracking: false);
|
||||
context.ConnectionHistory.Add(new EFClientConnectionHistory
|
||||
{
|
||||
ClientId = stateEvent.Client.ClientId,
|
||||
ServerId = await stateEvent.Client.CurrentServer.GetIdForServer(),
|
||||
ConnectionType = stateEvent is ClientStateAuthorizeEvent
|
||||
? Reference.ConnectionType.Connect
|
||||
: Reference.ConnectionType.Disconnect
|
||||
});
|
||||
|
||||
await context.SaveChangesAsync();
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,220 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Abstractions;
|
||||
using Data.Models;
|
||||
using Data.Models.Client;
|
||||
using Data.Models.Client.Stats;
|
||||
using Data.Models.Server;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Dtos;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
namespace IW4MAdmin.Application.Misc
|
||||
{
|
||||
/// <inheritdoc/>
|
||||
public class ServerDataViewer : IServerDataViewer
|
||||
{
|
||||
private readonly ILogger _logger;
|
||||
private readonly IDataValueCache<EFServerSnapshot, (int?, DateTime?)> _snapshotCache;
|
||||
private readonly IDataValueCache<EFClient, (int, int)> _serverStatsCache;
|
||||
private readonly IDataValueCache<EFServerSnapshot, List<ClientHistoryInfo>> _clientHistoryCache;
|
||||
private readonly IDataValueCache<EFClientRankingHistory, int> _rankedClientsCache;
|
||||
|
||||
private readonly TimeSpan? _cacheTimeSpan =
|
||||
Utilities.IsDevelopment ? TimeSpan.FromSeconds(30) : (TimeSpan?) TimeSpan.FromMinutes(10);
|
||||
|
||||
public ServerDataViewer(ILogger<ServerDataViewer> logger, IDataValueCache<EFServerSnapshot, (int?, DateTime?)> snapshotCache,
|
||||
IDataValueCache<EFClient, (int, int)> serverStatsCache,
|
||||
IDataValueCache<EFServerSnapshot, List<ClientHistoryInfo>> clientHistoryCache, IDataValueCache<EFClientRankingHistory, int> rankedClientsCache)
|
||||
{
|
||||
_logger = logger;
|
||||
_snapshotCache = snapshotCache;
|
||||
_serverStatsCache = serverStatsCache;
|
||||
_clientHistoryCache = clientHistoryCache;
|
||||
_rankedClientsCache = rankedClientsCache;
|
||||
}
|
||||
|
||||
public async Task<(int?, DateTime?)>
|
||||
MaxConcurrentClientsAsync(long? serverId = null, Reference.Game? gameCode = null, TimeSpan? overPeriod = null,
|
||||
CancellationToken token = default)
|
||||
{
|
||||
_snapshotCache.SetCacheItem(async (snapshots, ids, cancellationToken) =>
|
||||
{
|
||||
Reference.Game? game = null;
|
||||
long? id = null;
|
||||
|
||||
if (ids.Any())
|
||||
{
|
||||
game = (Reference.Game?)ids.First();
|
||||
id = (long?)ids.Last();
|
||||
}
|
||||
|
||||
var oldestEntry = overPeriod.HasValue
|
||||
? DateTime.UtcNow - overPeriod.Value
|
||||
: DateTime.UtcNow.AddDays(-1);
|
||||
|
||||
int? maxClients;
|
||||
DateTime? maxClientsTime;
|
||||
|
||||
if (id != null)
|
||||
{
|
||||
var clients = await snapshots.Where(snapshot => snapshot.ServerId == id)
|
||||
.Where(snapshot => game == null || snapshot.Server.GameName == game)
|
||||
.Where(snapshot => snapshot.CapturedAt >= oldestEntry)
|
||||
.OrderByDescending(snapshot => snapshot.ClientCount)
|
||||
.Select(snapshot => new
|
||||
{
|
||||
snapshot.ClientCount,
|
||||
snapshot.CapturedAt
|
||||
})
|
||||
.FirstOrDefaultAsync(cancellationToken);
|
||||
|
||||
maxClients = clients?.ClientCount;
|
||||
maxClientsTime = clients?.CapturedAt;
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
var clients = await snapshots.Where(snapshot => snapshot.CapturedAt >= oldestEntry)
|
||||
.Where(snapshot => game == null || snapshot.Server.GameName == game)
|
||||
.GroupBy(snapshot => snapshot.PeriodBlock)
|
||||
.Select(grp => new
|
||||
{
|
||||
ClientCount = grp.Sum(snapshot => (int?)snapshot.ClientCount),
|
||||
Time = grp.Max(snapshot => (DateTime?)snapshot.CapturedAt)
|
||||
})
|
||||
.OrderByDescending(snapshot => snapshot.ClientCount)
|
||||
.FirstOrDefaultAsync(cancellationToken);
|
||||
|
||||
maxClients = clients?.ClientCount;
|
||||
maxClientsTime = clients?.Time;
|
||||
}
|
||||
|
||||
_logger.LogDebug("Max concurrent clients since {Start} is {Clients}", oldestEntry, maxClients);
|
||||
|
||||
return (maxClients, maxClientsTime);
|
||||
}, nameof(MaxConcurrentClientsAsync), new object[] { gameCode, serverId }, _cacheTimeSpan, true);
|
||||
|
||||
try
|
||||
{
|
||||
return await _snapshotCache.GetCacheItem(nameof(MaxConcurrentClientsAsync),
|
||||
new object[] { gameCode, serverId }, token);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not retrieve data for {Name}", nameof(MaxConcurrentClientsAsync));
|
||||
return (null, null);
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<(int, int)> ClientCountsAsync(TimeSpan? overPeriod = null, Reference.Game? gameCode = null, CancellationToken token = default)
|
||||
{
|
||||
_serverStatsCache.SetCacheItem(async (set, ids, cancellationToken) =>
|
||||
{
|
||||
Reference.Game? game = null;
|
||||
|
||||
if (ids.Any())
|
||||
{
|
||||
game = (Reference.Game?)ids.First();
|
||||
}
|
||||
|
||||
var count = await set.CountAsync(item => game == null || item.GameName == game,
|
||||
cancellationToken);
|
||||
var startOfPeriod =
|
||||
DateTime.UtcNow.AddHours(-overPeriod?.TotalHours ?? -24);
|
||||
var recentCount = await set.CountAsync(client => (game == null || client.GameName == game) && client.LastConnection >= startOfPeriod,
|
||||
cancellationToken);
|
||||
|
||||
return (count, recentCount);
|
||||
}, nameof(_serverStatsCache), new object[] { gameCode }, _cacheTimeSpan, true);
|
||||
|
||||
try
|
||||
{
|
||||
return await _serverStatsCache.GetCacheItem(nameof(_serverStatsCache), new object[] { gameCode }, token);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not retrieve data for {Name}", nameof(ClientCountsAsync));
|
||||
return (0, 0);
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<IEnumerable<ClientHistoryInfo>> ClientHistoryAsync(TimeSpan? overPeriod = null, CancellationToken token = default)
|
||||
{
|
||||
_clientHistoryCache.SetCacheItem(async (set, cancellationToken) =>
|
||||
{
|
||||
var oldestEntry = overPeriod.HasValue
|
||||
? DateTime.UtcNow - overPeriod.Value
|
||||
: DateTime.UtcNow.AddHours(-12);
|
||||
|
||||
var history = await set.Where(snapshot => snapshot.CapturedAt >= oldestEntry)
|
||||
.Select(snapshot =>
|
||||
new
|
||||
{
|
||||
snapshot.ServerId,
|
||||
snapshot.CapturedAt,
|
||||
snapshot.ClientCount,
|
||||
snapshot.ConnectionInterrupted,
|
||||
MapName = snapshot.Map.Name,
|
||||
})
|
||||
.OrderBy(snapshot => snapshot.CapturedAt)
|
||||
.ToListAsync(cancellationToken);
|
||||
|
||||
return history.GroupBy(snapshot => snapshot.ServerId).Select(byServer => new ClientHistoryInfo
|
||||
{
|
||||
ServerId = byServer.Key,
|
||||
ClientCounts = byServer.Select(snapshot => new ClientCountSnapshot
|
||||
{ Time = snapshot.CapturedAt, ClientCount = snapshot.ClientCount, ConnectionInterrupted = snapshot.ConnectionInterrupted ?? false, Map = snapshot.MapName}).ToList()
|
||||
}).ToList();
|
||||
}, nameof(_clientHistoryCache), TimeSpan.MaxValue);
|
||||
|
||||
try
|
||||
{
|
||||
return await _clientHistoryCache.GetCacheItem(nameof(_clientHistoryCache), token);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not retrieve data for {Name}", nameof(ClientHistoryAsync));
|
||||
return Enumerable.Empty<ClientHistoryInfo>();
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<int> RankedClientsCountAsync(long? serverId = null, CancellationToken token = default)
|
||||
{
|
||||
_rankedClientsCache.SetCacheItem((set, ids, cancellationToken) =>
|
||||
{
|
||||
long? id = null;
|
||||
|
||||
if (ids.Any())
|
||||
{
|
||||
id = (long?)ids.First();
|
||||
}
|
||||
|
||||
var fifteenDaysAgo = DateTime.UtcNow.AddDays(-15);
|
||||
return set
|
||||
.Where(rating => rating.Newest)
|
||||
.Where(rating => rating.ServerId == id)
|
||||
.Where(rating => rating.CreatedDateTime >= fifteenDaysAgo)
|
||||
.Where(rating => rating.Client.Level != EFClient.Permission.Banned)
|
||||
.Where(rating => rating.Ranking != null)
|
||||
.CountAsync(cancellationToken);
|
||||
}, nameof(_rankedClientsCache), new object[] { serverId }, _cacheTimeSpan);
|
||||
|
||||
try
|
||||
{
|
||||
return await _rankedClientsCache.GetCacheItem(nameof(_rankedClientsCache), new object[] { serverId }, token);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Could not retrieve data for {Name}", nameof(RankedClientsCountAsync));
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -7,43 +7,42 @@ using System.Text;
|
||||
|
||||
namespace IW4MAdmin.Application.Misc
|
||||
{
|
||||
internal class TokenAuthentication : ITokenAuthentication
|
||||
class TokenAuthentication : ITokenAuthentication
|
||||
{
|
||||
private readonly ConcurrentDictionary<int, TokenState> _tokens;
|
||||
private readonly RandomNumberGenerator _random;
|
||||
private static readonly TimeSpan TimeoutPeriod = new(0, 0, 120);
|
||||
private const short TokenLength = 4;
|
||||
private readonly ConcurrentDictionary<long, TokenState> _tokens;
|
||||
private readonly RNGCryptoServiceProvider _random;
|
||||
private readonly static TimeSpan _timeoutPeriod = new TimeSpan(0, 0, 120);
|
||||
private const short TOKEN_LENGTH = 4;
|
||||
|
||||
public TokenAuthentication()
|
||||
{
|
||||
_tokens = new ConcurrentDictionary<int, TokenState>();
|
||||
_random = RandomNumberGenerator.Create();
|
||||
_tokens = new ConcurrentDictionary<long, TokenState>();
|
||||
_random = new RNGCryptoServiceProvider();
|
||||
}
|
||||
|
||||
public bool AuthorizeToken(ITokenIdentifier authInfo)
|
||||
public bool AuthorizeToken(long networkId, string token)
|
||||
{
|
||||
var authorizeSuccessful = _tokens.ContainsKey(authInfo.ClientId) &&
|
||||
_tokens[authInfo.ClientId].Token == authInfo.Token;
|
||||
bool authorizeSuccessful = _tokens.ContainsKey(networkId) && _tokens[networkId].Token == token;
|
||||
|
||||
if (authorizeSuccessful)
|
||||
{
|
||||
_tokens.TryRemove(authInfo.ClientId, out _);
|
||||
_tokens.TryRemove(networkId, out TokenState _);
|
||||
}
|
||||
|
||||
return authorizeSuccessful;
|
||||
}
|
||||
|
||||
public TokenState GenerateNextToken(ITokenIdentifier authInfo)
|
||||
public TokenState GenerateNextToken(long networkId)
|
||||
{
|
||||
TokenState state;
|
||||
TokenState state = null;
|
||||
|
||||
if (_tokens.ContainsKey(authInfo.ClientId))
|
||||
if (_tokens.ContainsKey(networkId))
|
||||
{
|
||||
state = _tokens[authInfo.ClientId];
|
||||
state = _tokens[networkId];
|
||||
|
||||
if (DateTime.Now - state.RequestTime > TimeoutPeriod)
|
||||
if ((DateTime.Now - state.RequestTime) > _timeoutPeriod)
|
||||
{
|
||||
_tokens.TryRemove(authInfo.ClientId, out _);
|
||||
_tokens.TryRemove(networkId, out TokenState _);
|
||||
}
|
||||
|
||||
else
|
||||
@ -52,42 +51,43 @@ namespace IW4MAdmin.Application.Misc
|
||||
}
|
||||
}
|
||||
|
||||
state = new TokenState
|
||||
state = new TokenState()
|
||||
{
|
||||
NetworkId = networkId,
|
||||
Token = _generateToken(),
|
||||
TokenDuration = TimeoutPeriod
|
||||
TokenDuration = _timeoutPeriod
|
||||
};
|
||||
|
||||
_tokens.TryAdd(authInfo.ClientId, state);
|
||||
_tokens.TryAdd(networkId, state);
|
||||
|
||||
// perform some housekeeping so we don't have built up tokens if they're not ever used
|
||||
foreach (var (key, value) in _tokens)
|
||||
{
|
||||
if (DateTime.Now - value.RequestTime > TimeoutPeriod)
|
||||
if ((DateTime.Now - value.RequestTime) > _timeoutPeriod)
|
||||
{
|
||||
_tokens.TryRemove(key, out _);
|
||||
_tokens.TryRemove(key, out TokenState _);
|
||||
}
|
||||
}
|
||||
|
||||
return state;
|
||||
}
|
||||
|
||||
private string _generateToken()
|
||||
public string _generateToken()
|
||||
{
|
||||
bool ValidCharacter(char c)
|
||||
bool validCharacter(char c)
|
||||
{
|
||||
// this ensure that the characters are 0-9, A-Z, a-z
|
||||
return (c > 47 && c < 58) || (c > 64 && c < 91) || (c > 96 && c < 123);
|
||||
}
|
||||
|
||||
var token = new StringBuilder();
|
||||
StringBuilder token = new StringBuilder();
|
||||
|
||||
var charSet = new byte[1];
|
||||
while (token.Length < TokenLength)
|
||||
while (token.Length < TOKEN_LENGTH)
|
||||
{
|
||||
byte[] charSet = new byte[1];
|
||||
_random.GetBytes(charSet);
|
||||
|
||||
if (ValidCharacter((char)charSet[0]))
|
||||
if (validCharacter((char)charSet[0]))
|
||||
{
|
||||
token.Append((char)charSet[0]);
|
||||
}
|
||||
|
||||
@ -1,207 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using System.Linq;
|
||||
using System.Reflection;
|
||||
using System.Text.RegularExpressions;
|
||||
using IW4MAdmin.Application.API.Master;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
namespace IW4MAdmin.Application.Plugin
|
||||
{
|
||||
/// <summary>
|
||||
/// implementation of IPluginImporter
|
||||
/// discovers plugins and script plugins
|
||||
/// </summary>
|
||||
public class PluginImporter : IPluginImporter
|
||||
{
|
||||
private IEnumerable<PluginSubscriptionContent> _pluginSubscription;
|
||||
private const string PluginDir = "Plugins";
|
||||
private const string PluginV2Match = "^ *((?:var|const|let) +init)|function init";
|
||||
private readonly ILogger _logger;
|
||||
private readonly IRemoteAssemblyHandler _remoteAssemblyHandler;
|
||||
private readonly IMasterApi _masterApi;
|
||||
private readonly ApplicationConfiguration _appConfig;
|
||||
|
||||
private static readonly Type[] FilterTypes =
|
||||
{
|
||||
typeof(IPlugin),
|
||||
typeof(IPluginV2),
|
||||
typeof(Command),
|
||||
typeof(IBaseConfiguration)
|
||||
};
|
||||
|
||||
public PluginImporter(ILogger<PluginImporter> logger, ApplicationConfiguration appConfig, IMasterApi masterApi,
|
||||
IRemoteAssemblyHandler remoteAssemblyHandler)
|
||||
{
|
||||
_logger = logger;
|
||||
_masterApi = masterApi;
|
||||
_remoteAssemblyHandler = remoteAssemblyHandler;
|
||||
_appConfig = appConfig;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// discovers all the script plugins in the plugins dir
|
||||
/// </summary>
|
||||
/// <returns></returns>
|
||||
public IEnumerable<(Type, string)> DiscoverScriptPlugins()
|
||||
{
|
||||
var pluginDir = $"{Utilities.OperatingDirectory}{PluginDir}{Path.DirectorySeparatorChar}";
|
||||
|
||||
if (!Directory.Exists(pluginDir))
|
||||
{
|
||||
return Enumerable.Empty<(Type, string)>();
|
||||
}
|
||||
|
||||
var scriptPluginFiles =
|
||||
Directory.GetFiles(pluginDir, "*.js").AsEnumerable().Union(GetRemoteScripts()).ToList();
|
||||
|
||||
var bothVersionPlugins = scriptPluginFiles.Select(fileName =>
|
||||
{
|
||||
_logger.LogDebug("Discovered script plugin {FileName}", fileName);
|
||||
try
|
||||
{
|
||||
var fileContents = File.ReadAllLines(fileName);
|
||||
var isValidV2 = fileContents.Any(line => Regex.IsMatch(line, PluginV2Match));
|
||||
return isValidV2 ? (typeof(IPluginV2), fileName) : (typeof(IPlugin), fileName);
|
||||
}
|
||||
catch
|
||||
{
|
||||
return (typeof(IPlugin), fileName);
|
||||
}
|
||||
}).ToList();
|
||||
|
||||
return bothVersionPlugins;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// discovers all the C# assembly plugins and commands
|
||||
/// </summary>
|
||||
/// <returns></returns>
|
||||
public (IEnumerable<Type>, IEnumerable<Type>, IEnumerable<Type>) DiscoverAssemblyPluginImplementations()
|
||||
{
|
||||
var pluginDir = $"{Utilities.OperatingDirectory}{PluginDir}{Path.DirectorySeparatorChar}";
|
||||
var pluginTypes = new List<Type>();
|
||||
var commandTypes = new List<Type>();
|
||||
var configurationTypes = new List<Type>();
|
||||
|
||||
if (!Directory.Exists(pluginDir))
|
||||
{
|
||||
return (pluginTypes, commandTypes, configurationTypes);
|
||||
}
|
||||
|
||||
var dllFileNames = Directory.GetFiles(pluginDir, "*.dll");
|
||||
_logger.LogDebug("Discovered {Count} potential plugin assemblies", dllFileNames.Length);
|
||||
|
||||
if (!dllFileNames.Any())
|
||||
{
|
||||
return (pluginTypes, commandTypes, configurationTypes);
|
||||
}
|
||||
|
||||
// we only want to load the most recent assembly in case of duplicates
|
||||
var assemblies = dllFileNames.Select(Assembly.LoadFrom)
|
||||
.Union(GetRemoteAssemblies())
|
||||
.GroupBy(assembly => assembly.FullName).Select(assembly =>
|
||||
assembly.OrderByDescending(asm => asm.GetName().Version).First());
|
||||
|
||||
var eligibleAssemblyTypes = assemblies
|
||||
.SelectMany(asm =>
|
||||
{
|
||||
try
|
||||
{
|
||||
return asm.GetTypes();
|
||||
}
|
||||
catch
|
||||
{
|
||||
return Enumerable.Empty<Type>();
|
||||
}
|
||||
}).Where(type =>
|
||||
FilterTypes.Any(filterType => type.GetInterface(filterType.Name, false) != null) ||
|
||||
(type.IsClass && FilterTypes.Contains(type.BaseType)));
|
||||
|
||||
foreach (var assemblyType in eligibleAssemblyTypes)
|
||||
{
|
||||
var isPlugin =
|
||||
(assemblyType.GetInterface(nameof(IPlugin), false) ??
|
||||
assemblyType.GetInterface(nameof(IPluginV2), false)) != null &&
|
||||
(!assemblyType.Namespace?.StartsWith(nameof(SharedLibraryCore)) ?? false);
|
||||
|
||||
if (isPlugin)
|
||||
{
|
||||
pluginTypes.Add(assemblyType);
|
||||
continue;
|
||||
}
|
||||
|
||||
var isCommand = assemblyType.IsClass && assemblyType.BaseType == typeof(Command) &&
|
||||
(!assemblyType.Namespace?.StartsWith(nameof(SharedLibraryCore)) ?? false);
|
||||
|
||||
if (isCommand)
|
||||
{
|
||||
commandTypes.Add(assemblyType);
|
||||
continue;
|
||||
}
|
||||
|
||||
var isConfiguration = assemblyType.IsClass &&
|
||||
assemblyType.GetInterface(nameof(IBaseConfiguration), false) != null &&
|
||||
(!assemblyType.Namespace?.StartsWith(nameof(SharedLibraryCore)) ?? false);
|
||||
|
||||
if (isConfiguration)
|
||||
{
|
||||
configurationTypes.Add(assemblyType);
|
||||
}
|
||||
}
|
||||
|
||||
_logger.LogDebug("Discovered {Count} plugin implementations", pluginTypes.Count);
|
||||
_logger.LogDebug("Discovered {Count} plugin command implementations", commandTypes.Count);
|
||||
_logger.LogDebug("Discovered {Count} plugin configuration implementations", configurationTypes.Count);
|
||||
|
||||
return (pluginTypes, commandTypes, configurationTypes);
|
||||
}
|
||||
|
||||
private IEnumerable<Assembly> GetRemoteAssemblies()
|
||||
{
|
||||
try
|
||||
{
|
||||
_pluginSubscription ??= _masterApi
|
||||
.GetPluginSubscription(Guid.Parse(_appConfig.Id), _appConfig.SubscriptionId).Result;
|
||||
|
||||
return _remoteAssemblyHandler.DecryptAssemblies(_pluginSubscription
|
||||
.Where(sub => sub.Type == PluginType.Binary).Select(sub => sub.Content).ToArray());
|
||||
}
|
||||
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogWarning(ex, "Could not load remote assemblies");
|
||||
return Enumerable.Empty<Assembly>();
|
||||
}
|
||||
}
|
||||
|
||||
private IEnumerable<string> GetRemoteScripts()
|
||||
{
|
||||
try
|
||||
{
|
||||
_pluginSubscription ??= _masterApi
|
||||
.GetPluginSubscription(Guid.Parse(_appConfig.Id), _appConfig.SubscriptionId).Result;
|
||||
|
||||
return _remoteAssemblyHandler.DecryptScripts(_pluginSubscription
|
||||
.Where(sub => sub.Type == PluginType.Script).Select(sub => sub.Content).ToArray());
|
||||
}
|
||||
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogWarning(ex,"Could not load remote scripts");
|
||||
return Enumerable.Empty<string>();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public enum PluginType
|
||||
{
|
||||
Binary,
|
||||
Script
|
||||
}
|
||||
}
|
||||
@ -1,58 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Models;
|
||||
using Data.Models.Client;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Commands;
|
||||
using SharedLibraryCore.Configuration;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
namespace IW4MAdmin.Application.Plugin.Script
|
||||
{
|
||||
/// <summary>
|
||||
/// generic script command implementation
|
||||
/// </summary>
|
||||
public class ScriptCommand : Command
|
||||
{
|
||||
private readonly Func<GameEvent, Task> _executeAction;
|
||||
private readonly ILogger _logger;
|
||||
|
||||
public ScriptCommand(string name, string alias, string description, bool isTargetRequired,
|
||||
EFClient.Permission permission,
|
||||
IEnumerable<CommandArgument> args, Func<GameEvent, Task> executeAction, CommandConfiguration config,
|
||||
ITranslationLookup layout, ILogger<ScriptCommand> logger, IEnumerable<Reference.Game> supportedGames)
|
||||
: base(config, layout)
|
||||
{
|
||||
_executeAction = executeAction;
|
||||
_logger = logger;
|
||||
Name = name;
|
||||
Alias = alias;
|
||||
Description = description;
|
||||
RequiresTarget = isTargetRequired;
|
||||
Permission = permission;
|
||||
Arguments = args.ToArray();
|
||||
SupportedGames = supportedGames?.Select(game => (Server.Game)game).ToArray();
|
||||
}
|
||||
|
||||
public override async Task ExecuteAsync(GameEvent e)
|
||||
{
|
||||
if (_executeAction == null)
|
||||
{
|
||||
throw new InvalidOperationException($"No execute action defined for command \"{Name}\"");
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
await _executeAction(e);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Failed to execute ScriptCommand action for command {Command} {@Event}", Name, e);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,567 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using System.Linq;
|
||||
using System.Runtime.CompilerServices;
|
||||
using System.Text;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using Data.Models;
|
||||
using IW4MAdmin.Application.Configuration;
|
||||
using IW4MAdmin.Application.Extensions;
|
||||
using IW4MAdmin.Application.Misc;
|
||||
using Jint;
|
||||
using Jint.Native;
|
||||
using Jint.Runtime;
|
||||
using Jint.Runtime.Interop;
|
||||
using Microsoft.CSharp.RuntimeBinder;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using Serilog.Context;
|
||||
using SharedLibraryCore;
|
||||
using SharedLibraryCore.Commands;
|
||||
using SharedLibraryCore.Database.Models;
|
||||
using SharedLibraryCore.Exceptions;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
using ILogger = Microsoft.Extensions.Logging.ILogger;
|
||||
|
||||
namespace IW4MAdmin.Application.Plugin.Script
|
||||
{
|
||||
/// <summary>
|
||||
/// implementation of IPlugin
|
||||
/// used to proxy script plugin requests
|
||||
/// </summary>
|
||||
public class ScriptPlugin : IPlugin
|
||||
{
|
||||
public string Name { get; set; }
|
||||
|
||||
public float Version { get; set; }
|
||||
|
||||
public string Author { get; set; }
|
||||
|
||||
/// <summary>
|
||||
/// indicates if the plugin is a parser
|
||||
/// </summary>
|
||||
public bool IsParser { get; private set; }
|
||||
|
||||
public FileSystemWatcher Watcher { get; }
|
||||
|
||||
private Engine _scriptEngine;
|
||||
private readonly string _fileName;
|
||||
private readonly SemaphoreSlim _onProcessing = new(1, 1);
|
||||
private bool _successfullyLoaded;
|
||||
private readonly List<string> _registeredCommandNames;
|
||||
private readonly ILogger _logger;
|
||||
|
||||
public ScriptPlugin(ILogger logger, string filename, string workingDirectory = null)
|
||||
{
|
||||
_logger = logger;
|
||||
_fileName = filename;
|
||||
Watcher = new FileSystemWatcher
|
||||
{
|
||||
Path = workingDirectory ?? $"{Utilities.OperatingDirectory}Plugins{Path.DirectorySeparatorChar}",
|
||||
NotifyFilter = NotifyFilters.LastWrite,
|
||||
Filter = _fileName.Split(Path.DirectorySeparatorChar).Last()
|
||||
};
|
||||
|
||||
Watcher.EnableRaisingEvents = true;
|
||||
_registeredCommandNames = new List<string>();
|
||||
}
|
||||
|
||||
~ScriptPlugin()
|
||||
{
|
||||
Watcher.Dispose();
|
||||
_onProcessing.Dispose();
|
||||
}
|
||||
|
||||
public async Task Initialize(IManager manager, IScriptCommandFactory scriptCommandFactory,
|
||||
IScriptPluginServiceResolver serviceResolver, IConfigurationHandlerV2<ScriptPluginConfiguration> configHandler)
|
||||
{
|
||||
try
|
||||
{
|
||||
await _onProcessing.WaitAsync();
|
||||
|
||||
// for some reason we get an event trigger when the file is not finished being modified.
|
||||
// this must have been a change in .NET CORE 3.x
|
||||
// so if the new file is empty we can't process it yet
|
||||
if (new FileInfo(_fileName).Length == 0L)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
var firstRun = _scriptEngine == null;
|
||||
|
||||
// it's been loaded before so we need to call the unload event
|
||||
if (!firstRun)
|
||||
{
|
||||
await OnUnloadAsync();
|
||||
|
||||
foreach (var commandName in _registeredCommandNames)
|
||||
{
|
||||
_logger.LogDebug("Removing plugin registered command {Command}", commandName);
|
||||
manager.RemoveCommandByName(commandName);
|
||||
}
|
||||
|
||||
_registeredCommandNames.Clear();
|
||||
}
|
||||
|
||||
_successfullyLoaded = false;
|
||||
string script;
|
||||
|
||||
await using (var stream =
|
||||
new FileStream(_fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
|
||||
{
|
||||
using (var reader = new StreamReader(stream, Encoding.Default))
|
||||
{
|
||||
script = await reader.ReadToEndAsync();
|
||||
}
|
||||
}
|
||||
|
||||
_scriptEngine?.Dispose();
|
||||
_scriptEngine = new Engine(cfg =>
|
||||
cfg.AddExtensionMethods(typeof(Utilities), typeof(Enumerable), typeof(Queryable),
|
||||
typeof(ScriptPluginExtensions))
|
||||
.AllowClr(new[]
|
||||
{
|
||||
typeof(System.Net.Http.HttpClient).Assembly,
|
||||
typeof(EFClient).Assembly,
|
||||
typeof(Utilities).Assembly,
|
||||
typeof(Encoding).Assembly,
|
||||
typeof(CancellationTokenSource).Assembly,
|
||||
typeof(Data.Models.Client.EFClient).Assembly,
|
||||
typeof(IW4MAdmin.Plugins.Stats.Plugin).Assembly
|
||||
})
|
||||
.CatchClrExceptions()
|
||||
.AddObjectConverter(new PermissionLevelToStringConverter()));
|
||||
|
||||
_scriptEngine.Execute(script);
|
||||
if (!_scriptEngine.GetValue("init").IsUndefined())
|
||||
{
|
||||
// this is a v2 plugin and we don't want to try to load it
|
||||
Watcher.EnableRaisingEvents = false;
|
||||
Watcher.Dispose();
|
||||
return;
|
||||
}
|
||||
_scriptEngine.SetValue("_localization", Utilities.CurrentLocalization);
|
||||
_scriptEngine.SetValue("_serviceResolver", serviceResolver);
|
||||
dynamic pluginObject = _scriptEngine.Evaluate("plugin").ToObject();
|
||||
|
||||
Author = pluginObject.author;
|
||||
Name = pluginObject.name;
|
||||
Version = (float)pluginObject.version;
|
||||
|
||||
var commands = JsValue.Undefined;
|
||||
try
|
||||
{
|
||||
commands = _scriptEngine.Evaluate("commands");
|
||||
}
|
||||
catch (JavaScriptException)
|
||||
{
|
||||
// ignore because commands aren't defined;
|
||||
}
|
||||
|
||||
if (commands != JsValue.Undefined)
|
||||
{
|
||||
try
|
||||
{
|
||||
foreach (var command in GenerateScriptCommands(commands, scriptCommandFactory))
|
||||
{
|
||||
_logger.LogDebug("Adding plugin registered command {CommandName}", command.Name);
|
||||
manager.AddAdditionalCommand(command);
|
||||
_registeredCommandNames.Add(command.Name);
|
||||
}
|
||||
}
|
||||
|
||||
catch (RuntimeBinderException e)
|
||||
{
|
||||
throw new PluginException($"Not all required fields were found: {e.Message}")
|
||||
{ PluginFile = _fileName };
|
||||
}
|
||||
}
|
||||
|
||||
async Task<bool> OnLoadTask()
|
||||
{
|
||||
await OnLoadAsync(manager);
|
||||
return true;
|
||||
}
|
||||
|
||||
var loadComplete = false;
|
||||
|
||||
try
|
||||
{
|
||||
if (pluginObject.isParser)
|
||||
{
|
||||
loadComplete = await OnLoadTask();
|
||||
IsParser = true;
|
||||
var eventParser = (IEventParser)_scriptEngine.Evaluate("eventParser").ToObject();
|
||||
var rconParser = (IRConParser)_scriptEngine.Evaluate("rconParser").ToObject();
|
||||
manager.AdditionalEventParsers.Add(eventParser);
|
||||
manager.AdditionalRConParsers.Add(rconParser);
|
||||
}
|
||||
}
|
||||
|
||||
catch (RuntimeBinderException)
|
||||
{
|
||||
var configWrapper = new ScriptPluginConfigurationWrapper(Name, _scriptEngine, configHandler);
|
||||
|
||||
if (!loadComplete)
|
||||
{
|
||||
_scriptEngine.SetValue("_configHandler", configWrapper);
|
||||
loadComplete = await OnLoadTask();
|
||||
}
|
||||
}
|
||||
|
||||
if (!firstRun && !loadComplete)
|
||||
{
|
||||
loadComplete = await OnLoadTask();
|
||||
}
|
||||
|
||||
_successfullyLoaded = loadComplete;
|
||||
}
|
||||
catch (JavaScriptException ex)
|
||||
{
|
||||
_logger.LogError(ex,
|
||||
"Encountered JavaScript runtime error while executing {MethodName} for script plugin {Plugin} at {@LocationInfo} StackTrace={StackTrace}",
|
||||
nameof(Initialize), Path.GetFileName(_fileName), ex.Location, ex.JavaScriptStackTrace);
|
||||
|
||||
throw new PluginException("An error occured while initializing script plugin");
|
||||
}
|
||||
catch (Exception ex) when (ex.InnerException is JavaScriptException jsEx)
|
||||
{
|
||||
_logger.LogError(ex,
|
||||
"Encountered JavaScript runtime error while executing {MethodName} for script plugin {Plugin} initialization {@LocationInfo} StackTrace={StackTrace}",
|
||||
nameof(Initialize), _fileName, jsEx.Location, jsEx.JavaScriptStackTrace);
|
||||
|
||||
throw new PluginException("An error occured while initializing script plugin");
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex,
|
||||
"Encountered JavaScript runtime error while executing {MethodName} for script plugin {Plugin}",
|
||||
nameof(OnLoadAsync), Path.GetFileName(_fileName));
|
||||
|
||||
throw new PluginException("An error occured while executing action for script plugin");
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (_onProcessing.CurrentCount == 0)
|
||||
{
|
||||
_onProcessing.Release(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public async Task OnEventAsync(GameEvent gameEvent, Server server)
|
||||
{
|
||||
if (!_successfullyLoaded)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
var shouldRelease = false;
|
||||
|
||||
try
|
||||
{
|
||||
await _onProcessing.WaitAsync(Utilities.DefaultCommandTimeout / 2);
|
||||
shouldRelease = true;
|
||||
WrapJavaScriptErrorHandling(() =>
|
||||
{
|
||||
_scriptEngine.SetValue("_gameEvent", gameEvent);
|
||||
_scriptEngine.SetValue("_server", server);
|
||||
_scriptEngine.SetValue("_IW4MAdminClient", Utilities.IW4MAdminClient(server));
|
||||
return _scriptEngine.Evaluate("plugin.onEventAsync(_gameEvent, _server)");
|
||||
}, new { EventType = gameEvent.Type }, server);
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (_onProcessing.CurrentCount == 0 && shouldRelease)
|
||||
{
|
||||
_onProcessing.Release(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public Task OnLoadAsync(IManager manager)
|
||||
{
|
||||
_logger.LogDebug("OnLoad executing for {Name}", Name);
|
||||
|
||||
WrapJavaScriptErrorHandling(() =>
|
||||
{
|
||||
_scriptEngine.SetValue("_manager", manager);
|
||||
return _scriptEngine.Evaluate("plugin.onLoadAsync(_manager)");
|
||||
});
|
||||
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
|
||||
public Task OnTickAsync(Server server)
|
||||
{
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
|
||||
public async Task OnUnloadAsync()
|
||||
{
|
||||
if (!_successfullyLoaded)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
await _onProcessing.WaitAsync();
|
||||
|
||||
_logger.LogDebug("OnUnload executing for {Name}", Name);
|
||||
|
||||
WrapJavaScriptErrorHandling(() => _scriptEngine.Evaluate("plugin.onUnloadAsync()"));
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (_onProcessing.CurrentCount == 0)
|
||||
{
|
||||
_onProcessing.Release(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public T ExecuteAction<T>(Delegate action, CancellationToken token, params object[] param)
|
||||
{
|
||||
var shouldRelease = false;
|
||||
|
||||
try
|
||||
{
|
||||
using var forceTimeout = new CancellationTokenSource(5000);
|
||||
using var combined = CancellationTokenSource.CreateLinkedTokenSource(forceTimeout.Token, token);
|
||||
_onProcessing.Wait(combined.Token);
|
||||
shouldRelease = true;
|
||||
|
||||
_logger.LogDebug("Executing action for {Name}", Name);
|
||||
|
||||
return WrapJavaScriptErrorHandling(T() =>
|
||||
{
|
||||
var args = param.Select(p => JsValue.FromObject(_scriptEngine, p)).ToArray();
|
||||
var result = action.DynamicInvoke(JsValue.Undefined, args);
|
||||
return (T)(result as JsValue)?.ToObject();
|
||||
},
|
||||
new
|
||||
{
|
||||
Params = string.Join(", ",
|
||||
param?.Select(eachParam => $"Type={eachParam?.GetType().Name} Value={eachParam}") ??
|
||||
Enumerable.Empty<string>())
|
||||
});
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (_onProcessing.CurrentCount == 0 && shouldRelease)
|
||||
{
|
||||
_onProcessing.Release(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public T WrapDelegate<T>(Delegate act, CancellationToken token, params object[] args)
|
||||
{
|
||||
var shouldRelease = false;
|
||||
|
||||
try
|
||||
{
|
||||
using var forceTimeout = new CancellationTokenSource(5000);
|
||||
using var combined = CancellationTokenSource.CreateLinkedTokenSource(forceTimeout.Token, token);
|
||||
_onProcessing.Wait(combined.Token);
|
||||
shouldRelease = true;
|
||||
|
||||
_logger.LogDebug("Wrapping delegate action for {Name}", Name);
|
||||
|
||||
return WrapJavaScriptErrorHandling(
|
||||
T() => (T)(act.DynamicInvoke(JsValue.Null,
|
||||
args.Select(arg => JsValue.FromObject(_scriptEngine, arg)).ToArray()) as ObjectWrapper)
|
||||
?.ToObject(),
|
||||
new
|
||||
{
|
||||
Params = string.Join(", ",
|
||||
args?.Select(eachParam => $"Type={eachParam?.GetType().Name} Value={eachParam}") ??
|
||||
Enumerable.Empty<string>())
|
||||
});
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (_onProcessing.CurrentCount == 0 && shouldRelease)
|
||||
{
|
||||
_onProcessing.Release(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// finds declared script commands in the script plugin
|
||||
/// </summary>
|
||||
/// <param name="commands">commands value from jint parser</param>
|
||||
/// <param name="scriptCommandFactory">factory to create the command from</param>
|
||||
/// <returns></returns>
|
||||
private IEnumerable<IManagerCommand> GenerateScriptCommands(JsValue commands,
|
||||
IScriptCommandFactory scriptCommandFactory)
|
||||
{
|
||||
var commandList = new List<IManagerCommand>();
|
||||
|
||||
// go through each defined command
|
||||
foreach (var command in commands.AsArray())
|
||||
{
|
||||
dynamic dynamicCommand = command.ToObject();
|
||||
string name = dynamicCommand.name;
|
||||
string alias = dynamicCommand.alias;
|
||||
string description = dynamicCommand.description;
|
||||
|
||||
if (dynamicCommand.permission is Data.Models.Client.EFClient.Permission perm)
|
||||
{
|
||||
dynamicCommand.permission = perm.ToString();
|
||||
}
|
||||
|
||||
string permission = dynamicCommand.permission;
|
||||
List<Reference.Game> supportedGames = null;
|
||||
var targetRequired = false;
|
||||
|
||||
var args = new List<CommandArgument>();
|
||||
dynamic arguments = null;
|
||||
|
||||
try
|
||||
{
|
||||
arguments = dynamicCommand.arguments;
|
||||
}
|
||||
|
||||
catch (RuntimeBinderException)
|
||||
{
|
||||
// arguments are optional
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
targetRequired = dynamicCommand.targetRequired;
|
||||
}
|
||||
|
||||
catch (RuntimeBinderException)
|
||||
{
|
||||
// arguments are optional
|
||||
}
|
||||
|
||||
if (arguments != null)
|
||||
{
|
||||
foreach (var arg in dynamicCommand.arguments)
|
||||
{
|
||||
args.Add(new CommandArgument { Name = arg.name, Required = (bool)arg.required });
|
||||
}
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
foreach (var game in dynamicCommand.supportedGames)
|
||||
{
|
||||
supportedGames ??= new List<Reference.Game>();
|
||||
supportedGames.Add(Enum.Parse(typeof(Reference.Game), game.ToString()));
|
||||
}
|
||||
}
|
||||
catch (RuntimeBinderException)
|
||||
{
|
||||
// supported games is optional
|
||||
}
|
||||
|
||||
async Task Execute(GameEvent gameEvent)
|
||||
{
|
||||
try
|
||||
{
|
||||
await _onProcessing.WaitAsync();
|
||||
|
||||
_scriptEngine.SetValue("_event", gameEvent);
|
||||
var jsEventObject = _scriptEngine.Evaluate("_event");
|
||||
|
||||
dynamicCommand.execute.Target.Invoke(_scriptEngine, jsEventObject);
|
||||
}
|
||||
|
||||
catch (JavaScriptException ex)
|
||||
{
|
||||
using (LogContext.PushProperty("Server", gameEvent.Owner?.ToString()))
|
||||
{
|
||||
_logger.LogError(ex, "Could not execute command action for {Filename} {@Location}",
|
||||
Path.GetFileName(_fileName), ex.Location);
|
||||
}
|
||||
|
||||
throw new PluginException("A runtime error occured while executing action for script plugin");
|
||||
}
|
||||
|
||||
catch (Exception ex)
|
||||
{
|
||||
using (LogContext.PushProperty("Server", gameEvent.Owner?.ToString()))
|
||||
{
|
||||
_logger.LogError(ex,
|
||||
"Could not execute command action for script plugin {FileName}",
|
||||
Path.GetFileName(_fileName));
|
||||
}
|
||||
|
||||
throw new PluginException("An error occured while executing action for script plugin");
|
||||
}
|
||||
|
||||
finally
|
||||
{
|
||||
if (_onProcessing.CurrentCount == 0)
|
||||
{
|
||||
_onProcessing.Release(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
commandList.Add(scriptCommandFactory.CreateScriptCommand(name, alias, description, permission,
|
||||
targetRequired, args, Execute, supportedGames));
|
||||
}
|
||||
|
||||
return commandList;
|
||||
}
|
||||
|
||||
private T WrapJavaScriptErrorHandling<T>(Func<T> work, object additionalData = null, Server server = null,
|
||||
[CallerMemberName] string methodName = "")
|
||||
{
|
||||
using (LogContext.PushProperty("Server", server?.ToString()))
|
||||
{
|
||||
try
|
||||
{
|
||||
return work();
|
||||
}
|
||||
catch (JavaScriptException ex)
|
||||
{
|
||||
_logger.LogError(ex,
|
||||
"Encountered JavaScript runtime error while executing {MethodName} for script plugin {Plugin} at {@LocationInfo} StackTrace={StackTrace} {@AdditionalData}",
|
||||
methodName, Path.GetFileName(_fileName), ex.Location, ex.StackTrace, additionalData);
|
||||
|
||||
throw new PluginException("A runtime error occured while executing action for script plugin");
|
||||
}
|
||||
catch (Exception ex) when (ex.InnerException is JavaScriptException jsEx)
|
||||
{
|
||||
_logger.LogError(ex,
|
||||
"Encountered JavaScript runtime error while executing {MethodName} for script plugin {Plugin} initialization {@LocationInfo} StackTrace={StackTrace} {@AdditionalData}",
|
||||
methodName, _fileName, jsEx.Location, jsEx.JavaScriptStackTrace, additionalData);
|
||||
|
||||
throw new PluginException("A runtime error occured while executing action for script plugin");
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex,
|
||||
"Encountered JavaScript runtime error while executing {MethodName} for script plugin {Plugin}",
|
||||
methodName, Path.GetFileName(_fileName));
|
||||
|
||||
throw new PluginException("An error occured while executing action for script plugin");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public class PermissionLevelToStringConverter : IObjectConverter
|
||||
{
|
||||
public bool TryConvert(Engine engine, object value, out JsValue result)
|
||||
{
|
||||
if (value is Data.Models.Client.EFClient.Permission)
|
||||
{
|
||||
result = value.ToString();
|
||||
return true;
|
||||
}
|
||||
|
||||
result = JsValue.Null;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,130 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Globalization;
|
||||
using System.Linq;
|
||||
using System.Text.Json;
|
||||
using System.Threading.Tasks;
|
||||
using IW4MAdmin.Application.Configuration;
|
||||
using Jint;
|
||||
using Jint.Native;
|
||||
using Jint.Native.Json;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Plugin.Script;
|
||||
|
||||
public class ScriptPluginConfigurationWrapper
|
||||
{
|
||||
public event Action<JsValue, Delegate> ConfigurationUpdated;
|
||||
|
||||
private readonly ScriptPluginConfiguration _config;
|
||||
private readonly IConfigurationHandlerV2<ScriptPluginConfiguration> _configHandler;
|
||||
private readonly Engine _scriptEngine;
|
||||
private readonly JsonParser _engineParser;
|
||||
private readonly List<(string, Delegate)> _updateCallbackActions = new();
|
||||
private string _pluginName;
|
||||
|
||||
public ScriptPluginConfigurationWrapper(string pluginName, Engine scriptEngine, IConfigurationHandlerV2<ScriptPluginConfiguration> configHandler)
|
||||
{
|
||||
_pluginName = pluginName;
|
||||
_scriptEngine = scriptEngine;
|
||||
_configHandler = configHandler;
|
||||
_configHandler.Updated += OnConfigurationUpdated;
|
||||
_config = configHandler.Get("ScriptPluginSettings", new ScriptPluginConfiguration()).GetAwaiter().GetResult();
|
||||
_engineParser = new JsonParser(_scriptEngine);
|
||||
}
|
||||
|
||||
~ScriptPluginConfigurationWrapper()
|
||||
{
|
||||
_configHandler.Updated -= OnConfigurationUpdated;
|
||||
}
|
||||
|
||||
public void SetName(string name)
|
||||
{
|
||||
_pluginName = name;
|
||||
}
|
||||
|
||||
public async Task SetValue(string key, object value)
|
||||
{
|
||||
var castValue = value;
|
||||
|
||||
if (value is double doubleValue)
|
||||
{
|
||||
castValue = AsInteger(doubleValue) ?? value;
|
||||
}
|
||||
|
||||
if (value is object[] array && array.All(item => item is double d && AsInteger(d) != null))
|
||||
{
|
||||
castValue = array.Select(item => AsInteger((double)item)).ToArray();
|
||||
}
|
||||
|
||||
if (!_config.ContainsKey(_pluginName))
|
||||
{
|
||||
_config.Add(_pluginName, new Dictionary<string, object>());
|
||||
}
|
||||
|
||||
var plugin = _config[_pluginName];
|
||||
|
||||
if (plugin.ContainsKey(key))
|
||||
{
|
||||
plugin[key] = castValue;
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
plugin.Add(key, castValue);
|
||||
}
|
||||
|
||||
await _configHandler.Set(_config);
|
||||
}
|
||||
|
||||
public JsValue GetValue(string key) => GetValue(key, null);
|
||||
|
||||
public JsValue GetValue(string key, Delegate updateCallback)
|
||||
{
|
||||
if (!_config.ContainsKey(_pluginName))
|
||||
{
|
||||
return JsValue.Undefined;
|
||||
}
|
||||
|
||||
if (!_config[_pluginName].ContainsKey(key))
|
||||
{
|
||||
return JsValue.Undefined;
|
||||
}
|
||||
|
||||
var item = _config[_pluginName][key];
|
||||
|
||||
if (item is JsonElement { ValueKind: JsonValueKind.Array } jElem)
|
||||
{
|
||||
item = jElem.Deserialize<List<dynamic>>();
|
||||
}
|
||||
|
||||
if (updateCallback is not null)
|
||||
{
|
||||
_updateCallbackActions.Add((key, updateCallback));
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
return _engineParser.Parse(item!.ToString()!);
|
||||
}
|
||||
catch
|
||||
{
|
||||
// ignored
|
||||
}
|
||||
|
||||
return JsValue.FromObject(_scriptEngine, item);
|
||||
}
|
||||
|
||||
private static int? AsInteger(double value)
|
||||
{
|
||||
return int.TryParse(value.ToString(CultureInfo.InvariantCulture), out var parsed) ? parsed : null;
|
||||
}
|
||||
|
||||
private void OnConfigurationUpdated(ScriptPluginConfiguration config)
|
||||
{
|
||||
foreach (var callback in _updateCallbackActions)
|
||||
{
|
||||
ConfigurationUpdated?.Invoke(GetValue(callback.Item1), callback.Item2);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,32 +0,0 @@
|
||||
using System;
|
||||
using IW4MAdmin.Application.Configuration;
|
||||
using Microsoft.Extensions.DependencyInjection;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Plugin.Script;
|
||||
|
||||
public class ScriptPluginFactory : IScriptPluginFactory
|
||||
{
|
||||
private readonly IServiceProvider _serviceProvider;
|
||||
|
||||
public ScriptPluginFactory(IServiceProvider serviceProvider)
|
||||
{
|
||||
_serviceProvider = serviceProvider;
|
||||
}
|
||||
|
||||
public object CreateScriptPlugin(Type type, string fileName)
|
||||
{
|
||||
if (type == typeof(IPlugin))
|
||||
{
|
||||
return new ScriptPlugin(_serviceProvider.GetRequiredService<ILogger<ScriptPlugin>>(),
|
||||
fileName);
|
||||
}
|
||||
|
||||
return new ScriptPluginV2(fileName, _serviceProvider.GetRequiredService<ILogger<ScriptPluginV2>>(),
|
||||
_serviceProvider.GetRequiredService<IScriptPluginServiceResolver>(),
|
||||
_serviceProvider.GetRequiredService<IScriptCommandFactory>(),
|
||||
_serviceProvider.GetRequiredService<IConfigurationHandlerV2<ScriptPluginConfiguration>>(),
|
||||
_serviceProvider.GetRequiredService<IInteractionRegistration>());
|
||||
}
|
||||
}
|
||||
@ -1,143 +0,0 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using System.Net.Http;
|
||||
using System.Text;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using Jint.Native;
|
||||
using SharedLibraryCore.Interfaces;
|
||||
|
||||
namespace IW4MAdmin.Application.Plugin.Script;
|
||||
|
||||
public class ScriptPluginHelper
|
||||
{
|
||||
private readonly IManager _manager;
|
||||
private readonly ScriptPluginV2 _scriptPlugin;
|
||||
private readonly SemaphoreSlim _onRequestRunning = new(1, 1);
|
||||
private const int RequestTimeout = 5000;
|
||||
|
||||
public ScriptPluginHelper(IManager manager, ScriptPluginV2 scriptPlugin)
|
||||
{
|
||||
_manager = manager;
|
||||
_scriptPlugin = scriptPlugin;
|
||||
}
|
||||
|
||||
public void GetUrl(string url, Delegate callback)
|
||||
{
|
||||
RequestUrl(new ScriptPluginWebRequest(url), callback);
|
||||
}
|
||||
|
||||
public void GetUrl(string url, string bearerToken, Delegate callback)
|
||||
{
|
||||
var headers = new Dictionary<string, string> { { "Authorization", $"Bearer {bearerToken}" } };
|
||||
RequestUrl(new ScriptPluginWebRequest(url, Headers: headers), callback);
|
||||
}
|
||||
|
||||
public void PostUrl(string url, string body, string bearerToken, Delegate callback)
|
||||
{
|
||||
var headers = new Dictionary<string, string> { { "Authorization", $"Bearer {bearerToken}" } };
|
||||
RequestUrl(
|
||||
new ScriptPluginWebRequest(url, body, "POST", Headers: headers), callback);
|
||||
}
|
||||
|
||||
public void RequestUrl(ScriptPluginWebRequest request, Delegate callback)
|
||||
{
|
||||
Task.Run(() =>
|
||||
{
|
||||
try
|
||||
{
|
||||
var response = RequestInternal(request);
|
||||
_scriptPlugin.ExecuteWithErrorHandling(scriptEngine =>
|
||||
{
|
||||
callback.DynamicInvoke(JsValue.Undefined, new[] { JsValue.FromObject(scriptEngine, response) });
|
||||
});
|
||||
}
|
||||
catch
|
||||
{
|
||||
// ignored
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
public void RequestNotifyAfterDelay(int delayMs, Delegate callback)
|
||||
{
|
||||
Task.Run(async () =>
|
||||
{
|
||||
try
|
||||
{
|
||||
await Task.Delay(delayMs, _manager.CancellationToken);
|
||||
_scriptPlugin.ExecuteWithErrorHandling(_ => callback.DynamicInvoke(JsValue.Undefined, new[] { JsValue.Undefined }));
|
||||
}
|
||||
catch
|
||||
{
|
||||
// ignored
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
public void RegisterDynamicCommand(JsValue command)
|
||||
{
|
||||
_scriptPlugin.RegisterDynamicCommand(command.ToObject());
|
||||
}
|
||||
|
||||
private object RequestInternal(ScriptPluginWebRequest request)
|
||||
{
|
||||
var entered = false;
|
||||
using var tokenSource = new CancellationTokenSource(RequestTimeout);
|
||||
using var client = new HttpClient();
|
||||
|
||||
try
|
||||
{
|
||||
_onRequestRunning.Wait(tokenSource.Token);
|
||||
|
||||
entered = true;
|
||||
var requestMessage = new HttpRequestMessage(new HttpMethod(request.Method), request.Url);
|
||||
|
||||
if (request.Body is not null)
|
||||
{
|
||||
requestMessage.Content = new StringContent(request.Body.ToString() ?? string.Empty, Encoding.Default,
|
||||
request.ContentType ?? "text/plain");
|
||||
}
|
||||
|
||||
if (request.Headers is not null)
|
||||
{
|
||||
foreach (var (key, value) in request.Headers)
|
||||
{
|
||||
if (!string.IsNullOrWhiteSpace(key))
|
||||
{
|
||||
requestMessage.Headers.Add(key, value);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var response = client.Send(requestMessage, tokenSource.Token);
|
||||
using var reader = new StreamReader(response.Content.ReadAsStream());
|
||||
return reader.ReadToEnd();
|
||||
}
|
||||
catch (HttpRequestException ex)
|
||||
{
|
||||
return new
|
||||
{
|
||||
ex.StatusCode,
|
||||
ex.Message,
|
||||
IsError = true
|
||||
};
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
return new
|
||||
{
|
||||
ex.Message,
|
||||
IsError = true
|
||||
};
|
||||
}
|
||||
finally
|
||||
{
|
||||
if (entered)
|
||||
{
|
||||
_onRequestRunning.Release(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user