public Response <RegistrationResponse> AdminDelete([FromBody] RoleUpdate login)
{
var response = new RegistrationResponse()
{
Successful = false
};
var service = new Tete.Api.Services.Authentication.LoginService(this.context);
var token = HttpContext.Request.Cookies[Constants.SessionTokenName];
var user = service.GetUserVMFromToken(token);
if (user != null)
{
try
{
service.DeleteAccount(login.UserId, user);
response.Successful = true;
}
catch { }
}
if (!response.Successful)
{
response.Messages.Add("Failed to delete account.");
}
return(new Response <RegistrationResponse>(response));
}
public Response <string> RemoveRole([FromBody] RoleUpdate roleUpdate)
{
var service = new Services.Users.UserService(Context, CurrentAdmin);
var success = service.RemoveRole(roleUpdate.UserId, roleUpdate.Name);
return(new Response <string>(success ? "Successful" : "Failed", !success));
}
public ActionResult Edit(RoleUpdate model)
{
IdentityResult result;
if (ModelState.IsValid)
{
foreach (var userId in model.IdsToAdd ?? new string[] { })
{
result = _userManager.AddToRole(userId, model.RoleName);
if (!result.Succeeded)
{
return(View("Error", result.Errors));
}
}
foreach (var userId in model.IdsToDelete ?? new string[] { })
{
result = _userManager.RemoveFromRole(userId, model.RoleName);
if (!result.Succeeded)
{
return(View("Error", result.Errors));
}
}
return(RedirectToAction("Index"));
}
return(View("Error", new string[] { "aranılan rol yok." }));
}
public void UpdateFromAPI(long id, RoleUpdate roleUpdate)
{
RoleRepository roleRepository = new RoleRepository();
roleRepository.Name = roleUpdate.Name;
this.roleStoreRepository.Update(id, roleRepository);
}
public async Task <dynamic> Update([FromBody] RoleUpdate item)
{
if (item == null)
{
return new { JsonString = "Error" }
}
;
var currentUser = JwtIdentity.UserInfo(Thread.CurrentPrincipal.Identity);
//item.SubmiterUserId = currentUser.Id;
var result = await _sqlData.Role.Update(item);
return(new { Result = JsonConvert.DeserializeObject(result) });
}
public async Task <IActionResult> SetUser(RoleUpdate model)
{
IdentityResult result;
if (ModelState.IsValid)
{
foreach (string userId in model.AddIds ?? new string[] { })
{
IdentityUser user = await _userManager.FindByIdAsync(userId);
if (user != null)
{
result = await _userManager.AddToRoleAsync(user, model.RoleName);
if (!result.Succeeded)
{
Errors(result);
}
}
}
foreach (string userId in model.DeleteIds ?? new string[] { })
{
IdentityUser user = await _userManager.FindByIdAsync(userId);
if (user != null)
{
result = await _userManager.RemoveFromRoleAsync(user, model.RoleName);
if (!result.Succeeded)
{
Errors(result);
}
}
}
}
if (ModelState.IsValid)
{
return(RedirectToAction("Index"));
}
else
{
return(await SetUser(model.RoleId));
}
}
public async void Update(string id, RoleUpdate roleIn) => await _roles.ReplaceOneAsync(role => role.Id == id, Role.FromUpdate(id, roleIn));
//TODO: Typing Start
//TODO: Integrations
//TODO: User Updates
//TODO: Voice Chat
private void GatewayMessageHandler(string eventName, string payload)
{
_Logger?.Debug($"{eventName} - {payload}");
var eventValue = (Events)Enum.Parse(typeof(Events), eventName);
var eventPayload = JObject.Parse(payload);
switch (eventValue)
{
case Events.READY:
{
var guilds = eventPayload["guilds"] as JArray;
foreach (var guild in guilds)
{
var g = new Guild {
Id = guild["id"].ToString(), Unavailable = guild["unavailable"].ToObject <bool>()
};
Guilds.Add(g.Id, g);
}
break;
}
case Events.GUILD_CREATE:
{
Guild g = null;
if (Guilds.ContainsKey(eventPayload["id"].ToString()))
{
g = Guilds[eventPayload["id"].ToString()];
}
else
{
g = new Guild()
{
Id = eventPayload["id"].ToString()
};
Guilds.Add(g.Id, g);
}
JsonConvert.PopulateObject(payload, g);
foreach (var channel in g.Channels)
{
if (!Channels.ContainsKey(channel.Key))
{
Channels.Add(channel.Key, channel.Value);
}
channel.Value.Guild_Id = g.Id;
channel.Value.Guild = g;
}
foreach (var member in g.Members)
{
if (!Users.ContainsKey(member.Key))
{
Users.Add(member.Key, member.Value.User);
}
else if (member.Value.User != Users[member.Key])
{
member.Value.User = Users[member.Key];
}
member.Value.Guild = g;
}
foreach (var presence in g.Presences.Values)
{
presence.User = Users[presence.User.Id];
}
g.UpdateAllUserPermissions();
GuildCreated?.Invoke(g);
break;
}
case Events.GUILD_UPDATE:
{
var g = Guilds[eventPayload["id"].ToString()];
// TODO: Double check that this is the correct behavior.
JsonConvert.PopulateObject(payload, g);
GuildUpdated?.Invoke(g);
break;
}
case Events.GUILD_DELETE:
{
var g = Guilds[eventPayload["id"].ToString()];
Guilds.Remove(eventPayload["id"].ToString());
GuildDeleted?.Invoke(g);
break;
}
case Events.CHANNEL_CREATE:
{
var c = eventPayload.ToObject <GuildChannel>();
var g = Guilds[c.Guild_Id];
c.Guild = g;
g.Channels.Add(c.Id, c);
Channels.Add(c.Id, c);
ChannelCreate?.Invoke(g, c);
break;
}
case Events.CHANNEL_UPDATE:
{
var g = Guilds[eventPayload["guild_id"].ToString()];
var c = g.Channels[eventPayload["id"].ToString()];
JsonConvert.PopulateObject(payload, c);
ChannelUpdate?.Invoke(g, c);
break;
}
case Events.CHANNEL_DELETE:
{
var g = Guilds[eventPayload["guild_id"].ToString()];
var c = g.Channels[eventPayload["id"].ToString()];
g.Channels.Remove(c.Id);
Channels.Remove(c.Id);
ChannelDelete?.Invoke(g, c);
break;
}
case Events.GUILD_BAN_ADD:
{
// TODO: User knows about bans
var g = Guilds[eventPayload["guild_id"].ToString()];
var m = g.Members[eventPayload["id"].ToString()];
Users[m.User.Id].Guilds.Remove(g);
g.Members.Remove(m.User.Id);
BanAdd?.Invoke(g, m.User);
break;
}
case Events.GUILD_BAN_REMOVE:
{
var g = Guilds[eventPayload["guild_id"].ToString()];
BanRemove?.Invoke(g, eventPayload.ToObject <DiscordUser>());
break;
}
case Events.GUILD_EMOJIS_UPDATE:
{
var g = Guilds[eventPayload["guild_id"].ToString()];
g.Emojis.Clear();
JsonConvert.PopulateObject(payload, g);
EmojiUpdate?.Invoke(g, eventPayload["emojis"].ToObject <List <Guild.Emoji> >());
break;
}
case Events.GUILD_MEMBER_ADD:
{
var g = Guilds[eventPayload["guild_id"].ToString()];
var m = eventPayload.ToObject <GuildMember>();
if (!Users.ContainsKey(m.User.Id))
{
Users.Add(m.User.Id, m.User);
}
else
{
m.User = Users[m.User.Id];
}
g.Members.Add(m.User.Id, m);
m.User.Guilds.Add(g);
m.Guild = g;
g.UpdateUserPermission(m);
MemberAdd?.Invoke(g, m);
break;
}
case Events.GUILD_MEMBER_REMOVE:
{
var g = Guilds[eventPayload["guild_id"].ToString()];
var m = g.Members[eventPayload["user"]["id"].ToString()];
g.Members.Remove(m.User.Id);
m.User.Guilds.Remove(g);
MemberRemove?.Invoke(g, m);
break;
}
case Events.GUILD_MEMBER_UPDATE:
{
var g = Guilds[eventPayload["guild_id"].ToString()];
var m = g.Members[eventPayload["user"]["id"].ToString()];
JsonConvert.PopulateObject(payload, m);
g.UpdateUserPermission(m);
MemberUpdate?.Invoke(g, m);
break;
}
case Events.GUILD_MEMBERS_CHUNK:
{
var g = Guilds[eventPayload["guild_id"].ToString()];
var members = eventPayload["members"].ToObject <List <GuildMember> >();
foreach (var member in members)
{
if (Users.ContainsKey(member.User.Id))
{
member.User = Users[member.User.Id];
}
else
{
Users.Add(member.User.Id, member.User);
}
g.Members.Remove(member.User.Id);
g.Members.Add(member.User.Id, member);
}
MemberChunkUpdate?.Invoke(g, members);
break;
}
case Events.GUILD_ROLE_CREATE:
{
var g = Guilds[eventPayload["guild_id"].ToString()];
var r = eventPayload["role"].ToObject <Guild.Role>();
g.Roles.Add(r.Id, r);
RoleCreate?.Invoke(g, r);
break;
}
case Events.GUILD_ROLE_UPDATE:
{
var g = Guilds[eventPayload["guild_id"].ToString()];
var r = g.Roles[eventPayload["role"]["id"].ToString()];
JsonConvert.PopulateObject(eventPayload["role"].ToString(), r);
RoleUpdate?.Invoke(g, r);
break;
}
case Events.GUILD_ROLE_DELETE:
{
var g = Guilds[eventPayload["guild_id"].ToString()];
var r = g.Roles[eventPayload["role_id"].ToString()];
g.Roles.Remove(r.Id);
RoleDelete?.Invoke(g, r);
break;
}
case Events.MESSAGE_CREATE:
{
var message = eventPayload.ToObject <Message>();
var c = Channels[message.Channel_Id];
message.Channel = c;
if (string.IsNullOrEmpty(message.Webhook_Id))
{
if (Users.ContainsKey(message.Author.Id))
{
message.Author = Users[message.Author.Id];
}
}
MessageCreate?.Invoke(c, message);
break;
}
case Events.MESSAGE_UPDATE:
{
var message = eventPayload.ToObject <Message>();
var c = Channels[message.Channel_Id];
MessageUpdate?.Invoke(c, message);
break;
}
case Events.MESSAGE_DELETE:
{
var message = eventPayload.ToObject <Message>();
var c = Channels[message.Channel_Id];
MessageDelete?.Invoke(c, message);
break;
}
case Events.MESSAGE_DELETE_BULK:
{
var messages = eventPayload.ToObject <List <Message> >();
var c = Channels[eventPayload["channel_id"].ToString()];
MessagesBulkDelete?.Invoke(c, messages);
break;
}
case Events.PRESENCE_UPDATE:
{
var presense = eventPayload.ToObject <Guild.Presence>();
var g = Guilds[eventPayload["guild_id"].ToString()];
if (g.Presences.ContainsKey(presense.User.Id))
{
var p = g.Presences[presense.User.Id];
p.Game = presense.Game;
p.Status = presense.Status;
presense = p;
}
else
{
presense.User = Users[presense.User.Id];
g.Presences.Add(presense.User.Id, presense);
}
PresenceUpdate?.Invoke(g, presense);
break;
}
}
}
public async Task <IActionResult> Update([FromHeader] string authToken, string id, RoleUpdate roleIn)
{
if (!await _authenticationService.CheckAccess(authToken, "roleMgr"))
{
return(Unauthorized());
}
var role = await _roleService.Get(id);
if (role == null)
{
return(NotFound());
}
_roleService.Update(id, roleIn);
await _logService.Create(new Log(
null,
AuthenticationHelpers.GetUserIdFromToken(authToken),
DateTime.UtcNow,
"Document modified.",
"auth.roles",
id,
JsonSerializer.Serialize(Role.FromUpdate(id, roleIn))
));
return(Ok());
}
public async Task <IActionResult> Put(RoleUpdate command)
{
var result = await _mediator.Send(command);
return(Ok(result));
}
