public async Task <ViewResult> Edit(int itemId)
{
// Get current user
var currentUser = await this._userManager.GetUserAsync(this.User);
using (var client = new OnebrbApi())
{
client.BaseUri = new Uri(_apiOptions.BaseAddress, UriKind.Absolute);
var response = await client.GetItemAsync(itemId);
ItemServiceModel itemModel = this._mapper.Map <ItemServiceModel>(response.Body);
EditItemViewModel editItemViewModel = this._mapper.Map <EditItemViewModel>(itemModel);
if (editItemViewModel == null)
{
return(View("Errors/NotFound"));
}
// Only the product author is allowed to edit it
if (editItemViewModel.UserId != currentUser.Id)
{
return(View("Errors/Unauthorized"));
}
editItemViewModel.SecurityHash = currentUser.SecurityHash;
return(View(editItemViewModel));
}
}
public async Task <ItemServiceModel> CreateItemAsync(ItemServiceModel model)
{
var item = _mapper.Map <Item>(model);
var savedItem = await _onebrbContext.CreateItemAync(item);
return(_mapper.Map <ItemServiceModel>(savedItem));
}
public async Task <IActionResult> EditItem(int itemId, [FromBody] EditItemRequestModel model)
{
Guard.Argument(itemId, nameof(itemId)).GreaterThan(0);
Guard.Argument(model, nameof(model)).NotNull();
// Validate security hash provided in the request
bool isValidSecurityHash = SecurityHashValidator.IsValidSecurityHash(model.UserId, model.SecurityHash);
// If the security hash is invalid it means it's been tempered with, so we terminate the request
if (!isValidSecurityHash)
{
return(BadRequest(new BaseApiResponse <ItemServiceModel>
{
StatusCode = StatusCodes.Status400BadRequest,
Message = ResponseMessages.BadRequest,
}));
}
ItemServiceModel item = await this._itemService.GetItemAsync(itemId);
if (item == null)
{
return(Ok(new BaseApiResponse <ItemServiceModel>
{
StatusCode = StatusCodes.Status404NotFound,
Message = ResponseMessages.NotFound,
}));
}
var editItemServiceModel = this._mapper.Map <EditItemServiceModel>(model);
bool result = await this._itemService.Edit(editItemServiceModel);
if (!result)
{
return(Ok(new BaseApiResponse <ItemServiceModel>
{
StatusCode = StatusCodes.Status500InternalServerError,
Message = ResponseMessages.ServerError,
}));
}
item = await this._itemService.GetItemAsync(itemId);
return(Ok(new BaseApiResponse <ItemServiceModel>
{
StatusCode = StatusCodes.Status200OK,
Message = ResponseMessages.SuccessfulOperation,
Body = item
}));
}
public async Task <IActionResult> DeleteItem(int itemId, [FromQuery] string userId, [FromQuery] string securityHash)
{
Guard.Argument(itemId, nameof(itemId)).GreaterThan(0);
// Validate security hash provided in the request
bool isValidSecurityHash = SecurityHashValidator.IsValidSecurityHash(userId, securityHash);
// If the security hash is invalid it means it's been tempered with, so we terminate the request
if (!isValidSecurityHash)
{
return(Ok(new BaseApiResponse <ItemServiceModel>
{
StatusCode = StatusCodes.Status401Unauthorized,
Message = ResponseMessages.Unauthorized,
}));
}
// Check if item exists
ItemServiceModel item = await this._itemService.GetItemAsync(itemId);
if (item == null)
{
return(Ok(new BaseApiResponse <ItemServiceModel>
{
StatusCode = StatusCodes.Status404NotFound,
Message = ResponseMessages.NotFound,
}));
}
// Delete
bool result = await this._itemService.Delete(new DeleteItemServiceModel
{
ItemId = itemId,
UserId = userId,
});
if (!result)
{
return(Problem(ResponseMessages.ServerError, null, 500));
}
return(Ok(new BaseApiResponse <ItemServiceModel>
{
StatusCode = StatusCodes.Status200OK,
Message = ResponseMessages.SuccessfulOperation,
Body = item
}));
}
public ActionResult Demo(ItemServiceModel model)
{
var item = new ItemServiceModel
{
Name = "Milk",
Price = 15,
DateOfPurchase = DateTime.UtcNow,
ItemType = (Omack.Core.Enums.ItemType) 1,
UserId = 2,
GroupId = 10,
MediaId = 1
};
_itemService.Add(item, _siteUtils.CurrentUser.Id, _siteUtils.CurrentGroup.Id);
return(Ok(item));
}
public async Task <ItemServiceModel> Create(ItemServiceModel item)
{
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
Item dbItem = ObjectMapper.Mapper.Map <Item>(item);
Item createdItem = await this._onebrbContext.CreateItemAync(dbItem);
if (createdItem.Id > 0)
{
return(ObjectMapper.Mapper.Map <ItemServiceModel>(createdItem));
}
return(null);
}
public Result <ItemServiceModel> Update(ItemServiceModel itemModel, int userId, int groupId)
{
var result = new Result <ItemServiceModel>();
try
{
var itemEntity = _unitOfWork.ItemRepository.GetSingle(x => x.Id == itemModel.Id && x.IsActive && x.UserId == userId && x.GroupId == groupId);
if (itemEntity != null)
{
itemEntity.Name = itemModel.Name;
itemEntity.Price = itemModel.Price;
itemEntity.DateOfPurchase = itemModel.DateOfPurchase;
itemEntity.ItemType = (int)itemModel.ItemType;
itemEntity.GroupId = itemModel.GroupId;
itemEntity.MediaId = itemModel.MediaId;
itemEntity.UpdatedOn = Application.CurrentDate;
itemEntity.UpdatedBy = userId;
_unitOfWork.Save();
//map to service model after update
var updatedItemModel = _mapper.Map <ItemServiceModel>(itemEntity);
//return result
result.IsSuccess = true;
result.Data = updatedItemModel;
return(result);
}
else
{
result.IsSuccess = false;
result.ErrorMessage = ErrorMessage.UpdateUnAuth;
return(result);
}
}
catch (Exception ex)
{
_logger.LogCritical(ex.InnerException.Message);
result.IsSuccess = false;
result.ErrorMessage = ErrorMessage.Update;
return(result);
}
}
public async void GetItemAsync_ItemFound_ShouldReturnItem()
{
int itemId = DataGenerator.Create <int>();
var fakeItem = new Item {
Id = itemId
};
var fakeItemServiceModel = new ItemServiceModel
{
Id = itemId,
};
_onebrbContext.Setup(x => x.GetItemAsync(itemId))
.ReturnsAsync(fakeItem);
ItemServiceModel result = await _itemService.GetItemAsync(itemId);
Assert.NotNull(result);
Assert.Equal(result.Id, fakeItem.Id);
}
public async Task <ActionResult <BaseApiResponse <ItemServiceModel> > > GetItem(int itemId)
{
Guard.Argument(itemId, nameof(itemId)).GreaterThan(0);
ItemServiceModel item = await _itemService.GetItemAsync(itemId);
if (item == null)
{
return(Ok(new BaseApiResponse <ItemServiceModel>
{
StatusCode = StatusCodes.Status404NotFound,
Message = ResponseMessages.NotFound,
}));
}
return(Ok(new BaseApiResponse <ItemServiceModel>
{
StatusCode = StatusCodes.Status200OK,
Message = ResponseMessages.SuccessfulOperation,
Body = item
}));
}
public Result <ItemServiceModel> Add(ItemServiceModel item, int userId, int groupId)
{
var result = new Result <ItemServiceModel>();
try
{
var newItem = new Item()
{
Name = item.Name,
Price = item.Price,
DateOfPurchase = item.DateOfPurchase,
ItemType = (int)item.ItemType,
IsActive = true,
UserId = userId,
GroupId = groupId,
MediaId = item.MediaId,
CreatedOn = Application.CurrentDate,
CreatedBy = userId
};
_unitOfWork.ItemRepository.Add(newItem);
_unitOfWork.Save();
var mappedItem = _mapper.Map <ItemServiceModel>(newItem);
result.IsSuccess = true;
result.Data = mappedItem;
return(result);
}
catch (Exception ex)
{
_logger.LogCritical(ex.InnerException.Message);
result.IsSuccess = false;
result.ErrorMessage = ErrorMessage.Add;
result.StatusCodes = StatusCodes.Status500InternalServerError;
return(result);
}
}
public async Task <ActionResult <ItemServiceModelBaseApiResponse> > View(int?itemId)
{
if (!itemId.HasValue)
{
return(View("Errors/NotFound"));
}
using (var client = new OnebrbApi())
{
client.BaseUri = new Uri(_apiOptions.BaseAddress, UriKind.Absolute);
var response = await client.GetItemAsync(itemId.Value);
if (response.StatusCode == StatusCodes.Status404NotFound)
{
return(View("Errors/NotFound"));
}
ItemServiceModel itemModel = this._mapper.Map <ItemServiceModel>(response.Body);
var itemViewModel = this._mapper.Map <ItemViewModel>(itemModel);
return(View(itemViewModel));
}
}
public async void GetItemAsync_ItemNotFound_ShouldReturnNull()
{
ItemServiceModel result = await _itemService.GetItemAsync(It.IsAny <int>());
Assert.Null(result);
}
