예제 #1
0
        public async Task <Currency> GetAsync(string code, CurrencyRequest request)
        {
            Requires.ArgumentNotNull(request, nameof(request));

            var currencyLink = await _linkFactory.CreateLinkAsync($"currencies/{code}").ConfigureAwait(_halClient);

            return(await _halClient.GetAsync <Currency>(currencyLink, request).ConfigureAwait(_halClient));
        }
예제 #2
0
        public async Task <Venue> GetAsync(int venueId, VenueRequest request)
        {
            var root = await _halClient.GetRootAsync().ConfigureAwait(_halClient);

            var venueLink = new Link
            {
                HRef = $"{root.VenuesLink.HRef}/{venueId}"
            };

            return(await _halClient.GetAsync <Venue>(venueLink, request).ConfigureAwait(_halClient));
        }
예제 #3
0
        public async Task <Event> GetAsync(int eventId, EventRequest request)
        {
            Requires.ArgumentNotNull(request, nameof(request));

            var root = await _halClient.GetRootAsync().ConfigureAwait(_halClient);

            var eventsLink = new Link
            {
                HRef = $"{root.SelfLink.HRef}/events/{eventId}"
            };

            return(await _halClient.GetAsync <Event>(eventsLink, request).ConfigureAwait(_halClient));
        }
예제 #4
0
        public async Task <Listing> GetAsync(int listingId, ListingRequest request)
        {
            Requires.ArgumentNotNull(request, nameof(request));

            var root = await _halClient.GetRootAsync().ConfigureAwait(_halClient);

            var listingLink = new Link
            {
                HRef = $"{root.SelfLink.HRef}/listings/{listingId}"
            };

            return(await _halClient.GetAsync <Listing>(listingLink, request).ConfigureAwait(_halClient));
        }
        private static ReadAllPage ReadAllBackwardsInternal(IHalClient client, bool prefetch)
        {
            var resource = client.Current.First();

            var pageInfo = resource.Data <HalReadAllPage>();

            var streamMessages = Convert(
                resource.Embedded
                .Where(r => r.Rel == Constants.Relations.Message)
                .ToArray(),
                client,
                prefetch);

            var readAllPage = new ReadAllPage(
                pageInfo.FromPosition,
                pageInfo.NextPosition,
                pageInfo.IsEnd,
                ReadDirection.Backward,
                async(position, cancellationToken) => ReadAllBackwardsInternal(
                    await client.GetAsync(resource, Constants.Relations.Previous, cancellationToken),
                    prefetch),
                streamMessages);

            return(readAllPage);
        }
예제 #6
0
        public async Task <Category> GetAsync(int categoryId, CategoryRequest request)
        {
            Requires.ArgumentNotNull(request, nameof(request));

            var categoryLink = await _linkFactory.CreateLinkAsync($"categories/{categoryId}").ConfigureAwait(_halClient);

            return(await _halClient.GetAsync <Category>(categoryLink, request).ConfigureAwait(_halClient));
        }
예제 #7
0
        public async Task <User> GetAsync(UserRequest request, CancellationToken cancellationToken)
        {
            var root = await _halClient.GetRootAsync().ConfigureAwait(_halClient);

            return(await _halClient.GetAsync <User>(
                       root.UserLink,
                       request,
                       cancellationToken).ConfigureAwait(_halClient));
        }
예제 #8
0
        private static async Task <ChangedResources <T> > GetChangedResourcesInternalAsync <T>(
            this IHalClient client,
            Link link,
            IDictionary <string, string> parameters,
            IDictionary <string, IEnumerable <string> > headers,
            CancellationToken cancellationToken) where T : Resource
        {
            Requires.ArgumentNotNull(client, nameof(client));
            Requires.ArgumentNotNull(link, nameof(link));

            var currentLink       = link;
            var currentParameters = new Dictionary <string, string>(parameters ?? new Dictionary <string, string>());
            // Increase page-size to reduce the number of round-trips
            var maxPageSize = "10000";

            if (currentParameters.ContainsKey("page_size"))
            {
                currentParameters["page_size"] = maxPageSize;
            }
            else
            {
                currentParameters.Add("page_size", maxPageSize);
            }

            var items        = new List <T>();
            var deletedItems = new List <T>();

            while (true)
            {
                cancellationToken.ThrowIfCancellationRequested();

                var currentPage = await client.GetAsync <PagedResource <T> >(
                    currentLink,
                    currentParameters,
                    headers,
                    cancellationToken).ConfigureAwait(client.Configuration);

                items.AddRange(currentPage.Items);
                if (currentPage.DeletedItems != null)
                {
                    deletedItems.AddRange(currentPage.DeletedItems);
                }

                if (currentPage.NextLink == null)
                {
                    // This is the last page
                    break;
                }

                // Stop passing parameters on subsequent calls since the "next" links
                // will already be assembled with all the parameters needed
                currentParameters = null;
                currentLink       = currentPage.NextLink;
            }

            return(new ChangedResources <T>(items, deletedItems, currentLink));
        }
예제 #9
0
        private static ReadStreamPage ReadStreamBackwardsInternal(
            IHalClient client,
            StreamId streamId,
            int fromVersionInclusive,
            bool prefetchJsonData)
        {
            var resource = client.Current.First();

            if (client.StatusCode == HttpStatusCode.NotFound)
            {
                return(new ReadStreamPage(
                           streamId,
                           PageReadStatus.StreamNotFound,
                           fromVersionInclusive,
                           -1,
                           -1,
                           -1,
                           ReadDirection.Backward,
                           true));
            }

            var pageInfo = resource.Data <HalReadPage>();

            var streamMessages = Convert(
                resource.Embedded
                .Where(r => r.Rel == Constants.Relations.Message)
                .ToArray(),
                client,
                prefetchJsonData);

            var readStreamPage = new ReadStreamPage(
                streamId,
                PageReadStatus.Success,
                pageInfo.FromStreamVersion,
                pageInfo.NextStreamVersion,
                pageInfo.LastStreamVersion,
                pageInfo.LastStreamPosition,
                ReadDirection.Backward,
                pageInfo.IsEnd,
                async(nextVersion, token) => ReadStreamBackwardsInternal(
                    await client.GetAsync(resource, Constants.Relations.Previous),
                    streamId,
                    pageInfo.LastStreamVersion,
                    prefetchJsonData),
                streamMessages);

            return(readStreamPage);
        }
예제 #10
0
        private static ReadStreamPage ReadStreamForwardsInternal(
            IHalClient client,
            StreamId streamId,
            int fromVersionInclusive,
            bool prefetchJsonData)
        {
            var resource = client.Current.First();

            if (client.StatusCode == HttpStatusCode.NotFound)
            {
                return(new ReadStreamPage(
                           streamId,
                           PageReadStatus.StreamNotFound,
                           fromVersionInclusive,
                           -1,
                           -1,
                           -1,
                           ReadDirection.Forward,
                           true));
            }

            var pageInfo = resource.Data <HalReadPage>();

            var streamMessages = Convert(
                resource.Embedded
                .Where(r => r.Rel == Constants.Relations.Message)
                .Reverse()
                .ToArray(),
                client,
                prefetchJsonData);

            var readStreamPage = new ReadStreamPage(
                streamId,
                PageReadStatus.Success,
                pageInfo.FromStreamVersion,
                pageInfo.NextStreamVersion,
                pageInfo.LastStreamVersion,
                pageInfo.LastStreamPosition,
                ReadDirection.Forward,
                pageInfo.IsEnd,
                ReadNextStreamPage,
                streamMessages);

            return(readStreamPage);

            async Task <ReadStreamPage> ReadNextStreamPage(int nextVersion, CancellationToken ct)
            => resource.Links.Any(link => link.Rel == Constants.Relations.Next)
                    ? ReadStreamForwardsInternal(
                await client.GetAsync(resource, Constants.Relations.Next),
                streamId,
                pageInfo.LastStreamVersion,
                prefetchJsonData)
                    : new ReadStreamPage(
                streamId,
                PageReadStatus.Success,
                pageInfo.LastStreamVersion,
                nextVersion,
                pageInfo.LastStreamVersion,
                pageInfo.LastStreamPosition,
                ReadDirection.Forward,
                true,
                ReadNextStreamPage);
        }
예제 #11
0
        public async Task <Webhook> GetAsync(int webhookId, WebhookRequest request)
        {
            var webhookLink = await _linkFactory.CreateLinkAsync($"webhooks/{webhookId}").ConfigureAwait(_halClient);

            return(await _halClient.GetAsync <Webhook>(webhookLink, request).ConfigureAwait(_halClient));
        }
예제 #12
0
        public async Task <Sale> GetAsync(int saleId, SaleRequest request)
        {
            var saleLink = await _linkFactory.CreateLinkAsync($"sales/{saleId}").ConfigureAwait(_halClient);

            return(await _halClient.GetAsync <Sale>(saleLink, request).ConfigureAwait(_halClient));
        }
 public static Task <IHalClient> GetAsync(this IHalClient client, IResource resource, string rel) =>
 client.GetAsync(resource, rel, null, null);
예제 #14
0
        public async Task <Shipments> GetAsync(int saleId, ShipmentRequest request)
        {
            var shipmentsLink = await _linkFactory.CreateLinkAsync($"sales/{saleId}/shipments").ConfigureAwait(_halClient);

            return(await _halClient.GetAsync <Shipments>(shipmentsLink, request).ConfigureAwait(_halClient));
        }
예제 #15
0
        public async Task <SellerListing> GetAsync(int sellerListingId, SellerListingRequest request)
        {
            var listingLink = await _linkFactory.CreateLinkAsync($"sellerlistings/{sellerListingId}").ConfigureAwait(_halClient);

            return(await _halClient.GetAsync <SellerListing>(listingLink, request).ConfigureAwait(_halClient));
        }
 public static Task <IHalClient> GetAsync(
     this IHalClient client,
     IResource resource,
     string rel,
     object parameters) =>
 client.GetAsync(resource, rel, parameters, null);
예제 #17
0
        public async Task <PaymentMethod> GetAsync(int paymentMethodId, PaymentMethodRequest request)
        {
            var paymentMethodLink = await _linkFactory.CreateLinkAsync($"paymentMethods/{paymentMethodId}").ConfigureAwait(_halClient);

            return(await _halClient.GetAsync <PaymentMethod>(paymentMethodLink, request).ConfigureAwait(_halClient));
        }
예제 #18
0
        public async Task <Purchase> GetAsync(int purchaseId, PurchaseRequest request)
        {
            var purchaseLink = await _linkFactory.CreateLinkAsync($"purchases/{purchaseId}").ConfigureAwait(_halClient);

            return(await _halClient.GetAsync <Purchase>(purchaseLink, request).ConfigureAwait(_halClient));
        }
예제 #19
0
 private static async Task <string> GetPayload(
     IHalClient client,
     IResource streamMessage,
     CancellationToken cancellationToken)
 => (await client.GetAsync(streamMessage, Constants.Relations.Self, cancellationToken))
 .Current.FirstOrDefault()?.Data <HttpStreamMessage>()?.Payload?.ToString();
예제 #20
0
        public async Task <Address> GetAsync(int addressId)
        {
            var addressLink = await _linkFactory.CreateLinkAsync($"addresses/{addressId}").ConfigureAwait(_halClient);

            return(await _halClient.GetAsync <Address>(addressLink).ConfigureAwait(_halClient));
        }