public virtual async Task <bool> AddGrantedPermissionAsync(IPermissionActor actor, string permission)
{
if (actor is IPermissionRole)
{
var roleData = m_PermissionRolesDataStore.Roles.First(d => d.Id?.Equals(actor.Id, StringComparison.OrdinalIgnoreCase) ?? false);
if (roleData == null)
{
return(false);
}
roleData.Permissions ??= new ();
roleData.Permissions.Add(permission);
await m_PermissionRolesDataStore.SaveChangesAsync();
return(true);
}
var userData = await m_UserDataStore.GetUserDataAsync(actor.Id, actor.Type);
if (userData == null)
{
return(false);
}
userData.Permissions ??= new();
userData.Permissions.Add(permission);
await m_UserDataStore.SetUserDataAsync(userData);
return(true);
}
public virtual async Task <bool> AddRoleToActorAsync(IPermissionActor actor, string roleId)
{
if (actor == null)
{
throw new ArgumentNullException(nameof(actor));
}
if (string.IsNullOrEmpty(roleId))
{
throw new ArgumentNullException(nameof(roleId));
}
var userData = await m_UserDataStore.GetUserDataAsync(actor.Id, actor.Type);
if (userData == null)
{
return(false);
}
userData.Roles ??= new HashSet <string>();
if (userData.Roles.Contains(roleId))
{
return(true);
}
userData.Roles.Add(roleId);
await m_UserDataStore.SetUserDataAsync(userData);
await m_EventBus.EmitAsync(m_Runtime, this, new PermissionActorRoleAddedEvent(actor, roleId));
return(true);
}
protected virtual void OnPlayerDisconnected(SteamPlayer steamPlayer)
{
var user = GetUser(steamPlayer);
if (user == null)
{
return;
}
if (user.Session is UnturnedUserSession session)
{
session.OnSessionEnd();
}
AsyncHelper.RunSync(async() =>
{
var disconnectedEvent = new UserDisconnectedEvent(user);
await m_EventBus.EmitAsync(m_Runtime, this, disconnectedEvent);
m_Users.Remove(user);
var userData = await m_UserDataStore.GetUserDataAsync(user.Id, user.Type);
if (userData == null)
{
return;
}
userData.LastSeen = DateTime.Now;
await m_UserDataStore.SetUserDataAsync(userData);
});
}
public virtual async Task <bool> AddRoleToActorAsync(IPermissionActor actor, string roleId)
{
var userData = await m_UserDataStore.GetUserDataAsync(actor.Id, actor.Type);
if (userData.Roles.Contains(roleId))
{
return(true);
}
userData.Roles.Add(roleId);
await m_UserDataStore.SetUserDataAsync(userData);
return(true);
}
private void UpdateLastSeen(string id, string type)
{
UniTask.RunOnThreadPool(async() =>
{
var userData = await m_UserDataStore.GetUserDataAsync(id, type);
if (userData == null)
{
return;
}
userData.LastSeen = DateTime.Now;
await m_UserDataStore.SetUserDataAsync(userData);
}).Forget();
}
public async Task SeedUserDataAsync(string actorId, string actorType, string displayName, Dictionary <string, object> data = null)
{
var userData = await m_UserDataStore.GetUserDataAsync(actorId, actorType);
if (userData != null)
{
return; // no seeding
}
var autoAssignRoles = new HashSet <string>(await m_PermissionRoleStore.GetAutoAssignedRolesAsync(actorId, actorType));
userData = new UserData
{
Data = data ?? new Dictionary <string, object>(),
Id = actorId,
Type = actorType,
LastSeen = DateTime.Now,
FirstSeen = DateTime.Now,
Permissions = new HashSet <string>(),
Roles = autoAssignRoles,
LastDisplayName = displayName
};
await m_UserDataStore.SetUserDataAsync(userData);
}
public async Task SeedUserDataAsync(string actorId, string actorType, string?displayName, Dictionary <string, object?>?data = null)
{
if (string.IsNullOrEmpty(actorId))
{
throw new ArgumentException(nameof(actorId));
}
if (string.IsNullOrEmpty(actorType))
{
throw new ArgumentException(nameof(actorType));
}
var userData = await m_UserDataStore.GetUserDataAsync(actorId, actorType);
if (userData != null)
{
return; // no seeding
}
var autoAssignRoles = new HashSet <string>(await m_PermissionRoleStore.GetAutoAssignedRolesAsync(actorId, actorType));
userData = new UserData
{
Data = data ?? new Dictionary <string, object?>(),
Id = actorId,
Type = actorType,
LastSeen = DateTime.Now,
FirstSeen = DateTime.Now,
Permissions = new HashSet <string>(),
Roles = autoAssignRoles,
LastDisplayName = displayName
};
await m_UserDataStore.SetUserDataAsync(userData);
}
private async void SaveDeathLocation(PlayerLife sender, EDeathCause cause, ELimb limb, CSteamID instigator)
{
var userData = await m_UserDataStore.GetUserDataAsync(sender.player.channel.owner.playerID.steamID.ToString(), "player");
userData.Data["deathLocation"] = sender.transform.position.ToSerializableVector3();
await m_UserDataStore.SetUserDataAsync(userData);
}
public override Task <decimal> UpdateBalanceAsync(string ownerId, string ownerType, decimal amount, string _)
{
return(m_Dispatcher.EnqueueV2(async() =>
{
var balance = await m_UserDataStore.GetUserDataAsync <decimal?>(ownerId, ownerType, TableName) ??
DefaultBalance;
var newBalance = balance + amount;
if (newBalance < 0)
{
throw new NotEnoughBalanceException(
m_StringLocalizer["economy:fail:not_enough_balance",
new { Amount = amount, Balance = balance, EconomyProvider = (IEconomyProvider)this }],
balance);
}
await m_UserDataStore.SetUserDataAsync(ownerId, ownerType, TableName, balance);
return balance;
}));
}
private Task SaveConfigAsync(ITargetConfig config, CancellationToken cancellationToken = default)
{
if (config is GroupConfig groupConfig)
{
return(_groupConfigStore.SetGroupConfigAsync(groupConfig, cancellationToken));
}
else if (config is UserData userData)
{
return(_userDataStore.SetUserDataAsync(userData, cancellationToken));
}
return(Task.CompletedTask);
}
private async Task <bool> SaveUserDataAsync(CommandContext context, UserData data, CancellationToken cancellationToken = default)
{
try
{
await _userDataStore.SetUserDataAsync(data, false, cancellationToken).ConfigureAwait(false);
return(true);
}
catch (Exception ex) when(ex.LogAsError(_log, "Failed saving notes for user {UserID} in the database", data.ID))
{
await context.ReplyTextAsync("/alert Failed saving notes in the database.", cancellationToken).ConfigureAwait(false);
return(false);
}
}
public override Task <decimal> UpdateBalanceAsync(string ownerId, string ownerType, decimal amount, string _)
{
var tcs = new TaskCompletionSource <decimal>();
m_EconomyDispatcher.Enqueue(async() =>
{
var balance = await m_UserDataStore.GetUserDataAsync <decimal?>(ownerId, ownerType, TableName) ??
DefaultBalance;
var newBalance = balance + amount;
if (newBalance < 0)
{
throw new NotEnoughBalanceException(
StringLocalizer["economy:fail:not_enough_balance",
new { Balance = balance - amount, CurrencySymbol }], balance);
}
await m_UserDataStore.SetUserDataAsync(ownerId, ownerType, TableName, balance);
tcs.SetResult(balance);
});
return(tcs.Task);
}
protected override async UniTask OnExecuteAsync()
{
if (Context.Parameters.Length < 1 || Context.Parameters.Length > 2)
{
throw new CommandWrongUsageException(Context);
}
if (Context.Parameters.Length == 1 && Context.Actor.Type != KnownActorTypes.Player)
{
throw new CommandWrongUsageException(Context);
}
if (Context.Parameters.Length == 2 && await CheckPermissionAsync("others") == PermissionGrantResult.Deny)
{
throw new NotEnoughPermissionException(Context, "others");
}
var uPlayer = Context.Parameters.Length == 1
? (UnturnedUser)Context.Actor
: await Context.Parameters.GetAsync <UnturnedUser>(0);
if (uPlayer == null)
{
throw new UserFriendlyException(m_StringLocalizer["commands:failed_player", new { Player = Context.Parameters[0] }]);
}
UserData userData = await m_UserDataStore.GetUserDataAsync(uPlayer.Id, uPlayer.Type);
if (!userData.Data.ContainsKey("homes"))
{
throw new UserFriendlyException(m_StringLocalizer["home:no_home"]);
}
var homes = (Dictionary <object, object>)userData.Data["homes"];
string homeName = Context.Parameters[0];
if (!homes.ContainsKey(homeName))
{
throw new UserFriendlyException(m_StringLocalizer["home:invalid_home", new { Home = homeName }]);
}
homes.Remove(homeName);
userData.Data["homes"] = homes;
await m_UserDataStore.SetUserDataAsync(userData);
await uPlayer.PrintMessageAsync(m_StringLocalizer["home:delete", new { Home = homeName }]);
}
public async Task SavePersistentDataAsync <T>(string key, T data)
{
var userData = await m_UserDataStore.GetUserDataAsync(Id, Type);
userData.Data ??= new Dictionary <string, object>();
if (userData.Data.ContainsKey(key))
{
userData.Data[key] = data;
}
else
{
userData.Data.Add(key, data);
}
await m_UserDataStore.SetUserDataAsync(userData);
}
public async Task SavePersistentDataAsync <T>(string key, T?data)
{
if (string.IsNullOrEmpty(key))
{
throw new ArgumentException(nameof(key));
}
var userData = await m_UserDataStore.GetUserDataAsync(Id, Type) ?? new UserData();
userData.Data ??= new Dictionary <string, object?>();
if (userData.Data.ContainsKey(key))
{
userData.Data[key] = data;
}
else
{
userData.Data.Add(key, data);
}
await m_UserDataStore.SetUserDataAsync(userData);
}
public async Task <bool> BanAsync(IUser user, IUser?instigator = null, string?reason = null, DateTime?expireDate = null)
{
if (expireDate.HasValue && expireDate.Value < DateTime.Now)
{
return(false);
}
var data = await m_UserDataStore.GetUserDataAsync(user.Id, user.Type);
if (data == null)
{
return(false);
}
expireDate ??= DateTime.MaxValue;
reason ??= m_StringLocalizer["ban_default"];
data.BanInfo = new BanData(reason, instigator, expireDate);
await m_UserDataStore.SetUserDataAsync(data);
return(true);
}
public async Task HandleEventAsync(object sender, UnturnedPlayerDeathEvent @event)
{
await UniTask.SwitchToMainThread();
var id = @event.Player.EntityInstanceId;
var position = @event.Player.Transform.Position.ToSerializableVector();
UniTask.RunOnThreadPool(async() =>
{
var userData = await m_UserDataStore.GetUserDataAsync(id, KnownActorTypes.Player);
if (userData == null)
{
var displayName = @event.Player.SteamPlayer.playerID.characterName;
await m_UserDataSeeder.SeedUserDataAsync(id, KnownActorTypes.Player, displayName,
new() { { "deathLocation", position } });
return;
}
userData.Data["deathLocation"] = position;
await m_UserDataStore.SetUserDataAsync(userData);
}).Forget();
}
protected override async UniTask OnExecuteAsync()
{
if (Context.Parameters.Length > 1)
{
throw new CommandWrongUsageException(Context);
}
UnturnedUser uPlayer = (UnturnedUser)Context.Actor;
UserData userData = await m_UserDataStore.GetUserDataAsync(uPlayer.Id, uPlayer.Type);
if (!userData.Data.ContainsKey("homes"))
{
userData.Data.Add("homes", new Dictionary <string, SerializableVector3>());
}
var homes = (Dictionary <object, object>)userData.Data["homes"];
int amountOfHomes = homes.Count;
// If this is the user's first home, or they have permission to make infinite homes, then skip the check
if (amountOfHomes != 0 && await CheckPermissionAsync("infinite") == PermissionGrantResult.Deny)
{
bool any = false;
for (int i = amountOfHomes; i < 11; i++)
{
// No logic unless it finds a permission with a number to limit homes
if (await CheckPermissionAsync(i.ToString()) == PermissionGrantResult.Deny)
{
continue;
}
any = true;
if (i > amountOfHomes)
{
break;
}
throw new UserFriendlyException(m_StringLocalizer["home:too_many"]);
}
// If there is no permission, only allow 1 home
if (!any)
{
throw new UserFriendlyException(m_StringLocalizer["home:too_many"]);
}
}
if (Context.Parameters.Length == 0)
{
homes["home"] = uPlayer.Player.Player.transform.position.ToSerializableVector();
userData.Data["homes"] = homes;
await m_UserDataStore.SetUserDataAsync(userData);
await uPlayer.PrintMessageAsync(m_StringLocalizer["home:set", new { Home = "home" }]);
}
else
{
string home = Context.Parameters[0];
homes[home] = uPlayer.Player.Player.transform.position.ToSerializableVector();
userData.Data["homes"] = homes;
await m_UserDataStore.SetUserDataAsync(userData);
await uPlayer.PrintMessageAsync(m_StringLocalizer["home:set", new { Home = home }]);
}
}
public static Task SetUserDataAsync(this IUserDataStore store, UserData data, CancellationToken cancellationToken = default) => store.SetUserDataAsync(data, true, cancellationToken);
