public async Task <TaskResult <PlanetInvite> > CreateInvite(ulong Planet_Id, ulong userid, string token, int hours)
{
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 <PlanetInvite>(false, "Failed to authorize user.", null));
}
ServerPlanet planet = await ServerPlanet.FindAsync(Planet_Id, Mapper);
if (!(await planet.AuthorizedAsync(authToken, PlanetPermissions.Invite)))
{
return(new TaskResult <PlanetInvite>(false, "You are not authorized to do this.", null));
}
PlanetInvite invite = new PlanetInvite()
{
Planet_Id = Planet_Id,
Issuer_Id = userid,
Time = DateTime.UtcNow,
Hours = hours
};
Random random = new Random();
const string chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
string code = new string(Enumerable.Repeat(chars, 8).Select(s => s[random.Next(s.Length)]).ToArray());
PlanetInvite test = await Context.PlanetInvites.FirstOrDefaultAsync(x => x.Code == code);
while (test != null)
{
code = new string(Enumerable.Repeat(chars, 8).Select(s => s[random.Next(s.Length)]).ToArray());
test = await Context.PlanetInvites.Where(x => x.Code == code).FirstOrDefaultAsync();
}
invite.Code = code;
if (hours == 0)
{
invite.Hours = null;
}
await Context.PlanetInvites.AddAsync(invite);
await Context.SaveChangesAsync();
return(new TaskResult <PlanetInvite>(true, $"Successfully created invite", invite));
}
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 <PlanetInvite> > CreateInvite(ulong Planet_Id, string token, int hours)
{
AuthToken authToken = await Context.AuthTokens.FindAsync(token);
if (authToken == null)
{
return(new TaskResult <PlanetInvite>(false, "Failed to authorize user.", null));
}
ServerPlanet planet = await ServerPlanet.FindAsync(Planet_Id);
if (!(await planet.AuthorizedAsync(authToken, PlanetPermissions.Invite)))
{
return(new TaskResult <PlanetInvite>(false, "You are not authorized to do this.", null));
}
PlanetInvite invite = new PlanetInvite()
{
Id = IdManager.Generate(),
Planet_Id = Planet_Id,
Issuer_Id = authToken.User_Id,
Time = DateTime.UtcNow,
Hours = hours
};
Random random = new Random();
const string chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
string code = new string(Enumerable.Repeat(chars, 8).Select(s => s[random.Next(s.Length)]).ToArray());
PlanetInvite test = await Context.PlanetInvites.FirstOrDefaultAsync(x => x.Code == code);
while (test != null)
{
code = new string(Enumerable.Repeat(chars, 8).Select(s => s[random.Next(s.Length)]).ToArray());
test = await Context.PlanetInvites.Where(x => x.Code == code).FirstOrDefaultAsync();
}
invite.Code = code;
if (hours == 0)
{
invite.Hours = null;
}
await Context.PlanetInvites.AddAsync(invite);
await Context.SaveChangesAsync();
return(new TaskResult <PlanetInvite>(true, $"Successfully created invite", invite));
}
/// <summary>
/// Returns the planet name using an invite code as authorization
/// </summary>
public async Task <TaskResult <string> > GetPlanetName(string invite_code)
{
PlanetInvite invite = await Context.PlanetInvites.FirstOrDefaultAsync(x => x.Code == invite_code);
if (invite == null)
{
return(new TaskResult <string>(false, "Could not find invite.", null));
}
ServerPlanet planet = await Context.Planets.FindAsync(invite.Planet_Id);
if (planet == null)
{
return(new TaskResult <string>(false, $"Could not find planet {invite.Planet_Id}", null));
}
return(new TaskResult <string>(true, $"Success", planet.Name));
}
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));
}
public async Task <TaskResult> Join(string code, string token)
{
AuthToken authToken = await Context.AuthTokens.FindAsync(token);
if (authToken == null)
{
return(new TaskResult(false, $"Unable to authorize"));
}
ulong user_id = authToken.User_Id;
PlanetInvite invite = await Context.PlanetInvites.FirstOrDefaultAsync(x => x.Code == code);
if (invite == null)
{
return(new TaskResult(false, $"Invite code not found!"));
}
if (await Context.PlanetBans.AnyAsync(x => x.User_Id == user_id && x.Planet_Id == invite.Planet_Id))
{
return(new TaskResult(false, $"User is banned from this planet!"));
}
if (await Context.PlanetMembers.AnyAsync(x => x.User_Id == user_id && x.Planet_Id == invite.Planet_Id))
{
return(new TaskResult(false, $"User is already in this planet!"));
}
ServerPlanet planet = await ServerPlanet.FindAsync(invite.Planet_Id);
if (!planet.Public)
{
return(new TaskResult(false, $"Planet is set to private!"));
}
User user = await Context.Users.FindAsync(user_id);
await planet.AddMemberAsync(user, Context);
return(new TaskResult(true, $"Successfully joined planet."));
}
public async Task <LocalRedirectResult> 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 LocalRedirectResult("/"));
}
PlanetInvite invite = await Context.PlanetInvites.Where(x => x.Code == code).FirstOrDefaultAsync();
if (invite == null)
{
return(new LocalRedirectResult("/"));
}
PlanetMember mem = await Context.PlanetMembers.Where(x => x.User_Id == userid && x.Planet_Id == invite.Planet_Id).FirstOrDefaultAsync();
if (mem != null)
{
return(new LocalRedirectResult("/"));
}
PlanetMember member = new PlanetMember()
{
User_Id = userid,
Planet_Id = invite.Planet_Id,
};
await Context.PlanetMembers.AddAsync(member);
await Context.SaveChangesAsync();
return(new LocalRedirectResult("/"));
}
public async Task <TaskResult <ClientPlanetInvite> > GetInvite(string code)
{
PlanetInvite invite = await Context.PlanetInvites.Where(x => x.Code == code).FirstOrDefaultAsync();
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));
}
}
ClientPlanetInvite clientinvite = ClientPlanetInvite.FromBase(invite, Mapper);
Planet planet = await Context.Planets.Where(x => x.Id == invite.Planet_Id).FirstOrDefaultAsync();
clientinvite.PlanetName = planet.Name;
return(new TaskResult <ClientPlanetInvite>(true, $"Successfully got invite", clientinvite));
}
