/// <summary>
/// Returns a role in a planet
/// </summary>
public async Task <TaskResult <PlanetRole> > GetPlanetRole(ulong role_id, string token)
{
AuthToken authToken = await Context.AuthTokens.FindAsync(token);
PlanetRole role = await Context.PlanetRoles.FindAsync(role_id);
if (authToken == null)
{
return(new TaskResult <PlanetRole>(false, "Failed to authorize user.", null));
}
ServerPlanet planet = await ServerPlanet.FindAsync(role.Planet_Id);
if (planet == null)
{
return(new TaskResult <PlanetRole>(false, $"Could not find planet {role.Planet_Id}", null));
}
if (!(await planet.IsMemberAsync(authToken.User_Id)))
{
return(new TaskResult <PlanetRole>(false, "Failed to authorize user.", null));
}
return(new TaskResult <PlanetRole>(true, $"Retrieved role.", role));
}
/// <summary>
/// Returns the category permissions node for this category
/// </summary>
public async Task <CategoryPermissionsNode> GetCategoryPermissionsNode(PlanetRole role)
{
// For SOME reason the args need to be in this order
var response = await ClientUserManager.Http.GetAsync($"api/node/category/{Id}/{role.Id}", HttpCompletionOption.ResponseHeadersRead);
if (!response.IsSuccessStatusCode)
{
Console.WriteLine("Failed to deserialize result from GetPermissionsNode in category");
Console.WriteLine(await response.Content.ReadAsStringAsync());
return(null);
}
// Return the deserialized node - it may be null, but that's ok
return(await JsonSerializer.DeserializeAsync <CategoryPermissionsNode>(await response.Content.ReadAsStreamAsync()));
}
public async Task SetAsync(CommandContext ctx, double rate, [Remainder] string rolename)
{
if (await ctx.Member.IsOwner() != true)
{
await ctx.ReplyAsync($"Only the owner of this server can use this command!");
return;
}
RoleIncomes roleincome = await Client.DBContext.RoleIncomes.FirstOrDefaultAsync(x => x.RoleName == rolename && x.PlanetId == ctx.Message.Planet_Id);
if (roleincome == null)
{
PlanetRole role = await(await Cache.GetPlanet(ctx.Planet.Id)).GetRole(rolename);
if (role == null)
{
await ctx.ReplyAsync($"Could not find role {rolename}!");
return;
}
roleincome = new RoleIncomes();
roleincome.Income = rate;
roleincome.RoleId = role.Id;
roleincome.PlanetId = ctx.Message.Planet_Id;
roleincome.RoleName = role.Name;
roleincome.LastPaidOut = DateTime.UtcNow;
Client.DBContext.RoleIncomes.Add(roleincome);
Client.DBContext.SaveChanges();
await ctx.ReplyAsync($"Set {rolename}'s hourly income/cost to {roleincome.Income} coins!");
}
else
{
roleincome.Income = rate;
await Client.DBContext.SaveChangesAsync();
await ctx.ReplyAsync($"Set {rolename}'s hourly income/cost to {roleincome.Income} coins!");
}
}
public async Task UpdateRole(string json)
{
PlanetRole role = JsonConvert.DeserializeObject <PlanetRole>(json);
if (role == null)
{
Console.WriteLine("Failed to deserialize role in role update.");
return;
}
Console.WriteLine($"RECIEVE: Planet role update ping for role {role.Id}");
Console.WriteLine(json);
await SetUpdatedRole(role);
if (OnRoleUpdate != null)
{
await OnRoleUpdate.Invoke(role);
}
}
public async Task ViewAsync(CommandContext ctx, [Remainder] string rolename)
{
PlanetRole role = await(await Cache.GetPlanet(ctx.Planet.Id)).GetRole(rolename);
if (role == null)
{
await ctx.ReplyAsync($"Could not find role {rolename}");
return;
}
RoleIncomes roleincome = await Client.DBContext.RoleIncomes.FirstOrDefaultAsync(x => x.RoleName == rolename && x.PlanetId == ctx.Message.Planet_Id);
if (roleincome == null)
{
await ctx.ReplyAsync($"Hourly Income/Cost has not been set for role {rolename}");
return;
}
await ctx.ReplyAsync($"Hourly Income/Cost for {rolename} is {roleincome.Income} coins");
}
public async Task SetUpdatedRole(PlanetRole role)
{
PlanetRolesCache.AddOrUpdate(role.Id, role, (key, old) => role);
}
/// <summary>
/// Returns a ServerPlanetRole using a PlanetRole as a base
/// </summary>
public static ServerPlanetRole FromBase(PlanetRole planetrole)
{
return(MappingManager.Mapper.Map <ServerPlanetRole>(planetrole));
}
public async Task <ChatChannelPermissionsNode> GetChatChannelPermissionsNodeAsync(PlanetRole role)
{
var response = await ClientUserManager.Http.GetAsync($"api/node/channel/{Id}/{role.Id}", HttpCompletionOption.ResponseHeadersRead);
if (response.IsSuccessStatusCode)
{
Console.WriteLine("Critical error for GetPermissionsNode in channel");
Console.WriteLine(await response.Content.ReadAsStringAsync());
return(null);
}
// Return the deserialized node - it may be null, but that's ok
return(await JsonSerializer.DeserializeAsync <ChatChannelPermissionsNode>(await response.Content.ReadAsStreamAsync()));
}
public async Task <PermissionsNode> GetPermissionsNodeAsync(PlanetRole role)
{
return(await GetChatChannelPermissionsNodeAsync(role));
}
private static async Task RoleMembership(HttpContext ctx, ValourDB db, ulong member_id,
[FromHeader] string authorization)
{
AuthToken auth = await ServerAuthToken.TryAuthorize(authorization, db);
if (auth is null)
{
await TokenInvalid(ctx); return;
}
ServerPlanetMember target_member = await db.PlanetMembers
.Include(x => x.Planet)
.Include(x => x.RoleMembership)
.FirstOrDefaultAsync(x => x.Id == member_id);
if (target_member is null)
{
ctx.Response.StatusCode = 404;
await ctx.Response.WriteAsync("Target member not found");
return;
}
// Ensure auth user is member of planet
ServerPlanetMember member = await db.PlanetMembers.FirstOrDefaultAsync(x => x.Planet_Id == target_member.Planet_Id &&
x.User_Id == auth.User_Id);
if (member is null)
{
ctx.Response.StatusCode = 403;
await ctx.Response.WriteAsync("Auth member not found");
return;
}
switch (ctx.Request.Method)
{
case "GET":
{
ctx.Response.StatusCode = 200;
await ctx.Response.WriteAsJsonAsync(target_member.RoleMembership);
return;
}
case "POST":
{
if (!auth.HasScope(UserPermissions.PlanetManagement))
{
ctx.Response.StatusCode = 403;
await ctx.Response.WriteAsync("Token lacks UserPermissions.PlanetManagement");
return;
}
if (!await member.HasPermissionAsync(PlanetPermissions.ManageRoles, db))
{
ctx.Response.StatusCode = 403;
await ctx.Response.WriteAsync("Token lacks PlanetPermissions.ManageRoles");
return;
}
// Get body rolemember object
var roleMember = await JsonSerializer.DeserializeAsync <ServerPlanetRoleMember>(ctx.Request.Body);
if (roleMember is null)
{
ctx.Response.StatusCode = 400;
await ctx.Response.WriteAsync("Include role member in body");
return;
}
PlanetRole role = await db.PlanetRoles.FindAsync(roleMember.Role_Id);
if (role is null)
{
ctx.Response.StatusCode = 400;
await ctx.Response.WriteAsync("Role not found");
return;
}
if (role.Planet_Id != member.Planet_Id || role.Planet_Id != target_member.Planet_Id)
{
ctx.Response.StatusCode = 400;
await ctx.Response.WriteAsync("Planet id mismatch");
return;
}
var callerAuth = await member.GetAuthorityAsync();
// Ensure role has less authority than user adding it
if (role.GetAuthority() >= callerAuth)
{
ctx.Response.StatusCode = 403;
await ctx.Response.WriteAsync("Can only add roles with lower authority than your own");
return;
}
// Ensure target member has less authority than caller
if (await target_member.GetAuthorityAsync() >= callerAuth)
{
ctx.Response.StatusCode = 403;
await ctx.Response.WriteAsync("Target has higher or equal authority");
return;
}
// Ensure things match properly
roleMember.Member_Id = target_member.Id;
roleMember.User_Id = target_member.User_Id;
roleMember.Planet_Id = target_member.Planet_Id;
// Add id
roleMember.Id = IdManager.Generate();
await db.PlanetRoleMembers.AddAsync(roleMember);
await db.SaveChangesAsync();
ctx.Response.StatusCode = 201;
await ctx.Response.WriteAsync(roleMember.Id.ToString());
return;
}
}
}
/// <summary>
/// Returns the permissions node for this category
/// </summary>
public async Task <PermissionsNode> GetPermissionsNodeAsync(PlanetRole role)
{
return(await GetCategoryPermissionsNode(role));
}
