partial void OnHandle(UserUpdated @event)
{
Entities.UserEntity entity = UserRepository.Load(@event.Rsn);;
entity = AutomapHelper.Automap(@event, entity);
UserRepository.Update(entity);
}
private async Task Save()
{
// Check empty fields
if (String.IsNullOrWhiteSpace(User.FirstName) || String.IsNullOrWhiteSpace(User.LastName) || String.IsNullOrWhiteSpace(User.Address) || String.IsNullOrWhiteSpace(User.Email) || String.IsNullOrWhiteSpace(User.Password) || String.IsNullOrWhiteSpace(User.Phone))
{
await _pageService.DisplayAlert("Error", "Please input all information", "OK");
return;
}
// Update User
var _user = new User
{
Id = User.Id,
FirstName = User.FirstName,
LastName = User.LastName,
Phone = User.Phone,
Email = User.Email,
Address = User.Address,
Password = User.Password,
Sex = User.Sex,
AvatarSource = User.AvatarSource,
Login = User.Login
};
// Update info
await _userBase.UpdateUser(_user);
UserUpdated?.Invoke(this, _user);
await _pageService.DisplayAlert("Update", "User information update successful!", "OK");
await _pageService.PopAsync();
}
/// <summary>
/// Constructs a new <see cref="BaseSocketClientAbstraction"/> around an existing <see cref="WebSocket.BaseSocketClient"/>.
/// </summary>
/// <param name="baseSocketClient">The value to use for <see cref="WebSocket.BaseSocketClient"/>.</param>
/// <exception cref="ArgumentNullException">Throws for <paramref name="baseSocketClient"/>.</exception>
protected BaseSocketClientAbstraction(BaseSocketClient baseSocketClient)
: base(baseSocketClient)
{
baseSocketClient.ChannelCreated += x => ChannelCreated?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.ChannelDestroyed += x => ChannelDestroyed?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.ChannelUpdated += (x, y) => ChannelUpdated?.InvokeAsync(x.Abstract(), y.Abstract()) ?? Task.CompletedTask;
baseSocketClient.CurrentUserUpdated += (x, y) => CurrentUserUpdated?.InvokeAsync(x.Abstract(), y.Abstract()) ?? Task.CompletedTask;
baseSocketClient.GuildAvailable += x => GuildAvailable?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.GuildMembersDownloaded += x => GuildMembersDownloaded?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.GuildMemberUpdated += (x, y) => GuildMemberUpdated?.InvokeAsync(x.Abstract(), y.Abstract()) ?? Task.CompletedTask;
baseSocketClient.GuildUnavailable += x => GuildUnavailable?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.GuildUpdated += (x, y) => GuildUpdated?.InvokeAsync(x.Abstract(), y.Abstract()) ?? Task.CompletedTask;
baseSocketClient.JoinedGuild += x => JoinedGuild?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.LeftGuild += x => LeftGuild?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.MessageReceived += x => MessageReceived?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.MessageUpdated += (x, y, z) => MessageUpdated?.InvokeAsync(x.Abstract(), y.Abstract(), z.Abstract()) ?? Task.CompletedTask;
baseSocketClient.MessageDeleted += (x, y) => MessageDeleted?.InvokeAsync(x.Abstract(), y.Abstract()) ?? Task.CompletedTask;
baseSocketClient.ReactionAdded += (x, y, z) => ReactionAdded?.InvokeAsync(x.Abstract(), y.Abstract(), z.Abstract()) ?? Task.CompletedTask;
baseSocketClient.ReactionRemoved += (x, y, z) => ReactionRemoved?.InvokeAsync(x.Abstract(), y.Abstract(), z.Abstract()) ?? Task.CompletedTask;
baseSocketClient.ReactionsCleared += (x, y) => ReactionsCleared?.InvokeAsync(x.Abstract(), y.Abstract()) ?? Task.CompletedTask;
baseSocketClient.RecipientAdded += x => RecipientAdded?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.RecipientRemoved += x => RecipientRemoved?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.RoleCreated += x => RoleCreated?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.RoleDeleted += x => RoleDeleted?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.RoleUpdated += (x, y) => RoleUpdated?.InvokeAsync(x.Abstract(), y.Abstract()) ?? Task.CompletedTask;
baseSocketClient.UserBanned += (x, y) => UserBanned?.InvokeAsync(x.Abstract(), y.Abstract()) ?? Task.CompletedTask;
baseSocketClient.UserIsTyping += (x, y) => UserIsTyping?.InvokeAsync(x.Abstract(), y.Abstract()) ?? Task.CompletedTask;
baseSocketClient.UserJoined += x => UserJoined?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.UserLeft += x => UserLeft?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.UserUnbanned += (x, y) => UserUnbanned?.InvokeAsync(x.Abstract(), y.Abstract()) ?? Task.CompletedTask;
baseSocketClient.UserUpdated += (x, y) => UserUpdated?.InvokeAsync(x.Abstract(), y.Abstract()) ?? Task.CompletedTask;
baseSocketClient.UserVoiceStateUpdated += (x, y, z) => UserVoiceStateUpdated?.InvokeAsync(x.Abstract(), y.Abstract(), z.Abstract()) ?? Task.CompletedTask;
baseSocketClient.VoiceServerUpdated += x => VoiceServerUpdated?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
}
private async Task DiscordShardedClientOnUserUpdated(SocketUser arg1, SocketUser arg2)
{
if (UserUpdated != null)
{
await UserUpdated.Invoke(this, arg1, arg2).ConfigureAwait(false);
}
}
public void LoadEvents()
{
Client.UserJoined += async(u) =>
{
Task.Run(() => UserJoin?.Invoke(new RuntimeUser(u)));
};
Client.UserLeft += async(u) =>
{
Task.Run(() => UserLeft?.Invoke(new RuntimeUser(u)));
};
Client.UserUpdated += async(u, unew) =>
{
RuntimeUser userOld = new RuntimeUser(u);
RuntimeUser userNew = new RuntimeUser(unew);
Task.Run(() => UserUpdated?.Invoke(userOld, userNew));
};
Client.MessageReceived += async(m) =>
{
RuntimeMessage newMessage = new RuntimeMessage(m);
if (MessageReceived != null)
{
await MessageReceived.Invoke(newMessage);
}
};
Client.JoinedGuild += async(g) =>
{
Task.Run(async() =>
{
RuntimeGuild guild = new RuntimeGuild(g);
await GuildJoin?.Invoke(guild);
});
};
Client.LeftGuild += async(g) =>
{
RuntimeGuild guild = new RuntimeGuild(g);
await GuildLeave?.Invoke(guild);
};
foreach (var shard in Client.Shards)
{
shard.Disconnected += async(ex) =>
{
await OnShardDisconnect?.Invoke(ex, shard.ShardId);
};
shard.Connected += async() =>
{
if (OnShardConnect != null)
{
await OnShardConnect.Invoke(shard.ShardId);
}
};
}
}
private void Apply(UserUpdated e)
{
UpdatedBy = e.UserId;
UpdatedDateTime = e.TimeStamp;
FirstName = e.FirstName;
LastName = e.LastName;
DisplayName = e.LastName;
Email = e.Email;
Avatar = e.Avatar;
}
public void SetCredits(int credits)
{
UserDetails.Credits = credits;
UserUpdated?.Invoke(this, new UserEventArgs
{
UserDetails = UserDetails,
IsFullRefresh = false,
IsInitialCheck = false
});
}
public async Task <bool> SetDetailsAsync(string token)
{
var initialCheck = !StartingDetailsChecked;
try
{
var request = new HttpRequestMessage
{
RequestUri = new Uri(_config["base_url"] + "/my/account"),
Method = HttpMethod.Get
};
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", token);
var httpResponse = await _http.SendAsync(request);
var userResponse = await httpResponse.Content.ReadFromJsonAsync <DetailsResponse>(_serializerOptions);
if (userResponse != null)
{
Username = userResponse.User.Username;
UserDetails = userResponse.User;
Token = token;
_http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
_localStorage.SetItem("Token", Token);
StartingDetailsChecked = true;
UserUpdated?.Invoke(this, new UserEventArgs
{
UserDetails = userResponse.User,
IsFullRefresh = true,
IsInitialCheck = initialCheck
});
return(true);
}
}
catch (Exception) { }
if (initialCheck)
{
UserUpdated?.Invoke(this, new UserEventArgs
{
UserDetails = null,
IsFullRefresh = true,
IsInitialCheck = initialCheck
});
}
StartingDetailsChecked = true;
return(false);
}
void When(UserUpdated e)
{
FirstName = e.FirstName;
MiddleName = e.MiddleName;
LastName = e.LastName;
Email = e.Email;
Phone = e.Phone;
Mobile = e.Mobile;
DateUpdated = e.UpdatedAt;
}
public Task <RequestToServerResult> UpdateUser(string login, UserInfoWithPrivateInfo userInfoWithPrivateInfo)
{
return(Task <RequestToServerResult> .Factory.StartNew(() =>
{
new UpdateUserPacket(_streamWriter.BaseStream, login, userInfoWithPrivateInfo).Send();
lock (_users)
{
_users[Login] = userInfoWithPrivateInfo;
}
_context.Post(p => UserUpdated?.Invoke(this, EventArgs.Empty), null);
return RequestToServerResult.OK;
}));
}
public async Task <Result> GetUser()
{
if (!await CheckIfTokenIsValid())
{
return(new Result());
}
var result = await _clientService.SendRequest <User>("/connect/userinfo", RestType.Get,
token : Token.AccessToken, endpoint : Endpoint.User);
User = result.Data;
Device.BeginInvokeOnMainThread(() => UserUpdated?.Invoke(this, User));
return(result);
}
public void Logout()
{
UserDetails = null;
Username = null;
Token = null;
_localStorage.RemoveItem("Token");
UserUpdated?.Invoke(this, new UserEventArgs
{
UserDetails = null,
IsFullRefresh = true,
IsInitialCheck = false
});
}
private static void HandleUserUpdated(PacketHeader header, Connection connection, string serializedUser)
{
lock (dbSync)
{
UserInfo user = new UserInfo();
user.DeserializeFromString(serializedUser);
if (database != null)
{
database.IdToUser[user.UserGuid] = user;
}
}
UserUpdated?.Invoke();
}
public async Task RefreshData()
{
var userResponse = await _http.GetFromJsonAsync <DetailsResponse>("/my/account", _serializerOptions);
Username = userResponse.User.Username;
UserDetails = userResponse.User;
UserUpdated?.Invoke(this, new UserEventArgs
{
UserDetails = userResponse.User,
IsFullRefresh = true,
IsInitialCheck = false
});
}
public async Task PublishUserUpdated(Guid id, string login, string firstName, string lastName)
{
var options = new PublishOptions();
var @event = new UserUpdated
{
Id = id,
Login = login,
FirstName = firstName,
LastName = lastName
};
options.SetMessageId(id.ToString());
await _endpoint.Publish(@event, options);
}
private void btnDelete_Click(object sender, EventArgs e)
{
bool delete = _userManager.Delete(selecteduser);
if (delete == true)
{
MessageBox.Show(this, "Kişi silindi", "Bilgi");
EventArgs ev = new EventArgs();
UserUpdated.Invoke(this, ev);
this.Close();
}
else
{
MessageBox.Show(this, "İşlem başarısız", "Bilgi");
}
}
private async Task <bool> Update(HttpContent content)
{
var response = await HttpClient.PostAsync(string.Format(UpdateUri, AuthService.User.Uuid), content);
var json = await response.Content.ReadAsStringAsync();
Debug.WriteLine(json);
var data = JsonConvert.DeserializeObject <ResponseDto <object> >(json);
if (data.Success)
{
UserUpdated?.Invoke(this, EventArgs.Empty);
}
return(data.Success);
}
private async Task GetAddress()
{
if (await _pageService.DisplayAlert("Geolocation!", "You want change your address?", "Yes", "No"))
{
var locator = CrossGeolocator.Current;
locator.DesiredAccuracy = 50;
// Get current location
var position = await locator.GetPositionAsync(timeout : TimeSpan.FromMilliseconds(1000));
// Get address
var address = new Xamarin.Forms.Maps.Position(position.Latitude, position.Longitude);
string tmp = "";
// WARNING RETURNS EMPTY STR
var possibleAddresses = await geoCoder.GetAddressesForPositionAsync(address);
foreach (var addr in possibleAddresses)
{
tmp += addr + "\n";
}
tmp = "Some address";
User.Address = tmp;
var _user = new User
{
Id = User.Id,
FirstName = User.FirstName,
LastName = User.LastName,
Phone = User.Phone,
Email = User.Email,
Address = User.Address,
Password = User.Password,
Sex = User.Sex,
AvatarSource = User.AvatarSource,
Login = User.Login
};
await _userBase.UpdateUser(_user);
UserUpdated?.Invoke(this, _user);
}
}
public void Handle(UserUpdated @event)
{
using (var context = new ProjectionContext(ConnectionString.Get()))
{
var entity = context.Users.Find(@event.AggregateId);
if (entity == null)
{
throw new EntityNotFoundException(@event.AggregateId, "Utilisateurs");
}
entity.Lastname = @event.Lastname;
entity.Firstname = @event.Firstname;
entity.IsEnabled = @event.IsEnabled;
entity.Email = @event.Email;
entity.Signature = @event.Signature;
context.SaveChanges();
}
}
protected override User.Domain.UserAggregate.Model.User Action()
{
var users = _unitOfWork.GetUserRepository();
var user = users.GetById(_user.Id);
user.UpdateName(_user.UserName.Name);
user.UpdatePicture(_user.UserPicture.ImageUrl);
users.AddOrUpdate(user);
_unitOfWork.AddEvent(UserUpdated.Create(user.Id,
user.UserName.Name,
user.UserEmail.Email,
user.UserPicture.ImageUrl));
return(user);
}
public ClientSubscriptionModule(Client client)
{
RPC = new ClientCalls(client);
RequestHandler requestHandler;
Attach(requestHandler = new RequestHandler());
requestHandler.Register(nameof(IServerCalls.UserStatusUpdated), (RequestPacket request) => {
var userUpdateArgs = new UserUpdatedEventArgs {
Client = request.Context.Client,
User = (User)request["user"],
UserStatus = (string)request["userStatus"]
};
UserUpdated?.Invoke(this, userUpdateArgs);
return(Task.FromResult(ProcessResult.Processed));
});
requestHandler.Register(nameof(IServerCalls.UserSubscriptionUpdated), async(RequestPacket request) => {
var subscription = UserSubscription.GetFromPacket(request);
var usubArgs = new UserSubscriptionUpdatedEventArgs {
Client = request.Context.Client,
Subscription = subscription
};
UserSubscriptionUpdated?.Invoke(this, usubArgs);
if (subscription.UpdateType == UpdateType.Add)
{
var userUpdateArgs = new UserUpdatedEventArgs {
Client = request.Context.Client,
User = (User)request["user"],
UserStatus = (string)request["userStatus"]
};
UserUpdated?.Invoke(this, userUpdateArgs);
}
return(ProcessResult.Processed);
});
}
public void LoadEvents()
{
Client.UserJoined += async(u) =>
{
await MeruUtils.TryAsync(async() =>
{
Task.Run(() => UserJoin?.Invoke(new RuntimeUser(u)));
});
};
Client.UserLeft += async(u) =>
{
await MeruUtils.TryAsync(async() =>
{
Task.Run(() => UserLeft?.Invoke(new RuntimeUser(u)));
});
};
Client.UserUpdated += async(u, unew) =>
{
RuntimeUser userOld = new RuntimeUser(u);
RuntimeUser userNew = new RuntimeUser(unew);
Task.Run(() => UserUpdated?.Invoke(userOld, userNew));
};
Client.MessageReceived += async(m) =>
{
Task.Run(async() =>
{
await MeruUtils.TryAsync(async() =>
{
RuntimeMessage newMessage = new RuntimeMessage(m);
await MessageReceived?.Invoke(newMessage);
});
});
};
}
public void btnSave_Click(object sender, EventArgs e)
{
string oldPass = txt_oldpass.Text.ToString();
string newPass = txt_newpass.Password.ToString();
string newPassR = txt_newpass2.Password.ToString();
if (oldPass != null && newPass != "" && newPassR != "")
{
users change = _userManager.ChangePass(oldPass, newPass, newPassR, _user);
if (change != null)
{
MessageBox.Show(this, "Şifreniz değiştirildi", "Bilgi");
_user = change;
EventArgs ev = new EventArgs();
UserUpdated.Invoke(this, ev);
this.Close();
}
else
{
MessageBox.Show(this, "Hatalı işlem", "Bilgi");
txt_oldpass.Clear();
txt_newpass.Clear();
txt_newpass2.Clear();
}
}
else
{
MessageBox.Show(this, "Alanlar boş bırakılamaz", "Bilgi");
txt_oldpass.Clear();
txt_newpass.Clear();
txt_newpass2.Clear();
this.Show();
}
}
public void btnSave_Click(object sender, EventArgs e)
{
string nametb = txt_username.Text.ToString();
string lastnametb = txt_lastname.Text.ToString();
if (combo_depts.SelectedIndex != -1 && combo_rates.SelectedIndex != -1 && combo_statu.SelectedIndex != -1 && nametb != "" && lastnametb != "")
{
string selectedDept = combo_depts.Items[combo_depts.SelectedIndex].ToString();
decimal deptID = _deptManager.DepartmetnID(selectedDept);
string selectedRate = combo_rates.Items[combo_rates.SelectedIndex].ToString();
int rate = (selectedRate == "Primer") ? 1 : 2;
string selectedStatu = combo_statu.Items[combo_statu.SelectedIndex].ToString();
bool statu = (selectedStatu == "Uygun") ? true : false;
bool add = _userManager.Add(nametb, lastnametb, deptID, rate, statu);
if (add == true)
{
MessageBox.Show(this, "Yeni kişi eklendi", "Bilgi");
EventArgs ev = new EventArgs();
UserUpdated.Invoke(this, ev);
this.Close();
}
else
{
MessageBox.Show(this, "Kayıt başarısız", "Bilgi");
}
}
else
{
MessageBox.Show(this, "Alanlar boş bırakılamaz", "Bilgi");
this.Show();
}
}
protected virtual void OnUserUpdated(ModmailConversationsEventArgs e)
{
UserUpdated?.Invoke(this, e);
}
/// <summary>
/// Called when [user updated].
/// </summary>
/// <param name="user">The user.</param>
private void OnUserUpdated(User user)
{
UserUpdated?.Invoke(this, new GenericEventArgs <User> {
Argument = user
});
}
private async Task ChangeAvatar()
{
// Choose new avatar
var choose = await _pageService.DisplayActionSheet("Change Avatar", "Cancel", null, "Camera", "Gallery");
if (choose == "Camera")
{
await CrossMedia.Current.Initialize();
if (!CrossMedia.Current.IsCameraAvailable || !CrossMedia.Current.IsTakePhotoSupported)
{
await _pageService.DisplayAlert("No camera", "No camera available", "OK");
return;
}
// Take a photo
var file = await CrossMedia.Current.TakePhotoAsync(new StoreCameraMediaOptions
{
SaveToAlbum = true,
Name = "test.jpg"
});
if (file == null)
{
return;
}
// Change avatar
User.AvatarSource = file.Path;
var _user = new User
{
Id = User.Id,
FirstName = User.FirstName,
LastName = User.LastName,
Phone = User.Phone,
Email = User.Email,
Address = User.Address,
Password = User.Password,
Sex = User.Sex,
AvatarSource = User.AvatarSource,
Login = User.Login
};
// Update info
await _userBase.UpdateUser(_user);
UserUpdated?.Invoke(this, _user);
}
else if (choose == "Gallery")
{
if (!CrossMedia.Current.IsPickPhotoSupported)
{
return;
}
// Choose photo from gallery
var file = await CrossMedia.Current.PickPhotoAsync();
if (file == null)
{
return;
}
// Change photo
User.AvatarSource = file.Path;
var _user = new User
{
Id = User.Id,
FirstName = User.FirstName,
LastName = User.LastName,
Phone = User.Phone,
Email = User.Email,
Address = User.Address,
Password = User.Password,
Sex = User.Sex,
AvatarSource = User.AvatarSource,
Login = User.Login
};
// Update info
await _userBase.UpdateUser(_user);
UserUpdated?.Invoke(this, _user);
}
}
private async Task InvokeUserUpdated(IUser before, IUser after)
{
await UserUpdated.InvokeAsync(this, new UserUpdatedEventArgs(before, after)).ConfigureAwait(false);
}
void OnEvent(string eventname, int seq, JsonNode data)
{
sequence = seq;
switch (eventname)
{
case "READY":
gatewayversion = data.SelectValue <int>("v");
sessionid = data.SelectValue <string>("session_id");
OnConnected();
break;
case "RESUMED":
OnConnected();
break;
case "INVALID_SESSION":
Disconnect(1021, "Authentication failure", /*data.SelectValue<bool>("d")*/ false);
break;
case "CHANNEL_CREATE":
ChannelCreated?.Invoke(JSON.Serializer.Read <Channel>(data));
break;
case "CHANNEL_UPDATE":
ChannelUpdated?.Invoke(JSON.Serializer.Read <Channel>(data));
break;
case "CHANNEL_DELETE":
ChannelDeleted?.Invoke(JSON.Serializer.Read <Channel>(data));
break;
case "CHANNEL_PINS_UPDATED":
ChannelPinUpdated?.Invoke(data.SelectValue <string>("channel_id"));
break;
case "MESSAGE_CREATE":
MessageCreated?.Invoke(JSON.Serializer.Read <Message>(data));
break;
case "MESSAGE_UPDATE":
MessageUpdated?.Invoke(JSON.Serializer.Read <Message>(data));
break;
case "MESSAGE_DELETE":
MessageDeleted?.Invoke(data.SelectValue <string>("channel_id"), data.SelectValue <string>("id"));
break;
case "MESSAGE_DELETE_BULK":
MessagesDeleted?.Invoke(data.SelectValue <string>("channel_id"), data.SelectValue <string[]>("ids"));
break;
case "GUILD_CREATE":
GuildCreated?.Invoke(JSON.Serializer.Read <Guild>(data));
break;
case "GUILD_UPDATE":
GuildUpdated?.Invoke(JSON.Serializer.Read <Guild>(data));
break;
case "GUILD_DELETE":
GuildDeleted?.Invoke(JSON.Serializer.Read <UnavailableGuild>(data));
break;
case "GUILD_BAN_ADD":
UserBanned?.Invoke(JSON.Serializer.Read <GuildUser>(data));
break;
case "GUILD_BAN_REMOVED":
UserUnbanned?.Invoke(JSON.Serializer.Read <GuildUser>(data));
break;
case "GUILD_EMOJIS_UPDATE":
EmojisUpdated?.Invoke(data.SelectValue <string>("guild_id"), JSON.Serializer.Read <Emoji[]>(data["emojis"]));
break;
case "GUILD_INTEGRATIONS_UPDATE":
GuildIntegrationsUpdated?.Invoke(data.SelectValue <string>("guild_id"));
break;
case "GUILD_MEMBER_ADD":
GuildMemberAdded?.Invoke(data.SelectValue <string>("guild_id"), JSON.Serializer.Read <GuildMember>(data));
break;
case "GUILD_MEMBER_REMOVE":
GuildMemberRemoved?.Invoke(data.SelectValue <string>("guild_id"), JSON.Serializer.Read <User>(data));
break;
case "GUILD_MEMBER_UPDATE":
GuildMemberUpdated?.Invoke(data.SelectValue <string>("guild_id"), JSON.Serializer.Read <Role[]>(data["roles"]), JSON.Serializer.Read <User>(data["user"]), data.SelectValue <string>("nick"));
break;
case "GUILD_MEMBERS_CHUNK":
GuildMembersChunk?.Invoke(data.SelectValue <string>("guild_id"), JSON.Serializer.Read <GuildMember[]>(data["members"]));
break;
case "GUILD_ROLE_CREATE":
GuildRoleCreated?.Invoke(data.SelectValue <string>("guild_id"), JSON.Serializer.Read <Role>(data["role"]));
break;
case "GUILD_ROLE_UPDATE":
GuildRoleUpdated?.Invoke(data.SelectValue <string>("guild_id"), JSON.Serializer.Read <Role>(data["role"]));
break;
case "GUILD_ROLE_DELETE":
GuildRoleDeleted?.Invoke(data.SelectValue <string>("guild_id"), data.SelectValue <string>("role_id"));
break;
case "MESSAGE_REACTION_ADD":
MessageReactionAdded?.Invoke(data.SelectValue <string>("user_id"), data.SelectValue <string>("channel_id"), data.SelectValue <string>("message_id"), JSON.Serializer.Read <Emoji>(data["emoji"]));
break;
case "MESSAGE_REACTION_REMOVE":
MessageReactionRemoved?.Invoke(data.SelectValue <string>("user_id"), data.SelectValue <string>("channel_id"), data.SelectValue <string>("message_id"), JSON.Serializer.Read <Emoji>(data["emoji"]));
break;
case "MESSAGE_REACTION_REMOVE_ALL":
MessageReactionRemovedAll?.Invoke(data.SelectValue <string>("channel_id"), data.SelectValue <string>("message_id"));
break;
case "PRESENCE_UPDATE":
PresenceUpdated?.Invoke(JSON.Serializer.Read <PresenceUpdate>(data));
break;
case "TYPING_START":
TypingStarted?.Invoke(data.SelectValue <string>("guild_id"), data.SelectValue <string>("user_id"), data.SelectValue <int>("timestamp").ToDateTime());
break;
case "USER_UPDATE":
UserUpdated?.Invoke(JSON.Serializer.Read <User>(data));
break;
case "VOICE_STATE_UPDATE":
VoiceStateUpdated?.Invoke(JSON.Serializer.Read <VoiceState>(data));
break;
case "VOICE_SERVER_UPDATE":
VoiceServerUpdated?.Invoke(data.SelectValue <string>("token"), data.SelectValue <string>("guild_id"), data.SelectValue <string>("endpoint"));
break;
case "WEBHOOKS_UPDATE":
WebhooksUpdated?.Invoke(data.SelectValue <string>("guild_id"), data.SelectValue <string>("channel_id"));
break;
default:
Logger.Warning(this, $"'{eventname}' event not handled", data.ToString());
break;
}
}
public async Task <IActionResult> UpdateAsync(UserViewModel <TUser> userModel)
{
var userSpecification = new UserSpecification()
{
ID = userModel.User.ID,
Email = userModel.User.Email
};
var savedUser = await _userRepository.ReadAsync(userSpecification);
var roles = await _userRoleRepository.ListAsync();
foreach (var userRole in userModel.User.Roles)
{
var role = roles.Where(r => r.ID == userRole.ID).FirstOrDefault();
userRole.Name = role.Name;
userRole.DisplayTitle = role.DisplayTitle;
}
var email = userModel.User.Email;
if (email.HasValue())
{
if (!_emailValidatorService.IsValidEmail(email))
{
ModelState.AddModelError("InvalidEmail", _localizer[UserErrorMessages.InvalidEmail]);
}
if (email != savedUser.Email)
{
var duplicateUser = await _userRepository.ReadAsync(userSpecification);
if (duplicateUser != null)
{
ModelState.AddModelError("DuplicateUser", _localizer[UserErrorMessages.DuplicateUser]);
}
}
}
if (userModel.HasIdentity(UserID) && userModel.Password.HasValue() ||
userModel.HasIdentity(UserID) && userModel.ConfirmationPassword.HasValue())
{
if (userModel.Password.IsNullOrWhiteSpace() || userModel.ConfirmationPassword.IsNullOrWhiteSpace())
{
ModelState.AddModelError("Invalid", _localizer[UserErrorMessages.TwoPasswordsRequired]);
return(PartialView("_Editor", userModel));
}
if (userModel.Password != userModel.ConfirmationPassword)
{
ModelState.AddModelError("Invalid", _localizer[UserErrorMessages.PasswordsDoNotMatch]);
return(PartialView("_Editor", userModel));
}
var passwordValidationErrors = _passwordValidatorService.ValidatePassword(userModel.Password);
if (passwordValidationErrors.Count > 0)
{
ModelState.AddModelError(
key: "PasswordValidationErrors",
errorMessage: _localizer[_passwordValidatorService.GetPasswordValidationErrorMessage()]
);
return(PartialView("_Editor", userModel));
}
var passHash = _passwordHasherService.HashPassword(userModel.User, userModel.Password);
userModel.User.PassHash = passHash;
}
else
{
userModel.User.PassHash = savedUser.PassHash;
}
if (!ModelState.IsValid)
{
return(PartialView("_Editor", userModel));
}
var update = await _userRepository.UpdateAsync(userModel.User, UserID);
if (update <= 0)
{
return(BadRequest());
}
var updatedUser = await _userRepository.ReadAsync(userSpecification);
var userDTO = new UserDTO(updatedUser);
var userUpdatedEvent = new UserUpdated(userDTO);
await _mediator.Publish(userUpdatedEvent);
var result = new UserViewModel <TUser>()
{
ID = userModel.ID,
User = updatedUser
};
return(PartialView("_Editor", result));
}
