protected async Task <IActionResult> DeleteItem(int id, bool setFlag)
{
var item = await _repository.GetById(id);
if (item == null)
{
return(Ok(ResponseDTO.NotFound()));
}
IActionResult response = BadRequest(ResponseDTO.BadRequest());
if (setFlag)
{
item.DeleteFlag = true;
item = await _repository.Update(item);
response = Ok(ResponseDTO.OkDeleted(item));
}
else
{
var result = await _repository.Remove(id);
response = result
? Ok(ResponseDTO.OkDeleted(item, "Removed from database."))
: response;
}
return(response);
}
public async Task <IActionResult> ClientGetCustomerInfo()
{
var sessionUsername = HttpContext.Session.GetString(SessionConstant.Username);
if (string.IsNullOrEmpty(sessionUsername))
{
return(Ok(ResponseDTO.BadRequest()));
}
var customer = await _repository.FirstOrDefault(c => c.Username == sessionUsername);
if (customer == null)
{
return(Ok(ResponseDTO.NotFound()));
}
return(Ok(ResponseDTO.Ok(new
{
id = customer.Id,
customer.Name,
dateOfBirth = customer.DateOfBirth.ToString("o"),
email = customer.Email,
phoneNumber = customer.PhoneNumber,
gender = customer.Gender
})));
}
protected async Task <IActionResult> _GetById <ResponseModel>(int id, RequestContext context)
where ResponseModel : BaseDTO
{
try
{
var entity = await _repository.GetById(id);
if (entity == null)
{
return(Ok(ResponseDTO.NotFound()));
}
var models = MapToResponseModels <ResponseModel>(new List <Model>()
{
entity
});
var resultModel = await FinishMappingResponseModels(models, new List <Model>() { entity }, context);
return(Ok(ResponseDTO.Ok(resultModel.First())));
}
catch (Exception e)
{
return(HandleExceptionInRequest(e));
}
}
/*
* Summary:
* - Give a change to modify response models before return.
*/
// protected virtual async Task<object> FinishMapResponseModel(object responseEntity, Model entity)
// {
// return await Task.FromResult(responseEntity);
// }
/*
* Summary: Return resposne for get request.
*/
public async Task <IActionResult> ResultForGetAll(IEnumerable <dynamic> items, int totalRecords)
{
if (items.Count() == 0)
{
return(Ok(ResponseDTO.NotFound()));
}
return(Ok(ResponseDTO.Ok(items, totalRecords)));
}
public async Task <IActionResult> GetUserById(int id)
{
var users = await repo.GetUserById(id);
if (users == null)
{
return(BadRequest(ResponseDTO.NotFound()));
}
var items = mapper.Map <ResponseUserDto>(users);
return(Ok(ResponseDTO.Ok(items)));
}
/// <summary>
/// Login for the given username and password.
/// </summary>
/// <returns>The authorized user if login is successful.</returns>
/// <param name="pUsername">Username.</param>
/// <param name="pPassword">Password.</param>
public ResponseDTO <UserDTO> Login(string pUsername, string pPassword)
{
using (IUnitOfWork bUoW = _unitOfWorkFactory.GetUnitOfWork())
{
User user = bUoW.UserRepository.Get(pUsername);
// Non-existing user
if (user == null)
{
return(ResponseDTO <UserDTO> .NotFound($"There is no user associated with the username {pUsername}"));
}
// Password matches with user's password: successful login
if (string.Equals(user.Password, pPassword))
{
return(ResponseDTO <UserDTO> .Ok(_mapper.Map <UserDTO>(user)));
}
return(ResponseDTO <UserDTO> .Unauthorized("Incorrect password."));
}
}
// Helper method
protected async Task <IActionResult> _UpdateItemForAdminAsync(Model model)
{
IActionResult response = BadRequest(ResponseDTO.NotFound());
if (!(await _repository.ExistWhere(m => m.Id == model.Id)))
{
return(response);
}
var item = await _repository.Update(model);
if (item == null)
{
return(response);
}
response = Ok(ResponseDTO.Ok(item));
return(response);
}
public async Task <IActionResult> UpdateUser(int id, UpdateDto dto)
{
var user = await repo.GetUserById(id);
if (user == null)
{
return(BadRequest(ResponseDTO.NotFound()));
}
user.Username = dto.Username;
user.Email = dto.Email;
user.RoleId = dto.RoleId;
user.Name = dto.Name;
user.PhoneNumber = dto.PhoneNumber;
await repo.Update(user);
return(Ok(ResponseDTO.Ok(user)));
}
public async Task <IActionResult> ClientUpdateAddress([FromBody] BodyAddressDTO dto)
{
var customer = await GetCustomer();
if (customer == null)
{
return(Ok(ResponseDTO.BadRequest("Invalid customers' username.")));
}
var updateAddress = customer.Addresses.FirstOrDefault(c => c.Id == dto.id);
if (updateAddress != null)
{
updateAddress.City = dto.city;
updateAddress.District = dto.district;
updateAddress.Ward = dto.ward;
updateAddress.Street = dto.street;
updateAddress.CustomerId = customer.Id;
updateAddress.RecipientName = dto.name;
updateAddress.RecipientPhoneNumber = dto.phoneNumber;
}
else
{
return(Ok(ResponseDTO.NotFound("Invalid ID for updated address.")));
}
await _context.SaveChangesAsync();
var listResponse = new List <object>();
foreach (var add in customer.Addresses)
{
listResponse.Add(ConvertToResponseAddressDTO(add, customer.Id));
}
return(Ok(ResponseDTO.Ok(listResponse)));
}
public async Task <IActionResult> ClientGetCustomerAddress()
{
var sessionUsername = HttpContext.Session.GetString(SessionConstant.Username);
if (string.IsNullOrEmpty(sessionUsername))
{
return(Ok(ResponseDTO.BadRequest()));
}
var customer = await _repository.FirstOrDefault(c => c.Username == sessionUsername);
if (customer == null)
{
return(Ok(ResponseDTO.NotFound()));
}
var listResult = new List <dynamic>();
foreach (var address in customer.Addresses)
{
listResult.Add(ConvertToResponseAddressDTO(address, customer.Id));
}
return(Ok(ResponseDTO.Ok(listResult)));
}
