INSANEMODE/ClanTagRankCommands
1
0
Fork 0
Code Issues 1 Pull Requests Releases 5 Wiki Activity

Compare commits

merge into: INSANEMODE:fed
Branches Tags
INSANEMODE:master INSANEMODE:eventing INSANEMODE:integration INSANEMODE:fed INSANEMODE:custom-ranks
INSANEMODE:release-1.31 INSANEMODE:release-1.3 INSANEMODE:Release1.1 INSANEMODE:Release-1.01 INSANEMODE:Release
...
pull from: INSANEMODE:integration
Branches Tags
INSANEMODE:eventing INSANEMODE:integration INSANEMODE:fed INSANEMODE:master INSANEMODE:custom-ranks
INSANEMODE:release-1.31 INSANEMODE:release-1.3 INSANEMODE:Release1.1 INSANEMODE:Release-1.01 INSANEMODE:Release

6 Commits
fed ... integratio

Author SHA1 Message Date
INSANEMODE
ac5bd03f3d cahnge startup logtype 2023-01-29 17:18:05 -06:00
INSANEMODE
5f651e9a4c create invite guest and set donator profile buttons, and commands 2022-10-25 05:29:32 -05:00
INSANEMODE
562bdd4269 add setdonator and invite guest commands 2022-08-19 04:20:56 -05:00
INSANEMODE
23ee5c5ded -change !inviteguest to check the target's tag before changing it to Guest. 
-change disconnect event logic to target the correct target when removing Guest tag.
 2022-08-19 00:58:16 -05:00
INSANEMODE
06023475ee comment out unneeded commands and events 
add inviteguest and setdonator commands
 2022-08-17 04:06:57 -05:00
INSANEMODE
f2832f3558 -start cleanining unused code 
-prepare to convert functions to new command system
 -convert to using client tags instead of persistant meta for player ranks
 2022-08-16 04:15:47 -05:00
11 changed files with 855 additions and 368 deletions
Expand all files Collapse all files

2
ClanTag.cs
View File

@ -20,7 +20,7 @@ namespace ClanTagRankCommands
switch ((int)level)
{
case -1:
rankName = "Banned"; //this typically won't be seen.
rankName = "Flagged"; //this typically won't be seen.
break;
case 0:
rankName = Config.User;

3
ClanTagRankCommands.csproj
View File

@ -10,12 +10,13 @@
</PropertyGroup>
<ItemGroup>
<Compile Remove="GscApiController.cs" />
<Compile Remove="TebexApiClient.cs" />
<Compile Remove="unusedClanTag.cs" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="RaidMax.IW4MAdmin.SharedLibraryCore" Version="2021.3.19.1" PrivateAssets="All" />
<PackageReference Include="RaidMax.IW4MAdmin.SharedLibraryCore" Version="2022.10.13.1" PrivateAssets="All" />
</ItemGroup>
<Target Name="PostBuild" AfterTargets="PostBuildEvent">

145
Commands/GetRankCommand.cs
View File

@ -1,94 +1,93 @@
using SharedLibraryCore;
using SharedLibraryCore.Commands;
using SharedLibraryCore.Configuration;
using SharedLibraryCore.Database.Models;
using SharedLibraryCore.Interfaces;
using System.Threading.Tasks;
//using SharedLibraryCore;
//using SharedLibraryCore.Commands;
//using SharedLibraryCore.Configuration;
//using SharedLibraryCore.Database.Models;
//using SharedLibraryCore.Interfaces;
//using System.Threading.Tasks;
namespace ClanTagRankCommands.Commands
{
//namespace ClanTagRankCommands.Commands
//{
/// <summary>
/// Example script command
/// </summary>
///
// /// <summary>
// /// Example script command
// /// </summary>
// ///
public class GetRankCommand : Command
{
readonly string rank = "rank";
string rank_string;
private readonly IMetaService _metaService;
private readonly IConfigurationHandler<Configuration> _configurationHandler;
private Configuration Config;
// public class GetRankCommand : Command
// {
// readonly string rank = "rank";
// string rank_string;
// private readonly IMetaServiceV2 _metaService;
// private readonly IConfigurationHandler<Configuration> _configurationHandler;
// private Configuration Config;
public GetRankCommand(CommandConfiguration config, ITranslationLookup lookup, IMetaService metaService, IConfigurationHandlerFactory configurationHandlerFactory) : base(config, lookup)
{
_metaService = metaService;
_configurationHandler = configurationHandlerFactory.GetConfigurationHandler<Configuration>("ClanTagRankCommands");
if (_configurationHandler.Configuration() == null)
{
_configurationHandler.Set((Configuration)new Configuration().Generate());
_configurationHandler.Save();
}
Config = _configurationHandler.Configuration();
// public GetRankCommand(CommandConfiguration config, ITranslationLookup lookup, IMetaServiceV2 metaService, IConfigurationHandlerFactory configurationHandlerFactory) : base(config, lookup)
// {
// _metaService = metaService;
// _configurationHandler = configurationHandlerFactory.GetConfigurationHandler<Configuration>("ClanTagRankCommands");
// if (_configurationHandler.Configuration() == null)
// {
// _configurationHandler.Set((Configuration)new Configuration().Generate());
// _configurationHandler.Save();
// }
// Config = _configurationHandler.Configuration();
Name = "GetRank";
Description = "Get a user's clan tag Rank (does not give permissions)";
Alias = "Gr";
Permission = EFClient.Permission.Trusted;
RequiresTarget = true;
Arguments = new[]
{
new CommandArgument()
{
}
};
// Name = "GetRank";
// Description = "Get a user's clan tag Rank (does not give permissions)";
// Alias = "Gr";
// Permission = EFClient.Permission.Trusted;
// RequiresTarget = true;
// Arguments = new[]
// {
// new CommandArgument()
// {
// }
// };
}
// }
public override async Task ExecuteAsync(GameEvent E)
{
//var S = E.Owner;
rank_string = "none";
if(E.Target is not null)
{
var rank_player_var = await _metaService.GetPersistentMeta(rank, E.Target);
if (rank_player_var == null)
{
await _metaService.AddPersistentMeta(rank, "none", E.Target);
rank_player_var = await _metaService.GetPersistentMeta(rank, E.Target);
}
// public override async Task ExecuteAsync(GameEvent E)
// {
// rank_string = "none";
// if(E.Target is not null)
// {
// var rank_player_var = await _metaService.GetPersistentMeta(rank, E.Target.ClientId);
// if (rank_player_var == null)
// {
// await _metaService.SetPersistentMeta(rank, "none", E.Target.ClientId);
// rank_player_var = await _metaService.GetPersistentMeta(rank, E.Target.ClientId);
// }
if (rank_string.Length > 0 && rank_string.Length < 9)
{
// if (rank_string.Length > 0 && rank_string.Length < 9)
// {
//await _metaService.AddPersistentMeta(rank, rank_string, E.Target);
rank_player_var = await _metaService.GetPersistentMeta(rank, E.Target);
if(rank_player_var.Value == "none" || rank_player_var.Value == "None" || rank_player_var.Value == "NONE")
{
// //await _metaService.AddPersistentMeta(rank, rank_string, E.Target);
// rank_player_var = await _metaService.GetPersistentMeta(rank, E.Target.ClientId);
// if(rank_player_var.Value == "none" || rank_player_var.Value == "None" || rank_player_var.Value == "NONE")
// {
//E.Origin.Tell(E.Target.Name + "'s rank has been reset");
rank_string = E.Target.Level.ClanTag(Config);
E.Origin.Tell("[" + rank_string + "]" + E.Target.Name );
// //E.Origin.Tell(E.Target.Name + "'s rank has been reset");
// rank_string = E.Target.Level.ClanTag(Config);
// E.Origin.Tell("[" + rank_string + "]" + E.Target.Name );
}
// }
else
{
rank_string = rank_player_var.Value;
E.Origin.Tell("[" + rank_player_var.Value + "]" + E.Target.Name);
// else
// {
// rank_string = rank_player_var.Value;
// E.Origin.Tell("[" + rank_player_var.Value + "]" + E.Target.Name);
}
}
// }
// }
}
// }
}
}
}
// }
// }
//}

89
Commands/InviteGuestCommand.cs Normal file
View File

@ -0,0 +1,89 @@
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 ClanTagRankCommands.Commands
{
public class InviteGuestCommand : Command
{
private readonly IMetaServiceV2 _metaService;
public InviteGuestCommand(CommandConfiguration config, ITranslationLookup layout, IMetaServiceV2 metaService) :
base(config, layout)
{
Name = "inviteGuest";
Description = "invite a guest to play on donator server (use !find to get @id to invite)";
Alias = "guest";
Permission = EFClient.Permission.Trusted;
RequiresTarget = true;
Arguments = new[]
{
new CommandArgument
{
Name = "Player",
Required = true
}
};
_metaService = metaService;
}
public override async Task ExecuteAsync(GameEvent gameEvent)
{
if (gameEvent.Target.Level >= gameEvent.Origin.Level && gameEvent.Origin.Level != EFClient.Permission.Creator)
{
gameEvent.Origin.Tell("You can't invite someone with the same or higher permissions than you");
return;
}
var token = gameEvent.Owner.Manager.CancellationToken;
var clienttag = await _metaService.GetPersistentMetaByLookup("ClientTagV2", "ClientTagNameV2", gameEvent.Target.ClientId, token);
if (gameEvent.Target is not null && gameEvent.Target.IsIngame && (gameEvent.Target.Tag is null))
{
gameEvent.Target.Tell($"you have been temporarily invited to join Donator servers by {gameEvent.Origin.Name}");
}
if (gameEvent.Target is not null && clienttag is not null)
{
if ((clienttag?.Value.Contains("Guest") ?? false))
{
gameEvent.Target.Tag = null;
await _metaService.RemovePersistentMeta(EFMeta.ClientTagV2, gameEvent.Target.ClientId, gameEvent.Owner.Manager.CancellationToken);
gameEvent.Target.Tell($"Your guest invite has been revoked by {gameEvent.Origin.Name}");
gameEvent.Origin.Tell($"Guest invite has been revoked for {gameEvent.Target.Name}");
return;
}
else if((clienttag?.Value.Contains("Donator") ?? false) || (clienttag?.Value.Contains("VIP") ?? false))
{
gameEvent.Origin.Tell($"Can't set {clienttag?.Value} {gameEvent.Target.Name} to Guest, they already have a rank.");
return;
}
}
else if(gameEvent.Target is null)
{
gameEvent.Origin.Tell($"Target player is undefined");
return;
}
var availableTags = await _metaService.GetPersistentMetaValue<List<LookupValue<string>>>(EFMeta.ClientTagNameV2, token);
var matchingTag = availableTags.FirstOrDefault(tag => tag.Value == "Guest".Trim());
gameEvent.Target.Tag = matchingTag.Value;
await _metaService.SetPersistentMetaForLookupKey(EFMeta.ClientTagV2, EFMeta.ClientTagNameV2, matchingTag.Id,
gameEvent.Target.ClientId, token);
gameEvent.Origin.Tell($"Temporarily set {gameEvent.Target.Name} to Guest");
}
}
}

166
Commands/PermaperkCommand.cs
View File

@ -1,98 +1,98 @@
using SharedLibraryCore;
using SharedLibraryCore.Commands;
using SharedLibraryCore.Configuration;
using SharedLibraryCore.Database.Models;
using SharedLibraryCore.Interfaces;
using System.Threading.Tasks;
using ClanTagRankCommands;
using System;
using System.Runtime;
//using SharedLibraryCore;
//using SharedLibraryCore.Commands;
//using SharedLibraryCore.Configuration;
//using SharedLibraryCore.Database.Models;
//using SharedLibraryCore.Interfaces;
//using System.Threading.Tasks;
//using ClanTagRankCommands;
//using System;
//using System.Runtime;
namespace ClanTagRankCommands.Commands
{
/// <summary>
/// Example script command
/// </summary>
public class PermaperkCommand : Command
{
private readonly IMetaService _metaService;
private readonly IConfigurationHandler<Configuration> _configurationHandler;
private Configuration Config;
public PermaperkCommand(CommandConfiguration config, ITranslationLookup lookup, IMetaService metaService, IConfigurationHandlerFactory configurationHandlerFactory) : base(config, lookup)
{
_metaService = metaService;
_configurationHandler = configurationHandlerFactory.GetConfigurationHandler<Configuration>("ClanTagRankCommands");
if (_configurationHandler.Configuration() == null)
{
_configurationHandler.Set((Configuration)new Configuration().Generate());
_configurationHandler.Save();
}
Config = _configurationHandler.Configuration();
Name = "Permaperk";
Description = "force permaperks, clan tag, and speed if they don't set correctly.";
Alias = "perma";
Permission = EFClient.Permission.Trusted;
RequiresTarget = false;
Arguments = new[]
{
new CommandArgument()
{
}
};
}
//namespace ClanTagRankCommands.Commands
//{
// /// <summary>
// /// Example script command
// /// </summary>
// public class PermaperkCommand : Command
// {
// private readonly IMetaService _metaService;
// private readonly IConfigurationHandler<Configuration> _configurationHandler;
// private Configuration Config;
// public PermaperkCommand(CommandConfiguration config, ITranslationLookup lookup, IMetaService metaService, IConfigurationHandlerFactory configurationHandlerFactory) : base(config, lookup)
// {
// _metaService = metaService;
// _configurationHandler = configurationHandlerFactory.GetConfigurationHandler<Configuration>("ClanTagRankCommands");
// if (_configurationHandler.Configuration() == null)
// {
// _configurationHandler.Set((Configuration)new Configuration().Generate());
// _configurationHandler.Save();
// }
// Config = _configurationHandler.Configuration();
// Name = "Permaperk";
// Description = "force permaperks, clan tag, and speed if they don't set correctly.";
// Alias = "perma";
// Permission = EFClient.Permission.Trusted;
// RequiresTarget = false;
// Arguments = new[]
// {
// new CommandArgument()
// {
// }
// };
// }
public override async Task ExecuteAsync(GameEvent E)
{
//await yadb.notifyYADB("Kicked player @{target} after a successful vote started from @{origin}", $"testing", E.Data,":pencil:", E.Owner, E.Origin, E.Origin);
var speedtoggle = await _metaService.GetPersistentMeta("speedtoggle", E.Origin);
if (speedtoggle == null)
{
// speedtoggle == 1 means slower, unmodified speed)
await _metaService.AddPersistentMeta("speedtoggle", "0", E.Origin);
speedtoggle = await _metaService.GetPersistentMeta("speedtoggle", E.Origin);
}
//await E.Owner.SetDvarAsync("sv_iw4madmin_options", "speedtoggle;" + E.Origin.ClientNumber.ToString() + ";" + speedtoggle.Value.ToString());
// public override async Task ExecuteAsync(GameEvent E)
// {
// //await yadb.notifyYADB("Kicked player @{target} after a successful vote started from @{origin}", $"testing", E.Data,":pencil:", E.Owner, E.Origin, E.Origin);
// var speedtoggle = await _metaService.GetPersistentMeta("speedtoggle", E.Origin);
// if (speedtoggle == null)
// {
// // speedtoggle == 1 means slower, unmodified speed)
// await _metaService.AddPersistentMeta("speedtoggle", "0", E.Origin);
// speedtoggle = await _metaService.GetPersistentMeta("speedtoggle", E.Origin);
// }
// //await E.Owner.SetDvarAsync("sv_iw4madmin_options", "speedtoggle;" + E.Origin.ClientNumber.ToString() + ";" + speedtoggle.Value.ToString());
if (E.Origin is not null && E.Origin.CurrentServer == E.Owner && E.Origin.ClientNumber != -1 && E.Origin.ClientNumber != 9)
{
var rank_player_var = await _metaService.GetPersistentMeta("rank", E.Origin);
var rankName = E.Origin.Level.ClanTag(Config);
// if (E.Origin is not null && E.Origin.CurrentServer == E.Owner && E.Origin.ClientNumber != -1 && E.Origin.ClientNumber != 9)
// {
// var rank_player_var = await _metaService.GetPersistentMeta("rank", E.Origin);
// var rankName = E.Origin.Level.ClanTag(Config);
rank_player_var = await _metaService.GetPersistentMeta("rank", E.Origin);
if (rank_player_var == null)
{
// rank_player_var = await _metaService.GetPersistentMeta("rank", E.Origin);
// if (rank_player_var == null)
// {
await _metaService.AddPersistentMeta("rank", "none", E.Origin);
rank_player_var = await _metaService.GetPersistentMeta("rank", E.Origin);
}
// await _metaService.AddPersistentMeta("rank", "none", E.Origin);
// rank_player_var = await _metaService.GetPersistentMeta("rank", E.Origin);
// }
if (!(rank_player_var.Value.Contains("none")) && !(rank_player_var.Value.Contains("None")) && !(rank_player_var.Value.Contains("NONE")))
{
rankName = rank_player_var.Value;
// if (!(rank_player_var.Value.Contains("none")) && !(rank_player_var.Value.Contains("None")) && !(rank_player_var.Value.Contains("NONE")))
// {
// rankName = rank_player_var.Value;
}
if (E.Origin is not null && E.Origin.CurrentServer == E.Owner && E.Origin.ClientNumber != -1 && E.Origin.ClientNumber != 9)// && (E.Origin.Level > EFClient.Permission.Trusted || rankName != Config.User))
{
if(string.IsNullOrWhiteSpace(rankName))
{
// }
// if (E.Origin is not null && E.Origin.CurrentServer == E.Owner && E.Origin.ClientNumber != -1 && E.Origin.ClientNumber != 9)// && (E.Origin.Level > EFClient.Permission.Trusted || rankName != Config.User))
// {
// if(string.IsNullOrWhiteSpace(rankName))
// {
}
else
{
await E.Owner.ExecuteCommandAsync("setclantag" + " " + E.Origin.ClientNumber.ToString() + " " + rankName.ToString());
await E.Owner.ExecuteCommandAsync("setrole" + " " + E.Origin.ClientNumber.ToString() + " " + rankName.ToString());
E.Origin.Tell("Setting permaperks");
}
// }
// else
// {
// await E.Owner.ExecuteCommandAsync("setclantag" + " " + E.Origin.ClientNumber.ToString() + " " + rankName.ToString());
// await E.Owner.ExecuteCommandAsync("setrole" + " " + E.Origin.ClientNumber.ToString() + " " + rankName.ToString());
// E.Origin.Tell("Setting permaperks");
// }
//await E.Owner.SetDvarAsync("sv_iw4madmin_role", "setRole;" + E.Origin.ClientNumber.ToString() + ";" + rankName.ToString());
}
}
// //await E.Owner.SetDvarAsync("sv_iw4madmin_role", "setRole;" + E.Origin.ClientNumber.ToString() + ";" + rankName.ToString());
// }
// }
}
}
}
// }
// }
//}

140
Commands/ResetRankCommand.cs
View File

@ -1,81 +1,81 @@
using SharedLibraryCore;
using SharedLibraryCore.Commands;
using SharedLibraryCore.Configuration;
using SharedLibraryCore.Database.Models;
using SharedLibraryCore.Interfaces;
using System;
using System.Threading.Tasks;
//using SharedLibraryCore;
//using SharedLibraryCore.Commands;
//using SharedLibraryCore.Configuration;
//using SharedLibraryCore.Database.Models;
//using SharedLibraryCore.Interfaces;
//using System;
//using System.Threading.Tasks;
namespace ClanTagRankCommands.Commands
{
/// <summary>
/// Example script command
/// </summary>
public class ResetRankCommand : Command
{
readonly string rank = "rank";
string rank_string;
private readonly IMetaService _metaService;
private readonly IConfigurationHandler<Configuration> _configurationHandler;
private Configuration Config;
//namespace ClanTagRankCommands.Commands
//{
// /// <summary>
// /// Example script command
// /// </summary>
// public class ResetRankCommand : Command
// {
// readonly string rank = "rank";
// string rank_string;
// private readonly IMetaServiceV2 _metaService;
// private readonly IConfigurationHandler<Configuration> _configurationHandler;
// private Configuration Config;
public ResetRankCommand(CommandConfiguration config, ITranslationLookup lookup, IMetaService metaService, IConfigurationHandlerFactory configurationHandlerFactory) : base(config, lookup)
{
_metaService = metaService;
_configurationHandler = configurationHandlerFactory.GetConfigurationHandler<Configuration>("ClanTagRankCommands");
if (_configurationHandler.Configuration() == null)
{
_configurationHandler.Set((Configuration)new Configuration().Generate());
_configurationHandler.Save();
}
Config = _configurationHandler.Configuration();
// public ResetRankCommand(CommandConfiguration config, ITranslationLookup lookup, IMetaServiceV2 metaService, IConfigurationHandlerFactory configurationHandlerFactory) : base(config, lookup)
// {
// _metaService = metaService;
// _configurationHandler = configurationHandlerFactory.GetConfigurationHandler<Configuration>("ClanTagRankCommands");
// if (_configurationHandler.Configuration() == null)
// {
// _configurationHandler.Set((Configuration)new Configuration().Generate());
// _configurationHandler.Save();
// }
// Config = _configurationHandler.Configuration();
Name = "ResetRank";
Description = "set a user's clan tag Rank (does not give permissions)";
Alias = "rr";
Permission = EFClient.Permission.Administrator;
RequiresTarget = true;
Arguments = new[]
{
new CommandArgument()
{
//Name = "rank",
//Required = false
}
};
}
// Name = "ResetRank";
// Description = "set a user's clan tag Rank (does not give permissions)";
// Alias = "rr";
// Permission = EFClient.Permission.Administrator;
// RequiresTarget = true;
// Arguments = new[]
// {
// new CommandArgument()
// {
// //Name = "rank",
// //Required = false
// }
// };
// }
public override async Task ExecuteAsync(GameEvent E)
{
//var S = E.Owner;
rank_string = "none";
if(E.Target is not null)
{
await _metaService.AddPersistentMeta(rank, rank_string, E.Target);
rank_string = E.Target.Level.ClanTag(Config);
E.Origin.Tell(E.Target.Name + "'s rank has been reset to: " + rank_string);
if (E.Target is not null && E.Target.IsIngame )
{
if (string.IsNullOrWhiteSpace(rank_string))
{
await E.Owner.ExecuteCommandAsync("resetclantag" + " " + E.Target.ClientNumber.ToString());
// public override async Task ExecuteAsync(GameEvent E)
// {
// //var S = E.Owner;
// rank_string = "none";
// if(E.Target is not null)
// {
// await _metaService.SetPersistentMeta(rank, rank_string, E.Target.ClientId);
// rank_string = E.Target.Level.ClanTag(Config);
// E.Origin.Tell(E.Target.Name + "'s rank has been reset to: " + rank_string);
// if (E.Target is not null && E.Target.IsIngame )
// {
// if (string.IsNullOrWhiteSpace(rank_string))
// {
// await E.Owner.ExecuteCommandAsync("resetclantag" + " " + E.Target.ClientNumber.ToString());
await E.Owner.ExecuteCommandAsync("resetrole " + E.Target.ClientNumber.ToString());
// await E.Owner.ExecuteCommandAsync("resetrole " + E.Target.ClientNumber.ToString());
}
else
{
await E.Owner.ExecuteCommandAsync("setclantag" + " " + E.Target.ClientNumber.ToString() + " " + rank_string.ToString());
//await E.Owner.SetDvarAsync("sv_iw4madmin_role", "setRole;" + E.Target.ClientNumber.ToString() + ";" + rank_string.ToString());
await E.Owner.ExecuteCommandAsync("setrole " + E.Target.ClientNumber.ToString() + " " + rank_string.ToString());
}
}
// }
// else
// {
// await E.Owner.ExecuteCommandAsync("setclantag" + " " + E.Target.ClientNumber.ToString() + " " + rank_string.ToString());
// //await E.Owner.SetDvarAsync("sv_iw4madmin_role", "setRole;" + E.Target.ClientNumber.ToString() + ";" + rank_string.ToString());
// await E.Owner.ExecuteCommandAsync("setrole " + E.Target.ClientNumber.ToString() + " " + rank_string.ToString());
// }
// }
}
// }
}
}
}
// }
// }
//}

215
Commands/SetDonatorCommand.cs Normal file
View File

@ -0,0 +1,215 @@
using System.Collections.Generic;
using System.Linq;
using System.Security.Policy;
using System.Threading;
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 ClanTagRankCommands.Commands
{
public class SetDonatorCommand : Command
{
private readonly IMetaServiceV2 _metaService;
private readonly IRemoteCommandService _remoteCommandService;
public SetDonatorCommand(CommandConfiguration config, ITranslationLookup layout, IMetaServiceV2 metaService, IRemoteCommandService remoteCommandService) :
base(config, layout)
{
Name = "SetDonator";
Description = "Sets a player to Donator rank";
Alias = "Donator";
Permission = EFClient.Permission.Moderator;
RequiresTarget = true;
Arguments = new[]
{
new CommandArgument
{
Name = "Player",
Required = true
}
};
_metaService = metaService;
_remoteCommandService = remoteCommandService;
}
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 == "Donator".Trim());
var clienttag = await _metaService.GetPersistentMetaByLookup("ClientTagV2", "ClientTagNameV2", gameEvent.Target.ClientId, token);
if (gameEvent.Target is not null && gameEvent.Target.IsIngame)
{
if (gameEvent.Target.Tag is null || gameEvent.Target.Tag.Contains("Guest"))
{
gameEvent.Origin.Tell($"set {gameEvent.Target.Name}'s rank");
if (gameEvent.Target.IsIngame)
{
gameEvent.Target.Tell($"Your rank has been set to Donator");
}
var args3 = new List<string>();
args3.Add(matchingTag.Value);
await _remoteCommandService.Execute(gameEvent.Origin.ClientId, gameEvent.Target.ClientId, "sct",
args3, gameEvent.Owner);
//var sct = $"{Utilities.CommandPrefix}sct @{gameEvent.Target.ClientId} {matchingTag.Value}";
//await gameEvent.Owner.ExecuteCommandAsync(sct);
if (gameEvent.Target.Level < EFClient.Permission.Moderator && gameEvent.Target.Level != EFClient.Permission.Banned)
{
gameEvent.Target.SetLevel(EFClient.Permission.Trusted, gameEvent.Origin);
}
}
else if (gameEvent.Target.Tag.Contains("Donator"))
{
gameEvent.Origin.Tell($"Unset {gameEvent.Target.Name}'s rank");
if (gameEvent.Target.IsIngame)
{
gameEvent.Target.Tell($"Your Donator rank has been removed");
}
//var uct = $"{Utilities.CommandPrefix}uct @{gameEvent.Target.ClientId}";
//await gameEvent.Owner.ExecuteCommandAsync(uct);
var args = new List<string>();
var commandResponse =
await _remoteCommandService.Execute(gameEvent.Origin.ClientId, gameEvent.Target.ClientId, "uct",
args, gameEvent.Owner);
//string.Join(".", commandResponse.Select(result => result.Response));
if (gameEvent.Target.Level < EFClient.Permission.Moderator && gameEvent.Target.Level != EFClient.Permission.Banned)
{
gameEvent.Target.SetLevel(EFClient.Permission.User, gameEvent.Origin);
}
}
else if(gameEvent.Target.Tag is not null && !gameEvent.Target.Tag.Contains("Guest"))
{
gameEvent.Origin.Tell($"Error! Can't set {gameEvent.Target.Name}'s tag, because a different tag is already set");
}
}
else if(gameEvent.Target is not null && !gameEvent.Target.IsIngame)
{
if (clienttag is null || (clienttag?.Value.Contains("Guest") ?? false))
{
gameEvent.Origin.Tell($"set {gameEvent.Target.Name}'s rank");
var args4 = new List<string>();
args4.Add("Your rank has been set to Donator");
await _remoteCommandService.Execute(gameEvent.Origin.ClientId, gameEvent.Target.ClientId, "om",
args4, gameEvent.Owner);
//var om = $"{Utilities.CommandPrefix}om @{gameEvent.Target.ClientId} Your rank has been set to Donator";
//await gameEvent.Owner.ExecuteCommandAsync(om);
var args3 = new List<string>();
args3.Add(matchingTag.Value);
await _remoteCommandService.Execute(gameEvent.Origin.ClientId, gameEvent.Target.ClientId, "sct",
args3, gameEvent.Owner);
//var sct = $"{Utilities.CommandPrefix}sct @{gameEvent.Target.ClientId} {matchingTag.Value}";
//await gameEvent.Owner.ExecuteCommandAsync(sct);
if (gameEvent.Target.Level < EFClient.Permission.Moderator && gameEvent.Target.Level != EFClient.Permission.Banned)
{
gameEvent.Target.SetLevel(EFClient.Permission.Trusted, gameEvent.Origin);
}
}
else if ((clienttag?.Value.Contains("Donator") ?? false))
{
gameEvent.Origin.Tell($"Unset {gameEvent.Target.Name}'s rank");
//var om = $"{Utilities.CommandPrefix}om @{gameEvent.Target.ClientId} Your Donator rank has been removed";
//await gameEvent.Owner.ExecuteCommandAsync(om);
var args2 = new List<string>();
args2.Add("Your Donator rank has been removed");
await _remoteCommandService.Execute(gameEvent.Origin.ClientId, gameEvent.Target.ClientId, "om",
args2, gameEvent.Owner);
//var uct = $"{Utilities.CommandPrefix}uct @{gameEvent.Target.ClientId}";
//await gameEvent.Owner.ExecuteCommandAsync(uct);
var args = new List<string>();
var commandResponse =
await _remoteCommandService.Execute(gameEvent.Origin.ClientId, gameEvent.Target.ClientId, "uct",
args, gameEvent.Owner);
//string.Join(".", commandResponse.Select(result => result.Response));
if (gameEvent.Target.Level < EFClient.Permission.Moderator && gameEvent.Target.Level != EFClient.Permission.Banned)
{
gameEvent.Target.SetLevel(EFClient.Permission.User, gameEvent.Origin);
}
}
else if (gameEvent.Target.Tag is not null && clienttag is not null && !gameEvent.Target.Tag.Contains("Guest"))
{
gameEvent.Origin.Tell($"Error! Can't set {gameEvent.Target.Name}'s tag, because a different tag is already set");
}
}
else if(gameEvent.Target is null)
{
gameEvent.Origin.Tell($"Error! target player is null");
}
//gameEvent.Target.Tag = matchingTag.Value;
//await _metaService.SetPersistentMetaForLookupKey(EFMeta.ClientTagV2, EFMeta.ClientTagNameV2, matchingTag.Id,
// gameEvent.Target.ClientId, token);
//if (gameEvent.Target.Level < EFClient.Permission.Moderator)
//{
// gameEvent.Target.SetLevel(EFClient.Permission.Trusted, gameEvent.Origin);
//}
//gameEvent.Origin.Tell($"Set {gameEvent.Target.Name} to Donator");
//if (gameEvent.Target.IsIngame)
//{
// gameEvent.Target.Tell($"Your rank has been set to Donator!");
//}
//else
//{
// var cmd = $"{Utilities.CommandPrefix}om @{gameEvent.Target.ClientId} Your rank has been set to Donator!";
// await gameEvent.Owner.ExecuteCommandAsync(cmd);
// //var impersonatedCommandEvent = new GameEvent
// //{
// // Type = GameEvent.EventType.Command,
// // Origin = gameEvent.Origin,
// // //ImpersonationOrigin = gameEvent.Origin,
// // Message = cmd,
// // Data = cmd,
// // Owner = gameEvent.Owner,
// // CorrelationId = gameEvent.CorrelationId
// //};
// //gameEvent.Owner.Manager.AddEvent(impersonatedCommandEvent);
// //var result = await impersonatedCommandEvent.WaitAsync(Utilities.DefaultCommandTimeout,
// // gameEvent.Owner.Manager.CancellationToken);
// //await result.WaitAsync(Utilities.DefaultCommandTimeout, gameEvent.Owner.Manager.CancellationToken);
// // remove the added command response
// // todo: something weird happening making this change required
// //var responses = gameEvent.Owner.Manager.ProcessingEvents
// // .Where(ev => ev.Value.CorrelationId == impersonatedCommandEvent.CorrelationId)
// // .SelectMany(ev => ev.Value.Output)
// // .ToList();
// //foreach (var output in responses)
// // await gameEvent.Origin.Tell(_translationLookup["COMMANDS_RUN_AS_SUCCESS"].FormatExt(output))
// // .WaitAsync();
//}
}
}
}

14
Commands/SetRankCommand.cs
View File

@ -18,12 +18,12 @@ namespace ClanTagRankCommands.Commands
{
readonly string rank = "rank";
string rank_string;
private readonly IMetaService _metaService;
private readonly IMetaServiceV2 _metaService;
private readonly IConfigurationHandler<Configuration> _configurationHandler;
private Configuration Config;
public SetRankCommand(CommandConfiguration config, ITranslationLookup lookup, IMetaService metaService, IConfigurationHandlerFactory configurationHandlerFactory) : base(config, lookup)
public SetRankCommand(CommandConfiguration config, ITranslationLookup lookup, IMetaServiceV2 metaService, IConfigurationHandlerFactory configurationHandlerFactory) : base(config, lookup)
{
_metaService = metaService;
_configurationHandler = configurationHandlerFactory.GetConfigurationHandler<Configuration>("ClanTagRankCommands");
@ -57,18 +57,18 @@ namespace ClanTagRankCommands.Commands
rank_string = E.Data;
if(E.Target is not null)
{
var rank_player_var = await _metaService.GetPersistentMeta(rank, E.Target);
var rank_player_var = await _metaService.GetPersistentMeta(rank, E.Target.ClientId);
if (rank_player_var == null)
{
await _metaService.AddPersistentMeta(rank, "none", E.Target);
rank_player_var = await _metaService.GetPersistentMeta(rank, E.Target);
await _metaService.SetPersistentMeta(rank, "none", E.Target.ClientId);
rank_player_var = await _metaService.GetPersistentMeta(rank, E.Target.ClientId);
}
if (rank_string.Length > 0 && rank_string.Length < 9)
{
await _metaService.AddPersistentMeta(rank, rank_string, E.Target);
rank_player_var = await _metaService.GetPersistentMeta(rank, E.Target);
await _metaService.SetPersistentMeta(rank, rank_string, E.Target.ClientId);
rank_player_var = await _metaService.GetPersistentMeta(rank, E.Target.ClientId);
if(rank_player_var.Value == "none" || rank_player_var.Value == "None" || rank_player_var.Value == "NONE")
{

155
DataManager.cs Normal file
View File

@ -0,0 +1,155 @@
using ClanTagRankCommands;
using System.Collections.Generic;
using System.Linq;
using Data.Models;
//using Data.Models.Client;
using SharedLibraryCore.Interfaces;
using SharedLibraryCore;
using SharedLibraryCore.Commands;
using SharedLibraryCore.Configuration;
using SharedLibraryCore.Dtos;
using System.Threading.Tasks;
using static System.Enum;
using Microsoft.Extensions.Logging;
using ILogger = Microsoft.Extensions.Logging.ILogger;
using System.Text.Json.Serialization;
using System.Threading;
using SharedLibraryCore.Database.Models;
using SharedLibraryCore.Helpers;
using System;
using JsonSerializer = System.Text.Json.JsonSerializer;
using Serilog.Core;
using Data.Models.Client;
namespace ClanTagRankCommands;
public class DataManager
{
public DataManager(IMetaServiceV2 metaService, ILogger<Plugin> logger)
{
_logger = logger;
_metaService = metaService;
}
private readonly IMetaServiceV2 _metaService;
private readonly ILogger _logger;
public async Task<DonatorState> ReadPersistentData(int? ClientId, IManager manager)
{
var token = manager.CancellationToken;
var availableTags = await _metaService.GetPersistentMetaValue<List<LookupValue<string>>>(EFMeta.ClientTagNameV2, token);
var matchingTag = availableTags.FirstOrDefault(tag => tag.Value == "Donator".Trim());
_logger.LogInformation("Reading persistent data for {0}", ClientId);
DonatorState clientDonatorState = DonatorState.User;
if(ClientId is not null)
{
var existingtag = await _metaService.GetPersistentMetaByLookup("ClientTagV2", "ClientTagNameV2", (int)ClientId,
token);//GetAdditionalProperty<string>(EFMeta.ClientTagNameV2);
if (existingtag is null || existingtag.Value.Contains("Guest"))
{
_logger.LogInformation("No existing tag found for {0}", ClientId);
return clientDonatorState;
}
else if (existingtag.Value.Contains("Donator"))
{
_logger.LogInformation("Existing tag: {0}", existingtag.Value);
clientDonatorState = DonatorState.Donator;
}
else if (existingtag is not null && !existingtag.Value.Contains("Guest"))
{
_logger.LogInformation("Existing tag: {0}", existingtag.Value);
clientDonatorState = DonatorState.Other;
}
}
//var clientDonatorState = client.ToPartialClient().Tag ??
//Parse<DonatorState>(value: client.ToPartialClient().Tag ?? nameof(DonatorState.User));
return clientDonatorState;
}
//public async Task<DonatorStateMeta> GetCurrentMuteState(EFClient client)
//{
// try
// {
// //await _onMuteAction.WaitAsync();
// var ClientDonatorMeta = await ReadPersistentDataV2(client);
// if (ClientDonatorMeta is not null) return ClientDonatorMeta;
// // Return null if the client doesn't have old or new meta.
// var DonatorState = await ReadPersistentDataV1(client);
// ClientDonatorMeta = new DonatorStateMeta
// {
// //Reason = muteState is null ? string.Empty : _translationLookup["PLUGINS_MUTE_MIGRATED"],
// //Expiration = muteState switch
// //{
// // null => DateTime.UtcNow,
// // MuteState.Muted => null,
// // _ => DateTime.UtcNow
// //},
// DonatorState = muteState ?? DonatorState.User,
// CommandExecuted = true
// };
// // Migrate old mute meta, else, client has no state, so set a generic one, but don't write it to database.
// if (DonatorState is not null)
// {
// ClientDonatorMeta.CommandExecuted = false;
// await WritePersistentData(client, ClientDonatorMeta);
// //await CreatePenalty(muteState.Value, Utilities.IW4MAdminClient(), client, ClientDonatorMeta.Expiration,
// // ClientDonatorMeta.Reason);
// }
// else
// {
// client.SetAdditionalProperty(Plugin.MuteKey, ClientDonatorMeta);
// }
// return ClientDonatorMeta;
// }
// finally
// {
// //if (_onMuteAction.CurrentCount == 0) _onMuteAction.Release();
// }
//}
//private async Task<DonatorStateMeta?> ReadPersistentDataV2(EFClient client)
//{
// // Get meta from client
// var clientDonatorMeta = client.GetAdditionalProperty<DonatorStateMeta>(Plugin.DonatorKey);
// if (clientDonatorMeta is not null) return clientDonatorMeta;
// // Get meta from database and store in client if exists
// clientDonatorMeta = await _metaService.GetPersistentMetaValue<DonatorStateMeta>(Plugin.DonatorKey, client.ClientId);
// if (clientDonatorMeta is not null) client.SetAdditionalProperty(Plugin.DonatorKey, clientDonatorMeta);
// return clientDonatorMeta;
//}
//public async Task WritePersistentData(EFClient client, DonatorState state)
//{
// await _metaService.SetPersistentMeta(Plugin.DonatorKey, state.ToString(), client.ClientId);
// client.SetAdditionalProperty(Plugin.DonatorKey, state);
//}
}
public class DonatorStateMeta
{
//public string Reason { get; set; } = string.Empty;
//public DateTime? Expiration { get; set; }
public DonatorState DonatorState { get; set; }
[JsonIgnore] public bool CommandExecuted { get; set; }
}
public enum DonatorState
{
User,
Donator,
Other
}

4
GscApiController.cs
View File

@ -17,10 +17,10 @@ namespace WebfrontCore.Controllers.API
{
string rankName;
EFMeta customRankName;
private readonly IMetaService _metaService;
private readonly IMetaServiceV2 _metaService;
private readonly IConfigurationHandler<Configuration> _configurationHandler;
private Configuration Config;
public GscApiController(IManager manager, IMetaService metaService, IConfigurationHandlerFactory configurationHandlerFactory) : base(manager)
public GscApiController(IManager manager, IMetaServiceV2 metaService, IConfigurationHandlerFactory configurationHandlerFactory) : base(manager)
{
_metaService = metaService;
_configurationHandler = configurationHandlerFactory.GetConfigurationHandler<Configuration>("ClanTagRankCommands");

290
Plugin.cs
View File

@ -3,12 +3,17 @@ using SharedLibraryCore.Interfaces;
using System.Threading.Tasks;
using System.Threading;
using SharedLibraryCore.Database.Models;
using SharedLibraryCore.Helpers;
using System.Collections.Generic;
using Microsoft.Extensions.Logging;
using ILogger = Microsoft.Extensions.Logging.ILogger;
using Data.Models;
using System;
using SharedLibraryCore.Commands;
using JsonSerializer = System.Text.Json.JsonSerializer;
using System.Linq;
using Serilog.Core;
namespace ClanTagRankCommands
{
@ -18,24 +23,35 @@ namespace ClanTagRankCommands
private readonly IConfigurationHandler<Configuration> _configurationHandler;
private readonly ILogger _logger;
private Configuration Config;
readonly string rank = "rank";
string rankName = "none";
//readonly string rank = "rank";
//string rankName = "none";
private readonly IInteractionRegistration _interactionRegistration;
private static readonly string DonatorInteraction = "Webfront::Profile::Donator";
private static readonly string GuestInteraction = "Webfront::Profile::Guest";
private readonly IRemoteCommandService _remoteCommandService;
public string Name => "ClanTagRankCommands";
public float Version => 1.42f;
public float Version => 1.5f;
public string Author => "INSANEMODE";
private readonly IMetaService _metaService;
private readonly IMetaServiceV2 _metaService;
public Plugin(IMetaService metaService, IConfigurationHandlerFactory configurationHandlerFactory, ILogger<Plugin> logger)
public static string DonatorKey = "IW4MDonator";
public static DataManager DataManager;
public Plugin(IMetaServiceV2 metaService, IConfigurationHandlerFactory configurationHandlerFactory, ILogger<Plugin> logger, IInteractionRegistration interactionRegistration, IRemoteCommandService remoteCommandService)
{
_remoteCommandService = remoteCommandService;
_logger = logger;
_metaService = metaService;
_configurationHandler = (IConfigurationHandler<Configuration>)configurationHandlerFactory.GetConfigurationHandler<Configuration>("ClanTagRankCommands");
_interactionRegistration = interactionRegistration;
DataManager = new DataManager(metaService, logger);
}
public Task OnLoadAsync(IManager manager)// => Task.CompletedTask;
{
@ -48,138 +64,144 @@ namespace ClanTagRankCommands
string version = manager.Version;
string str = string.Format("Loaded {0} ({1}) by {2} in {3} ({4})!", (object)((IPlugin)this).Name, (object)((IPlugin)this).Version, (object)((IPlugin)this).Author, (object)"IW4MAdmin", (object)version);
_logger.LogInformation(str);
_interactionRegistration.RegisterInteraction(DonatorInteraction, async (clientId, game, token) =>
{
await Task.Delay(1);
_logger.LogDebug($"Donator button interaction for {clientId.Value}");
if (!clientId.HasValue)
{
_logger.LogDebug($"No client id provided");
return null;
}
//var client = manager.GetClientService().Get(clientId.Value).Result;
var DonatorState = await DataManager.ReadPersistentData(clientId.Value, manager);
_logger.LogDebug($"DonatorState: {(int)DonatorState}");
return DonatorState is DonatorState.User
? new InteractionData
{
EntityId = clientId.Value,
Name = "Set Donator",
DisplayMeta = "oi-circle-check",
ActionPath = "DynamicAction",
ActionMeta = new()
{
{ "InteractionId", "command" },
{ "Data", $"Donator" },
{ "ActionButtonLabel", "Confirm" },
{ "Name", "Set Donator rank" },
{ "ShouldRefresh", true.ToString() }
},
MinimumPermission = Data.Models.Client.EFClient.Permission.Administrator,
Source = Name,
Enabled = true,
PermissionAccess = "read",
PermissionEntity = "Interaction",
Description = "Set Donator rank for client"
}
: new InteractionData
{
EntityId = clientId.Value,
Name = "UnSet Donator",
DisplayMeta = "oi-circle-x",
ActionPath = "DynamicAction",
ActionMeta = new()
{
{ "InteractionId", "command" },
{ "Data", $"Donator" },
{ "ActionButtonLabel", "Confirm" },
{ "Name", "UnSet Donator rank" },
{ "ShouldRefresh", true.ToString() }
},
MinimumPermission = Data.Models.Client.EFClient.Permission.Administrator,
Source = Name,
Enabled = true,
PermissionAccess = "read",
PermissionEntity = "Interaction",
Description = "UnSet Donator rank for client"
};
});
_logger.LogDebug("Registered Donator Interaction");
_interactionRegistration.RegisterInteraction(GuestInteraction, async (clientId, game, token) =>
{
await Task.Delay(1);
_logger.LogDebug($"guest button interaction for {clientId.Value}");
if (!clientId.HasValue)
{
_logger.LogDebug($"No client id provided");
return null;
}
bool guest;
var clienttag = await _metaService.GetPersistentMetaByLookup("ClientTagV2", "ClientTagNameV2", (int)clientId,
token);
if(clienttag is not null && clienttag.Value.Contains("Guest"))
{
guest = false;
}
else if(clienttag is not null && !clienttag.Value.Contains("Guest"))
{
return null;
}
else
{
guest = true;
}
return guest
? new InteractionData
{
EntityId = clientId.Value,
Name = "Invite Guest",
DisplayMeta = "oi-people",
ActionPath = "DynamicAction",
ActionMeta = new()
{
{ "InteractionId", "command" },
{ "Data", $"Guest" },
{ "ActionButtonLabel", "Confirm" },
{ "Name", "Temporarily invite guest to donator server" },
{ "ShouldRefresh", true.ToString() }
},
MinimumPermission = Data.Models.Client.EFClient.Permission.Trusted,
Source = Name,
Enabled = true,
PermissionAccess = "read",
PermissionEntity = "Interaction",
Description = "Temporarily invite a guest, until they leave the server"
}
: new InteractionData
{
EntityId = clientId.Value,
Name = "Cancel Guest Invite",
DisplayMeta = "oi-circle-x",
ActionPath = "DynamicAction",
ActionMeta = new()
{
{ "InteractionId", "command" },
{ "Data", $"Guest" },
{ "ActionButtonLabel", "Confirm" },
{ "Name", "Cancel guest invite" },
{ "ShouldRefresh", true.ToString() }
},
MinimumPermission = Data.Models.Client.EFClient.Permission.Trusted,
Source = Name,
Enabled = true,
PermissionAccess = "read",
PermissionEntity = "Interaction",
Description = "Cancel a guest invite"
};
});
return Task.CompletedTask;
}
public async Task OnEventAsync(GameEvent E, Server S)// => Task.CompletedTask;
{
//if (E.Type == GameEvent.EventType.Join || E.Type == GameEvent.EventType.ChangePermission )
if ((E.Type == GameEvent.EventType.Other) && E.Subtype.Contains("RC"))
if (E.Type == GameEvent.EventType.Disconnect && (S.Hostname.Contains("Donator") || S.Hostname.Contains("Test")) && E.Origin.Tag == "Guest")
{
//Console.WriteLine("RC: " + E.Origin.Name);
if (E.Origin is not null && E.Origin.CurrentServer == S && E.Origin.ClientNumber != -1 && E.Origin.ClientNumber != 9)
{
var rank_player_var = await _metaService.GetPersistentMeta(rank, E.Origin);
rankName = E.Origin.Level.ClanTag(Config);
rank_player_var = await _metaService.GetPersistentMeta("rank", E.Origin);
if (rank_player_var == null)
{
await _metaService.AddPersistentMeta("rank", "none", E.Origin);
rank_player_var = await _metaService.GetPersistentMeta("rank", E.Origin);
}
if (!(rank_player_var.Value.Contains("none")) && !(rank_player_var.Value.Contains("None")) && !(rank_player_var.Value.Contains("NONE")))
{
rankName = rank_player_var.Value;
}
if (E.Origin is not null && E.Origin.CurrentServer == S && E.Origin.ClientNumber != -1 && E.Origin.ClientNumber != 9)// && (E.Origin.Level > EFClient.Permission.Trusted || rankName != Config.User))
{
if (string.IsNullOrWhiteSpace(rankName))
{
//await S.ExecuteCommandAsync("resetclantag" + " " + E.Origin.ClientNumber.ToString());
//await S.ExecuteCommandAsync("resetrole " + E.Origin.ClientNumber.ToString());
}
else
{
await S.ExecuteCommandAsync("setclantag" + " " + E.Origin.ClientNumber.ToString() + " " + rankName.ToString());
await S.ExecuteCommandAsync("setrole " + E.Origin.ClientNumber.ToString() + " " + rankName.ToString());
}
//await S.SetDvarAsync("sv_iw4madmin_role", "setRole;" + E.Origin.ClientNumber.ToString() + ";" + rankName.ToString());
}
}
E.Origin.Tag = null;
await _metaService.RemovePersistentMeta(EFMeta.ClientTagV2, E.Origin.ClientId,
E.Owner.Manager.CancellationToken);
}
//if ((E.Type == GameEvent.EventType.Connect))
//{
// //Console.WriteLine("RC: " + E.Origin.Name);
// if (E.Origin.CurrentServer == S && E.Origin is object && E.Origin.ClientNumber != -1 && E.Origin.ClientNumber != 9)
// {
// var rank_player_var = await _metaService.GetPersistentMeta(rank, E.Origin);
// rankName = E.Origin.Level.ClanTag(Config);
// rank_player_var = await _metaService.GetPersistentMeta("rank", E.Origin);
// if (rank_player_var == null)
// {
// await _metaService.AddPersistentMeta("rank", "none", E.Origin);
// rank_player_var = await _metaService.GetPersistentMeta("rank", E.Origin);
// }
// if (!(rank_player_var.Value.Contains("none")) && !(rank_player_var.Value.Contains("None")) && !(rank_player_var.Value.Contains("NONE")))
// {
// rankName = rank_player_var.Value;
// }
// if (E.Origin.CurrentServer == S && E.Origin is object && E.Origin.ClientNumber != -1 && E.Origin.ClientNumber != 9)// && (E.Origin.Level > EFClient.Permission.Trusted || rankName != Config.User))
// {
// if (string.IsNullOrWhiteSpace(rankName) || rankName.Length < 1)
// {
// //await S.ExecuteCommandAsync("resetclantag" + " " + E.Origin.ClientNumber.ToString());
// //await S.ExecuteCommandAsync("resetrole " + E.Origin.ClientNumber.ToString());
// }
// else
// {
// await S.ExecuteCommandAsync("setclantag" + " " + E.Origin.ClientNumber.ToString() + " " + rankName.ToString());
// await S.ExecuteCommandAsync("setrole " + E.Origin.ClientNumber.ToString() + " " + rankName.ToString());
// }
// //await S.SetDvarAsync("sv_iw4madmin_role", "setRole;" + E.Origin.ClientNumber.ToString() + ";" + rankName.ToString());
// }
// }
//}
//if ((E.Type == GameEvent.EventType.Other) && E.Subtype.Contains("YADB-Embed"))
//{
// Console.WriteLine(E.Extra);
// Console.WriteLine(E.Origin.Name);
//}
//if (E.Type == GameEvent.EventType.Start || E.Type == GameEvent.EventType.MapChange)
//{
// var currentclients = S.GetClientsAsList(); //GetActiveClients();
// foreach (EFClient client in currentclients)
// {
// if (client.CurrentServer == S && client is object && client.ClientNumber != -1 && client.ClientNumber != 9)
// {
// var rank_player_var = await _metaService.GetPersistentMeta("rank", client);
// rankName = client.Level.ClanTag(Config);
// rank_player_var = await _metaService.GetPersistentMeta("rank", client);
// if (rank_player_var == null)
// {
// await _metaService.AddPersistentMeta("rank", "none", client);
// rank_player_var = await _metaService.GetPersistentMeta("rank", client);
// }
// if (!(rank_player_var.Value.Contains("none")) && !(rank_player_var.Value.Contains("None")) && !(rank_player_var.Value.Contains("NONE")))
// {
// rankName = rank_player_var.Value;
// }
// if (client.CurrentServer == S && client is object && client.ClientNumber != -1 && client.ClientNumber != 9)
// {
// await S.SetDvarAsync("sv_iw4madmin_role", "setRole;" + client.ClientNumber.ToString() + ";" + rankName.ToString());
// await S.ExecuteCommandAsync("setclantag" + " " + client.ClientNumber.ToString() + " " + rankName.ToString());
// }
// }
// }
//}
//return Task.CompletedTask;
}
public Task OnTickAsync(Server S)// =>
{
@ -188,7 +210,13 @@ namespace ClanTagRankCommands
}
public Task OnUnloadAsync() => Task.CompletedTask;
public Task OnUnloadAsync() //=>
{
_interactionRegistration.UnregisterInteraction(DonatorInteraction);
_interactionRegistration.UnregisterInteraction(GuestInteraction);
return Task.CompletedTask;
}
}