public async Task <ActionResult <bool> > UpdateInformation([FromForm] UpdateInformationModel request)
{
string folder = Path.Combine(_hostingEnvironment.WebRootPath,
"Avatars");
return(Ok(await UserService.UpdateInformationUser(await GetUserId(),
request,
folder)));
}
public ActionResult UpdateMyInformation(UpdateInformationModel model)
{
try
{
_serviceUser.UpdateMyInformation(model);
return(Ok());
}
catch (ValidationException exception)
{
var validationResult = exception.ValidationResult;
foreach (var t in validationResult)
{
ModelState.AddModelError(t.PropertyName, t.ErrorMessage);
}
return(BadRequest(ModelState));
}
catch (Exception exception)
{
ModelState.AddModelError("ErrorMessage", exception.Message);
return(BadRequest(ModelState));
}
}
public void UpdateMyInformation(UpdateInformationModel model)
{
IValidator validator = new FluentValidator <UpdateInformationModel, UpdateInformationModelValidationRules>(model);
var validationResults = validator.Validate();
if (!validator.IsValid)
{
throw new ValidationException(Messages.DangerInvalidEntitiy)
{
ValidationResult = validationResults
};
}
var language = _repositoryLanguage.Get(e => e.Id == model.Language.Id);
if (language == null)
{
throw new ParentNotFoundException();
}
var identity = (CustomIdentity)Thread.CurrentPrincipal?.Identity;
var user = _repositoryUser
.Join(x => x.Creator)
.Join(x => x.Language)
.Join(x => x.Person)
.FirstOrDefault(e => e.Id == identity.UserId);
if (user == null)
{
throw new NotFoundException();
}
var person = user.Person;
if (model.Username != user.Username)
{
if (_repositoryUser.Get().Any(p => p.Username == model.Username))
{
throw new DuplicateException(string.Format(Messages.DangerFieldDuplicated, Dictionary.Username));
}
}
if (model.Email != user.Email)
{
if (_repositoryUser.Get().Any(p => p.Email == model.Email))
{
throw new DuplicateException(string.Format(Messages.DangerFieldDuplicated, Dictionary.Email));
}
}
var personHistory = person.CreateMapped <Person, PersonHistory>();
personHistory.Id = GuidHelper.NewGuid();
personHistory.ReferenceId = user.Id;
personHistory.CreatorId = user.Creator.Id;
_repositoryPersonHistory.Add(personHistory, true);
person.FirstName = model.FirstName;
person.LastName = model.LastName;
person.LastModificationTime = DateTime.Now;
person.LastModifierId = user.Id;
var versionPerson = person.Version;
person.Version = versionPerson + 1;
_repositoryPerson.Update(person, true);
var userHistory = user.CreateMapped <User, UserHistory>();
userHistory.Id = GuidHelper.NewGuid();
userHistory.ReferenceId = user.Id;
userHistory.CreatorId = user.Creator.Id;
userHistory.PersonId = user.Person.Id;
userHistory.LanguageId = user.Language.Id;
_repositoryUserHistory.Add(userHistory, true);
user.Username = model.Username;
user.Email = model.Email;
user.LastModificationTime = DateTime.Now;
user.LastModifier = user;
user.Language = language;
var versionUser = user.Version;
user.Version = versionUser + 1;
var affectedUser = _repositoryUser.Update(user, true);
if (!_serviceMain.ApplicationSettings.SendMailAfterUpdateUserInformation)
{
return;
}
var emailUser = new EmailUser
{
Username = affectedUser.Username,
Password = string.Empty,
CreationTime = affectedUser.CreationTime,
Email = affectedUser.Email,
FirstName = affectedUser.Person.FirstName,
LastName = affectedUser.Person.LastName
};
var emailSender = new EmailSender(_serviceMain, _smtp);
emailSender.SendEmailToUser(emailUser, EmailTypeOption.UpdateMyInformation);
}
public async Task <TResponse <bool> > UpdateInformationUser(int userId,
UpdateInformationModel request,
string folder)
{
try
{
var user = await GetById(userId);
if (user.IsSuccess)
{
var image = request.Image;
string avatar = string.Empty;
if (image != null &&
image.Length > 0)
{
avatar = $"{user.Data.Username}.png";
}
var result = await WriteRepository.ExecuteAsync(SqlQuery.USER_UPDATE_INFORMATION,
new
{
request.FullName,
request.DisplayName,
request.PhoneNumber,
request.Email,
request.BranchId,
request.Avatar,
UserUpdated = userId,
DateUpdated = DateTime.Now,
Id = userId
});
if (result.IsSuccess)
{
if (result.Data > 0)
{
if (image != null &&
image.Length > 0)
{
try
{
if (!Directory.Exists(folder))
{
Directory.CreateDirectory(folder);
}
using (FileStream filestream = File.Create(Path.Combine(folder,
user.Data.Username) + ".png"))
{
image.CopyTo(filestream);
filestream.Flush();
}
}
catch (Exception ex)
{
}
}
return(await Ok(true));
}
return(await Fail <bool>(ErrorEnum.CAN_NOT_CHANGE_USER_INFORMATION.GetStringValue()));
}
}
return(await Fail <bool>(user.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
