public async Task <UpdateProductResponse> UpdateProduct([FromBody] UpdateProductRequest request)
        {
            /* VALIDATE */
            var validator = _validatorResolver.Resolve <UpdateProductRequestValidator>();
            ValidationResult validationResult = validator.Validate(request);

            if (!validationResult.IsValid)
            {
                throw new ValidationException(validationResult.ToString());
            }

            var product = await _productService.GetProductBySku(request.SKU);

            if (ControlHelper.isEmpty(product))
            {
                throw new NotFoundException(nameof(Product));
            }

            product.ProductName = request.ProductName;
            product.Description = request.Description;
            product.Price       = request.Price;
            product.Quantity    = request.Quantity;

            await _productService.UpdateProduct(product);

            var productResponse = _mapper.Map <UpdateProductResponse>(product);

            return(productResponse);
        }
Beispiel #2
0
        public async Task <UserResponse> Authenticate([FromBody] LoginRequest userRequest)
        {
            /* VALIDATE */
            var validator = _validatorResolver.Resolve <LoginRequestValidator>();
            ValidationResult validationResult = validator.Validate(userRequest);

            if (!validationResult.IsValid)
            {
                throw new ValidationException(validationResult.ToString());
            }

            var user = await _userService.Authenticate(userRequest.Username, userRequest.Password);

            return(_mapper.Map <UserResponse>(user));
        }
Beispiel #3
0
        public async Task <object> DispatchAsync()
        {
            var commandName = _command.GetType().Name;
            var validator   = _validatorResolver.Resolve <T>();

            Logger.Debug($"Validating command: {commandName}.");
            var errors = validator.SetPropertiesAndValidate(_command).ToArray();

            if (errors.Any())
            {
                Logger.Debug($"Command: {commandName} is invalid. Errors: {errors.AggregateLines()}.");
                throw new ValidatorException(errors);
            }

            Logger.Debug($"Dispatching command: {commandName}.");
            object response = null;
            await _dispatcher.DispatchAsync(_command);

            if (_asyncResponseFunc != null)
            {
                response = await _asyncResponseFunc(_command);
            }
            else if (_responseFunc != null)
            {
                response = _responseFunc(_command);
            }

            return(response);
        }
        public async Task <UserResponse> PurchaseItem([FromBody] PurchaseRequestModel purchaseRequest)
        {
            /*
             * FLOW:
             *      1. User'ı ve Item'ı göndermeli.
             *      2. User var mı?
             *      3. Item var mı?
             *      4. Ödeme yöntemi nedir? Ona göre hareket edilecek. Kredikartı veya oyun parası. (Bunun için yeni bir modele ihtiyaç var)
             *      5. Ödeme valid ise UserItem tablosuna listedeki Item'lar eklenecek. Ve yeni Item'listesi  ve User değerleri dönmeli.
             */
            /* VALIDATE */
            var validator        = _validatorResolver.Resolve <PurchaseRequestValidator>();
            var validationResult = validator.Validate(purchaseRequest);

            if (!validationResult.IsValid)
            {
                throw new FluentValidation.ValidationException(validationResult.ToString());
            }

            foreach (var item in purchaseRequest.Items)
            {
                var purchaseResponse = await _userItemService.CreateUserItem(item);
            }

            var foundUser = await _userService.GetUserById(purchaseRequest.CustomerId);

            if (foundUser == null)
            {
                throw new NotFoundException(_localizer.GetString(LocaleResourceConstants.UserNotFound));                    //TODO: Handle error logging and response model for client
            }
            return(_mapper.Map <UserResponse>(foundUser));
        }
Beispiel #5
0
        public async Task <UserResponse> CreateUser([FromBody] UserRequest userRequest)
        {
            /* VALIDATE */
            var validator = _validatorResolver.Resolve <UserRequestValidator>();
            ValidationResult validationResult = validator.Validate(userRequest);

            if (!validationResult.IsValid)
            {
                throw new ValidationException(validationResult.ToString());
            }

            var user = _mapper.Map <User>(userRequest);

            var userResponse = _userService.CreateUser(user);

            var userResponseModel = _mapper.Map <UserResponse>(userResponse.Result);

            return(userResponseModel);
        }
Beispiel #6
0
        public async Task UpgradeItem([FromBody] UserItemRequest request)
        {
            /* VALIDATE */
            var validator = _validatorResolver.Resolve <UserItemRequestValidator>();
            ValidationResult validationResult = validator.Validate(request);

            if (!validationResult.IsValid)
            {
                throw new ValidationException(validationResult.ToString());
            }

            var user = await _userService.GetUserById(request.UserId);

            if (ControlUtil.isEmpty(user))
            {
                throw new NotFoundException(_localizer.GetString(LocaleResourceConstants.UserNotFound));                             //TODO: Handle error logging and response model for client
            }
            var userItem = _mapper.Map <UserItem>(request);

            userItem.ItemLevel++;

            await _userItemService.UpdateUserItem(userItem);
        }