public async Task <TaskResult> Join(string code, ulong userid, string token)
{
AuthToken authToken = await Context.AuthTokens.FindAsync(token);
// Return the same if the token is for the wrong user to prevent someone
// from knowing if they cracked another user's token. This is basically
// impossible to happen by chance but better safe than sorry in the case that
// the literal impossible odds occur, more likely someone gets a stolen token
// but is not aware of the owner but I'll shut up now - Spike
if (authToken == null || authToken.User_Id != userid)
{
return(new TaskResult(false, $"Incorrect token!"));
}
PlanetInvite invite = await Context.PlanetInvites.FindAsync(code);
if (invite == null)
{
return(new TaskResult(false, $"Code is not found!"));
}
PlanetBan ban = await Context.PlanetBans.FirstOrDefaultAsync(x => x.User_Id == userid && x.Planet_Id == invite.Planet_Id);
if (ban != null)
{
return(new TaskResult(false, $"User is banned from this planet!"));
}
PlanetMember mem = await Context.PlanetMembers.FirstOrDefaultAsync(x => x.User_Id == userid && x.Planet_Id == invite.Planet_Id);
if (mem != null)
{
return(new TaskResult(false, $"User is already in this planet!"));
}
Planet planet = await Context.Planets.FirstOrDefaultAsync(x => x.Id == invite.Planet_Id);
if (!planet.Public)
{
return(new TaskResult(false, $"Planet is set to private!"));
}
PlanetMember member = new PlanetMember()
{
User_Id = userid,
Planet_Id = invite.Planet_Id,
};
await Context.PlanetMembers.AddAsync(member);
await Context.SaveChangesAsync();
return(new TaskResult(true, $"Joined Planet"));
}
public async Task <TaskResult> BanUser(ulong target_id, ulong planet_id, string reason, string token, uint time)
{
AuthToken authToken = await Context.AuthTokens.FindAsync(token);
if (authToken == null)
{
return(new TaskResult(false, "Failed to authorize user."));
}
ServerPlanet planet = await ServerPlanet.FindAsync(planet_id);
if (!(await planet.AuthorizedAsync(authToken, PlanetPermissions.Ban)))
{
return(new TaskResult(false, "You are not authorized to do this."));
}
ServerPlanetMember member = await Context.PlanetMembers.FirstOrDefaultAsync(x => x.Id == target_id &&
x.Planet_Id == planet_id);
PlanetBan ban = new PlanetBan()
{
Id = IdManager.Generate(),
Reason = reason,
Planet_Id = planet_id,
User_Id = member.User_Id,
Banner_Id = authToken.User_Id,
Time = DateTime.UtcNow,
Permanent = false
};
if (time <= 0)
{
ban.Permanent = true;
}
else
{
ban.Minutes = time;
}
// Add channel to database
await Context.PlanetBans.AddAsync(ban);
List <ServerPlanetRoleMember> roles = await Task.Run(() => Context.PlanetRoleMembers.Where(x => x.Member_Id == target_id && x.Planet_Id == planet_id).ToList());
foreach (ServerPlanetRoleMember role in roles)
{
Context.PlanetRoleMembers.Remove(role);
}
Context.PlanetMembers.Remove(member);
await Context.SaveChangesAsync();
return(new TaskResult(true, $"Successfully banned user {member.Nickname}"));
}
public async Task <TaskResult> BanUser(ulong id, ulong Planet_Id, string reason, ulong userid, string token, uint time)
{
AuthToken authToken = await Context.AuthTokens.FindAsync(token);
// Return the same if the token is for the wrong user to prevent someone
// from knowing if they cracked another user's token. This is basically
// impossible to happen by chance but better safe than sorry in the case that
// the literal impossible odds occur, more likely someone gets a stolen token
// but is not aware of the owner but I'll shut up now - Spike
if (authToken == null || authToken.User_Id != userid)
{
return(new TaskResult(false, "Failed to authorize user."));
}
ServerPlanet planet = await ServerPlanet.FindAsync(Planet_Id, Mapper);
if (!(await planet.AuthorizedAsync(authToken, PlanetPermissions.Ban)))
{
return(new TaskResult(false, "You are not authorized to do this."));
}
PlanetBan ban = new PlanetBan()
{
Reason = reason,
Planet_Id = Planet_Id,
User_Id = id,
Banner_Id = userid,
Time = DateTime.UtcNow,
Permanent = false
};
if (time <= 0)
{
ban.Permanent = true;
}
else
{
ban.Minutes = time;
}
// Add channel to database
await Context.PlanetBans.AddAsync(ban);
PlanetMember member = await Context.PlanetMembers.Where(x => x.User_Id == id).FirstOrDefaultAsync();
Context.PlanetMembers.Remove(member);
await Context.SaveChangesAsync();
return(new TaskResult(true, $"Successfully banned user {id}"));
}
public async Task <TaskResult <ClientPlanetInvite> > GetInvite(string code, ulong userid)
{
PlanetInvite invite = await Context.PlanetInvites.FirstOrDefaultAsync(x => x.Code == code);
if (invite.IsPermanent() == false)
{
if (DateTime.UtcNow > invite.Time.AddMinutes((double)invite.Hours))
{
Context.PlanetInvites.Remove(invite);
await Context.SaveChangesAsync();
return(new TaskResult <ClientPlanetInvite>(false, $"Invite is expired", null));
}
}
PlanetBan ban = await Context.PlanetBans.FirstOrDefaultAsync(x => x.User_Id == userid && x.Planet_Id == invite.Planet_Id);
if (ban != null)
{
return(new TaskResult <ClientPlanetInvite>(false, $"User is banned from this planet!", null));
}
PlanetMember member = await Context.PlanetMembers.FirstOrDefaultAsync(x => x.User_Id == userid && x.Planet_Id == invite.Planet_Id);
if (member != null)
{
return(new TaskResult <ClientPlanetInvite>(false, $"User is already in this planet!", null));
}
ClientPlanetInvite clientinvite = ClientPlanetInvite.FromBase(invite, Mapper);
Planet planet = await Context.Planets.FirstOrDefaultAsync(x => x.Id == invite.Planet_Id);
if (!planet.Public)
{
return(new TaskResult <ClientPlanetInvite>(false, $"Planet is set to private!", null));
}
clientinvite.PlanetName = planet.Name;
return(new TaskResult <ClientPlanetInvite>(true, $"Successfully got invite", clientinvite));
}
