public async Task <IActionResult> Update(Guid imageId, [FromBody] UpdateRequestModel request)
{
if (request.ImageName == null)
{
return(BadRequest(UploadImageResultViewModel.Failure(localizer["NameNotSet"].Value, false, localizer)));
}
if (request.Description == null)
{
return(BadRequest(UploadImageResultViewModel.Failure(localizer["DescriptionNotSet"].Value, false, localizer)));
}
if (request.Source == null)
{
return(BadRequest(UploadImageResultViewModel.Failure(localizer["SourceNotSet"].Value, false, localizer)));
}
if (request.VersionDescription == null)
{
return(BadRequest(UploadImageResultViewModel.Failure(localizer["VersionDescriptionNotSet"].Value, false, localizer)));
}
try
{
var user = await userManager.GetUserAsync(HttpContext.User);
var applicationRequest = new UpdateImageMetadata.Request(imageId, user, request.ImageName, request.Source, request.Description, request.VersionDescription);
await new UpdateImageMetadata(dbContext, localizer).RunAsync(applicationRequest);
var toastText = $"{localizer["SuccessfullyUpdatedImage"]} '{request.ImageName}'";
return(Ok(new { ToastText = toastText, ToastTitle = localizer["Success"] }));
}
catch (Exception e)
{
return(ControllerError.BadRequest(e, this));
}
}
public async Task <IActionResult> Update(Guid tagId, [FromBody] UpdateRequestModel request)
{
CheckBodyParameter(request);
var userId = await UserServices.UserIdFromContextAsync(HttpContext, userManager);
await new UpdateTag(callContext).RunAsync(new UpdateTag.Request(userId, tagId, request.NewName.Trim(), request.NewDescription.Trim()));
return(ControllerResultWithToast.Success(Get("TagRecorded") + ' ' + request.NewName, this));
}
public async Task <IActionResult> Update(Guid imageId, [FromBody] UpdateRequestModel request)
{
CheckBodyParameter(request);
var userId = await UserServices.UserIdFromContextAsync(HttpContext, userManager);
var applicationRequest = new UpdateImageMetadata.Request(imageId, userId, request.ImageName, request.Source, request.Description, request.VersionDescription);
await new UpdateImageMetadata(callContext).RunAsync(applicationRequest);
var toastText = $"{Get("SuccessfullyUpdatedImage")} '{request.ImageName}'";
return(ControllerResultWithToast.Success(toastText, this));
}
/// <summary>
/// Execute convert input.
/// </summary>
/// <param name="request">RequestModel</param>
/// <returns>DataModel</returns>
private UpdateDataModel Convert(UpdateRequestModel request)
{
// Local variable declaration
UpdateDataModel inputObject = null;
// Variable initialize
inputObject = new UpdateDataModel();
// Convert data input
DataHelper.ConvertInput(request, inputObject);
// Return value
return(inputObject);
}
/// <summary>
/// Execute convert input.
/// </summary>
/// <param name="request">RequestModel</param>
/// <returns>DataModel</returns>
private UpdateDataModel Convert(UpdateRequestModel request)
{
// Local variable declaration
UpdateDataModel inputObject = null;
// Variable initialize
inputObject = new UpdateDataModel();
// Convert data input
DataHelper.ConvertInput(request, inputObject);
// Return value
return inputObject;
}
public ActionResult <SnippetModel> Update(
[FromRoute][ObjectId][Required] string Id,
[FromBody] UpdateRequestModel requestModel)
{
return(this.updateActionModelQueryHandler
.Handle(
query: new UpdateActionModelQuery(
snippetId: Id,
description: requestModel.Description,
content: requestModel.Content))
.Match <ActionResult <SnippetModel> >(
some: resultModel => resultModel.SnippetModel,
none: () => new NotFoundResult()));
}
public async Task Update(string email, string password, string name)
{
//Arrange
var testUser = new UpdateRequestModel
{
Email = email,
Password = password
};
//Act
var updated = await Controller.Edit(testUser);
// Assert
Assert.Equal(email, updated.Email);
}
public async Task <UserModel> Edit([FromBody] UpdateRequestModel request)
{
var user = _usersService.GetByEmail(request.Email);
if (user == null)
{
throw new HttpRequestException(_errorHandler.GetMessage(ErrorMessagesEnum.AuthUserDoesNotExists));
}
var validEmail = await _usersService.ValidateUser(user);
if (!validEmail.Succeeded)
{
_errorHandler.ErrorIdentityResult(validEmail);
}
IdentityResult validPass = null;
if (!string.IsNullOrEmpty(request.Password))
{
validPass = await _usersService.ValidatePassword(user, request.Password);
if (validPass.Succeeded)
{
user.PasswordHash = _usersService.HashPassword(user,
request.Password);
}
else
{
_errorHandler.ErrorIdentityResult(validPass);
}
}
if (validPass != null && ((!validEmail.Succeeded || request.Password == string.Empty || !validPass.Succeeded)))
{
throw new HttpRequestException(_errorHandler.GetMessage(ErrorMessagesEnum.AuthNotValidInformations));
}
var result = await _usersService.Update(user);
if (result.Succeeded)
{
return(user);
}
throw new HttpRequestException(_errorHandler.GetMessage(ErrorMessagesEnum.AuthCannotUpdate));
}
/// <summary>
/// Execute processing.
/// </summary>
/// <param name="request">RequestModel</param>
/// <returns>ResponseModel</returns>
private UpdateResponseModel Execute(UpdateRequestModel request)
{
// Local variable declaration
UpdateResponseModel responseModel = null;
UpdateDataModel inputObject = null;
UpdateDataModel resultObject = null;
// Variable initialize
responseModel = new UpdateResponseModel();
// Execute convert input.
inputObject = Convert(request);
// Check infomation
Check(inputObject);
// Update infomation
resultObject = UpdateInfo(inputObject);
// Execute convert ouput.
responseModel = Convert(resultObject);
return(responseModel);
}
/// <summary>
/// Update process.
/// </summary>
/// <param name="request">RequestModel</param>
/// <returns>ResponseModel</returns>
public UpdateResponseModel Invoke(UpdateRequestModel request)
{
var response = Execute(request);
return(response);
}
public async Task <IActionResult> UpdateTeamRequest([FromBody] UpdateRequestModel payload, CancellationToken cancellationToken)
{
await _updateTeamRequestCommand.Value.ExecuteAsync(payload, HttpContext.User, cancellationToken);
return(Ok());
}
/// <summary>
/// Update process.
/// </summary>
/// <param name="request">RequestModel</param>
/// <returns>ResponseModel</returns>
public UpdateResponseModel Invoke(UpdateRequestModel request)
{
var response = Execute(request);
return response;
}
/// <summary>
/// Execute processing.
/// </summary>
/// <param name="request">RequestModel</param>
/// <returns>ResponseModel</returns>
private UpdateResponseModel Execute(UpdateRequestModel request)
{
// Local variable declaration
UpdateResponseModel responseModel = null;
UpdateDataModel inputObject = null;
UpdateDataModel resultObject = null;
// Variable initialize
responseModel = new UpdateResponseModel();
// Execute convert input.
inputObject = Convert(request);
// Check infomation
Check(inputObject);
// Update infomation
resultObject = UpdateInfo(inputObject);
// Execute convert ouput.
responseModel = Convert(resultObject);
return responseModel;
}
public async Task <IActionResult> Update(Guid tagId, [FromBody] UpdateRequestModel request)
{
return(Ok(await new UpdateTag(dbContext).RunAsync(tagId, request.NewName)));
}
