コード例 #1
0
        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));
            }
        }
コード例 #2
0
        public async Task <ItemServiceModel> CreateItemAsync(ItemServiceModel model)
        {
            var item = _mapper.Map <Item>(model);

            var savedItem = await _onebrbContext.CreateItemAync(item);

            return(_mapper.Map <ItemServiceModel>(savedItem));
        }
コード例 #3
0
        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
            }));
        }
コード例 #4
0
        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
            }));
        }
コード例 #5
0
        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));
        }
コード例 #6
0
        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);
        }
コード例 #7
0
        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);
            }
        }
コード例 #8
0
        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);
        }
コード例 #9
0
        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
            }));
        }
コード例 #10
0
        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);
            }
        }
コード例 #11
0
        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));
            }
        }
コード例 #12
0
        public async void GetItemAsync_ItemNotFound_ShouldReturnNull()
        {
            ItemServiceModel result = await _itemService.GetItemAsync(It.IsAny <int>());

            Assert.Null(result);
        }