public async Task <IActionResult> Execute(JObject jObj, string subject)
        {
            if (jObj == null)
            {
                throw new ArgumentNullException(nameof(jObj));
            }

            var href         = "/" + Constants.RouteNames.Messages + "/" + Constants.RouteNames.Search;
            var request      = _requestBuilder.GetSearchMessages(jObj);
            var searchResult = await _repository.Search(request);

            _halResponseBuilder.AddLinks(l => l.AddSelf(href));
            if (searchResult.Content == null || !searchResult.Content.Any())
            {
                return(new OkObjectResult(_halResponseBuilder.Build()));
            }

            foreach (var message in searchResult.Content)
            {
                _messageEnricher.Enrich(_halResponseBuilder, message);
            }

            double r       = (double)searchResult.TotalResults / (double)request.Count;
            var    nbPages = Math.Ceiling(r);

            nbPages = nbPages == 0 ? 1 : nbPages;
            for (var page = 1; page <= nbPages; page++)
            {
                _halResponseBuilder.AddLinks(l => l.AddOtherItem("navigation", new Dtos.Link(href, page.ToString())));
            }

            return(new OkObjectResult(_halResponseBuilder.Build()));
        }
        public async Task <IActionResult> Execute(JObject jObj)
        {
            if (jObj == null)
            {
                throw new ArgumentNullException(nameof(jObj));
            }

            var parameter    = _requestBuilder.GetSearchProducts(jObj);
            var searchResult = await _repository.Search(parameter);

            _halResponseBuilder.AddLinks(l => l.AddSelf(GetProductLink()));
            if (searchResult != null && searchResult.Content != null)
            {
                var products = searchResult.Content;
                foreach (var product in products)
                {
                    _productEnricher.Enrich(_halResponseBuilder, product);
                }

                double r       = (double)searchResult.TotalResults / (double)parameter.Count;
                var    nbPages = Math.Ceiling(r);
                nbPages = nbPages == 0 ? 1 : nbPages;
                for (var page = 1; page <= nbPages; page++)
                {
                    _halResponseBuilder.AddLinks(l => l.AddOtherItem("navigation", new Dtos.Link(GetProductLink(), page.ToString())));
                }
            }

            return(new OkObjectResult(_halResponseBuilder.Build()));
        }
Example #3
0
        public async Task <IActionResult> Execute(JObject jObj, string subject)
        {
            if (jObj == null)
            {
                throw new ArgumentNullException(nameof(jObj));
            }

            var request = _requestBuilder.GetSearchDiscountsParameter(jObj);

            request.Subject = subject;
            var searchResult = await _repository.Search(request);

            searchResult.Content = searchResult.Content == null ? new List <DiscountAggregate>() : searchResult.Content;
            var href = "/" + Constants.RouteNames.Discounts + "/" + Constants.RouteNames.Search;

            _halResponseBuilder.AddLinks(l => l.AddSelf(href));
            foreach (var order in searchResult.Content)
            {
                _discountEnricher.Enrich(_halResponseBuilder, order);
            }

            double r       = (double)searchResult.TotalResults / (double)request.Count;
            var    nbPages = Math.Ceiling(r);

            nbPages = nbPages == 0 ? 1 : nbPages;
            for (var page = 1; page <= nbPages; page++)
            {
                _halResponseBuilder.AddLinks(l => l.AddOtherItem("navigation", new Dtos.Link(href, page.ToString())));
            }

            return(new OkObjectResult(_halResponseBuilder.Build()));
        }
        public async Task <IActionResult> Execute(string orderId, string subject)
        {
            if (string.IsNullOrWhiteSpace(orderId))
            {
                throw new ArgumentNullException(nameof(orderId));
            }

            if (string.IsNullOrWhiteSpace(subject))
            {
                throw new ArgumentNullException(nameof(subject));
            }

            var order = await _orderRepository.Get(orderId);

            if (order == null)
            {
                var error = _responseBuilder.GetError(ErrorCodes.Server, ErrorDescriptions.TheOrderDoesntExist);
                return(_controllerHelper.BuildResponse(System.Net.HttpStatusCode.NotFound, error));
            }

            if (order.Subject != subject && order.SellerId != subject)
            {
                var error = _responseBuilder.GetError(ErrorCodes.Server, ErrorDescriptions.TheOrderCannotBeAccessedByYou);
                return(_controllerHelper.BuildResponse(System.Net.HttpStatusCode.BadRequest, error));
            }

            _halResponseBuilder.AddLinks(l => l.AddSelf("/" + Constants.RouteNames.Orders + "/" + orderId));
            await _orderEnricher.Enrich(_halResponseBuilder, order);

            return(new OkObjectResult(_halResponseBuilder.Build()));
        }
        public async Task <IActionResult> Execute()
        {
            var tags = await _repository.GetAll();

            _halResponseBuilder.AddLinks(l => l.AddSelf("/" + Constants.RouteNames.Tags));
            foreach (var tag in tags)
            {
                _tagEnricher.Enrich(_halResponseBuilder, tag);
            }

            return(new OkObjectResult(_halResponseBuilder.Build()));
        }
Example #6
0
        public async Task <IActionResult> Execute()
        {
            var categories = await _repository.GetAll();

            _halResponseBuilder.AddLinks(l => l.AddSelf("/" + Constants.RouteNames.ShopCategories));
            foreach (var category in categories)
            {
                _shopCategoryEnricher.Enrich(_halResponseBuilder, category);
            }

            return(new OkObjectResult(_halResponseBuilder.Build()));
        }
        public async Task <IActionResult> Execute()
        {
            var shops = await _repository.Get();

            _halResponseBuilder.AddLinks(l => l.AddSelf("/" + Constants.RouteNames.Shops));
            foreach (var shop in shops)
            {
                _shopEnricher.Enrich(_halResponseBuilder, shop);
            }

            return(new OkObjectResult(_halResponseBuilder.Build()));
        }
        public async Task <IActionResult> Execute(string subject)
        {
            if (string.IsNullOrWhiteSpace(subject))
            {
                throw new ArgumentNullException(nameof(subject));
            }

            var content = await _orderRepository.GetStatus(new GetOrderStatusParameter
            {
                Subject = subject,
            });

            var href = "/" + Constants.RouteNames.Orders + "/" + Constants.RouteNames.Status;

            _halResponseBuilder.AddLinks(l => l.AddSelf(href)).AddEmbedded(e => e.AddObject(_responseBuilder.GetOrderStatus(content)));
            return(new OkObjectResult(_halResponseBuilder.Build()));
        }
        public async Task <IActionResult> Execute(string id)
        {
            if (string.IsNullOrWhiteSpace(id))
            {
                throw new ArgumentNullException(nameof(id));
            }

            var shop = await _repository.Get(id);

            if (shop == null)
            {
                return(new NotFoundResult());
            }

            _halResponseBuilder.AddLinks(l => l.AddSelf("/" + Constants.RouteNames.Shops + "/" + id));
            _shopEnricher.Enrich(_halResponseBuilder, shop);
            return(new OkObjectResult(_halResponseBuilder.Build()));
        }
        public async Task <IActionResult> Execute(string id)
        {
            if (string.IsNullOrWhiteSpace(id))
            {
                throw new ArgumentNullException(nameof(id));
            }

            var service = await _repository.Get(id);

            if (service == null)
            {
                return(new NotFoundResult());
            }

            _halResponseBuilder.AddLinks(l => l.AddSelf(GetServiceLink(id)));
            _serviceEnricher.Enrich(_halResponseBuilder, service);
            return(new OkObjectResult(_halResponseBuilder.Build()));
        }
        public async Task <IActionResult> Execute(string subject)
        {
            if (string.IsNullOrWhiteSpace(subject))
            {
                throw new ArgumentNullException(nameof(subject));
            }

            var shops = await _repository.Search(new SearchShopsParameter
            {
                Subjects = new[] { subject }
            });

            _halResponseBuilder.AddLinks(l => l.AddSelf("/" + Constants.RouteNames.Shops + "/" + Constants.RouteNames.Me));
            foreach (var shop in shops.Content)
            {
                _shopEnricher.Enrich(_halResponseBuilder, shop);
            }

            return(new OkObjectResult(_halResponseBuilder.Build()));
        }
        public async Task <IActionResult> Execute(JObject jObj, string subject)
        {
            if (jObj == null)
            {
                throw new ArgumentNullException(nameof(jObj));
            }

            if (string.IsNullOrWhiteSpace(subject))
            {
                throw new ArgumentNullException(nameof(subject));
            }

            var request = _requestBuilder.GetNotificationStatus(jObj);

            request.To = subject;
            var content = await _notificationRepository.Search(request);

            var href = "/" + Constants.RouteNames.Notifications + "/" + Constants.RouteNames.Status;

            _halResponseBuilder.AddLinks(l => l.AddSelf(href)).AddEmbedded(e => e.AddObject(_responseBuilder.GetNotificationStatus(content)));
            return(new OkObjectResult(_halResponseBuilder.Build()));
        }
        public async Task <IActionResult> Execute(string subject)
        {
            if (string.IsNullOrWhiteSpace(subject))
            {
                throw new ArgumentNullException(nameof(subject));
            }

            var announces = await _repository.Search(new SearchClientServicesParameter
            {
                Subjects = new [] { subject }
            });

            _halResponseBuilder.AddLinks(l => l.AddSelf(GetAnnouncementLink()));
            if (announces.TotalResults > 0)
            {
                foreach (var announce in announces.Content)
                {
                    _enricher.Enrich(_halResponseBuilder, announce);
                }
            }

            return(new OkObjectResult(_halResponseBuilder.Build()));
        }
Example #14
0
        public async Task <IActionResult> Execute(string id)
        {
            if (string.IsNullOrWhiteSpace(id))
            {
                throw new ArgumentNullException(nameof(id));
            }


            if (string.IsNullOrWhiteSpace(id))
            {
                throw new ArgumentNullException(nameof(id));
            }

            var category = await _repository.Get(id);

            if (category == null)
            {
                return(new NotFoundResult());
            }

            _shopCategoryEnricher.Enrich(_halResponseBuilder, category);
            return(new OkObjectResult(_halResponseBuilder.Build()));
        }
Example #15
0
        public async Task <IActionResult> Execute(string id, string subject)
        {
            if (string.IsNullOrWhiteSpace(id))
            {
                throw new ArgumentNullException(nameof(id));
            }

            if (string.IsNullOrWhiteSpace(subject))
            {
                throw new ArgumentNullException(nameof(subject));
            }

            var message = await _messageRepository.Get(id);

            if (message == null)
            {
                return(new NotFoundResult());
            }

            _halResponseBuilder.AddLinks(l => l.AddSelf("/" + Constants.RouteNames.Messages + "/" + id));
            _messageEnricher.Enrich(_halResponseBuilder, message);
            return(new OkObjectResult(_halResponseBuilder.Build()));
        }
Example #16
0
        public async Task <IActionResult> Execute(string shopId, JObject jObj)
        {
            if (string.IsNullOrWhiteSpace(shopId))
            {
                throw new ArgumentNullException(nameof(shopId));
            }

            if (jObj == null)
            {
                throw new ArgumentNullException(nameof(jObj));
            }

            var parameter = _requestBuilder.GetSearchShopComments(jObj);

            parameter.ShopId = shopId;
            var searchResult = await _shopRepository.SearchComments(parameter);

            _halResponseBuilder.AddLinks(l => l.AddSelf(GetCommentLink(shopId)));
            if (searchResult != null && searchResult.Content != null)
            {
                var comments = searchResult.Content;
                foreach (var comment in comments)
                {
                    _commentEnricher.Enrich(_halResponseBuilder, comment, parameter.ShopId);
                }

                double r       = (double)searchResult.TotalResults / (double)parameter.Count;
                var    nbPages = Math.Ceiling(r);
                nbPages = nbPages == 0 ? 1 : nbPages;
                for (var page = 1; page <= nbPages; page++)
                {
                    _halResponseBuilder.AddLinks(l => l.AddOtherItem("navigation", new Dtos.Link(GetCommentLink(shopId), page.ToString())));
                }
            }

            return(new OkObjectResult(_halResponseBuilder.Build()));
        }