public async Task <ActionResult> UpdateSuppliers([FromBody] UpdateSupplierCommand command)
{
var response = await _mediator.Send(command);
if (response.Status.IsSuccessful)
{
return(Ok(response));
}
return(BadRequest(response));
}
public async Task <ActionResult> Update(int id, UpdateSupplierCommand command)
{
if (id != command.Id)
{
return(BadRequest());
}
await Mediator.Send(command);
return(NoContent());
}
public async Task <ResultWrapper <UpdateSupplierOutput> > Handle(UpdateSupplierCommand request, CancellationToken cancellationToken)
{
ResultWrapper <UpdateSupplierOutput> createUserResult = new ResultWrapper <UpdateSupplierOutput>();
try
{
GenderEnum GenderEn = GenderEnum.NULL;
if (!Enum.TryParse <GenderEnum>(request.Gender.ToString(), true, out GenderEn))
{
createUserResult.Status = false;
createUserResult.Message = "Gender value is invalid!";
return(createUserResult);
}
TUser tUser = _dbContext.TUser.FirstOrDefault(x => x.Id == request.Id);
if (tUser == null)
{
createUserResult.Status = false;
createUserResult.Message = "cannot find supplier!";
return(createUserResult);
}
tUser.Gender = request.Gender;
tUser.FirstName = request.FirstName;
tUser.LastName = request.LastName;
tUser.Address = request.Address;
tUser.PostalCode = request.PostalCode;
tUser.Phone = request.Phone;
tUser.TRegionCityId = request.RegionCityId;
tUser.RestaurantName = request.RestaurantName;
tUser.ShareAccount = request.ShareAccount;
tUser.SharePercent = request.SharePercent;
tUser.Lat = request.Lat;
tUser.Lng = request.Lng;
_dbContext.Update(tUser);
await _dbContext.SaveChangesAsync();
createUserResult.Status = true;
createUserResult.Result = new UpdateSupplierOutput()
{
Id = tUser.Id,
Email = tUser.Email,
FireBaseId = tUser.FireBaseId
};
}
catch (Exception ex)
{
createUserResult.Status = false;
createUserResult.Message = ex.Message;
}
return(createUserResult);
}
public async Task <IdResponse> HandleAsync(UpdateSupplierCommand cmd, CancellationToken ct)
{
var result = _supplierRepository.Update(new Supplier
{
Name = cmd.Name,
Email = cmd.Email,
Telephone = cmd.Telephone,
ID = cmd.id
});
return(new IdResponse(cmd.Id));
}
public async Task <ActionResult <SupplierDto> > Update(int supplierId,
[FromBody] UpdateSupplierViewModel updateSupplierViewModel)
{
var command = new UpdateSupplierCommand
{
Id = supplierId,
Name = updateSupplierViewModel.Name,
Email = updateSupplierViewModel.Email,
Phone = updateSupplierViewModel.Phone
};
var result = await mediator.Send(command);
if (!result.Success)
{
return(BadRequest(result.ErrorMessages));
}
var resultData = await mediator.Send(new GetSupplierByIdQuery { Id = supplierId });
return(Ok(resultData.Data));
}
public async Task ValidateEmail(string email)
{
var createSupplierCommand = new CreateSupplierCommand
{
Name = "Pascal",
Phone = "+41 79 456 45 45",
Email = email,
};
var createSupplierCommandValidator = new CreateSupplierCommandValidator();
var result = await createSupplierCommandValidator.ValidateAsync(createSupplierCommand);
Assert.False(result.IsValid);
Assert.NotEmpty(result.Errors);
Assert.Contains(result.Errors, e => e.PropertyName == nameof(createSupplierCommand.Email));
Assert.DoesNotContain(result.Errors, e => e.PropertyName == nameof(createSupplierCommand.Name));
Assert.DoesNotContain(result.Errors, e => e.PropertyName == nameof(createSupplierCommand.Phone));
var updateSupplierCommand = new UpdateSupplierCommand
{
Id = 1,
Name = "Pascal",
Phone = "+41 79 456 45 45",
Email = email,
};
var updateSupplierCommandValidator = new UpdateSupplierCommandValidator();
result = await updateSupplierCommandValidator.ValidateAsync(updateSupplierCommand);
Assert.False(result.IsValid);
Assert.NotEmpty(result.Errors);
Assert.Contains(result.Errors, e => e.PropertyName == nameof(updateSupplierCommand.Email));
Assert.DoesNotContain(result.Errors, e => e.PropertyName == nameof(updateSupplierCommand.Id));
Assert.DoesNotContain(result.Errors, e => e.PropertyName == nameof(updateSupplierCommand.Name));
Assert.DoesNotContain(result.Errors, e => e.PropertyName == nameof(updateSupplierCommand.Phone));
}
public async Task <IActionResult> Update([FromBody] UpdateSupplierCommand updateSupplierCommand)
{
ResultWrapper <UpdateSupplierOutput> updateSupplierResult = await _mediator.Send(updateSupplierCommand);
return(Ok(updateSupplierResult));
}
public async Task <IActionResult> UpdateDevice(UpdateSupplierCommand command)
{
var result = await Task.FromResult(command);
return(Ok(result));
}
public async Task <IActionResult> Update([FromBody] UpdateSupplierCommand command)
{
var result = await _mediator.Send(command);
return(Ok(result));
}
public async Task <ActionResult> UpdateAsync([FromBody] UpdateSupplierCommand command)
{
await _mediator.Send(command, HttpContext.RequestAborted);
return(NoContent());
}
public async Task TestUpdateSupplierSuccess()
{
await using var context = DatabaseHelper.CreateInMemoryDatabaseContext(nameof(TestUpdateSupplierSuccess));
var addedSupplier = await context.Suppliers.AddAsync(ValidModelCreator.Supplier());
var supplier1Id = addedSupplier.Entity.Id;
var updateCmd1 = new UpdateSupplierCommand
{
Id = supplier1Id,
Name = "something",
Email = "*****@*****.**",
Phone = null,
};
var updateHandler = new UpdateSupplierCommandHandler(context);
var queryOneHandler = new GetSupplierByIdQueryHandler(context);
var response1 = await updateHandler.Handle(updateCmd1, CancellationToken.None);
Assert.True(response1.Success);
var updatedSupplier =
(await queryOneHandler.Handle(new GetSupplierByIdQuery {
Id = updateCmd1.Id
}, CancellationToken.None))
.Data;
Assert.Equal(updateCmd1.Name, updatedSupplier.Name);
Assert.Equal(updateCmd1.Email, updatedSupplier.Email);
Assert.Equal(updateCmd1.Phone, updatedSupplier.Phone);
var updateCmd2 = new UpdateSupplierCommand
{
Id = supplier1Id,
Name = "something new",
Email = "*****@*****.**",
Phone = "+41 79 456 45 45",
};
var response2 = await updateHandler.Handle(updateCmd2, CancellationToken.None);
Assert.True(response2.Success);
var updatedAgain =
(await queryOneHandler.Handle(new GetSupplierByIdQuery {
Id = updateCmd1.Id
}, CancellationToken.None))
.Data;
Assert.Equal(updateCmd2.Name, updatedAgain.Name);
Assert.Equal(updateCmd2.Email, updatedAgain.Email);
Assert.Equal(updateCmd2.Phone, updatedAgain.Phone);
var updateNonExistingSupplierCommand = new UpdateSupplierCommand
{
Id = supplier1Id + 1,
Name = "something",
Email = "*****@*****.**",
Phone = "+41 79 456 45 45",
};
var response3 = await updateHandler.Handle(updateNonExistingSupplierCommand, CancellationToken.None);
Assert.False(response3.Success);
}
