Пример #1
0
        private Dictionary <string, string> FormatRequestParameters(
            string continuationToken = null,
            string language          = null,
            string country           = null,
            ContentSource?source     = null)
        {
            Dictionary <string, string> requestParameters = new Dictionary <string, string>();

            if (!string.IsNullOrEmpty(continuationToken))
            {
                requestParameters.Add("continuationToken", continuationToken);
            }

            if (!string.IsNullOrEmpty(language))
            {
                requestParameters.Add("language", language);
            }

            if (!string.IsNullOrEmpty(country))
            {
                requestParameters.Add("country", country);
            }

            if (source.HasValue)
            {
                string sources = source.ToString().Replace(", ", "+");
                requestParameters.Add("source", sources);
            }

            return(requestParameters);
        }
Пример #2
0
 public Task <ContentResponse> LookupAsync(
     List <string> itemIds,
     ContentSource?source = null,
     string language      = null,
     string country       = null,
     ExtraDetails extras  = ExtraDetails.None)
 {
     return(LookupApiAsync(itemIds, source, language, country, extras));
 }
Пример #3
0
 public Task <ContentResponse> SearchAsync(
     MediaNamespace mediaNamespace,
     string query,
     ContentSource?source = null,
     SearchFilter filter  = SearchFilter.Default,
     string language      = null,
     string country       = null,
     int?maxItems         = null)
 {
     return(SearchApiAsync(mediaNamespace, query, source, filter, language, country, maxItems));
 }
Пример #4
0
        private async Task <ContentResponse> SearchApiAsync(
            MediaNamespace mediaNamespace,
            string query         = null,
            ContentSource?source = null,
            SearchFilter filter  =
            SearchFilter.Default,
            string language          = null,
            string country           = null,
            int?maxItems             = null,
            string continuationToken = null)
        {
            Dictionary <string, string> requestParameters = FormatRequestParameters(continuationToken, language, country, source);

            if (!string.IsNullOrEmpty(query))
            {
                requestParameters.Add("q", Uri.EscapeDataString(query));
            }

            if (filter != SearchFilter.Default)
            {
                requestParameters.Add("filters", filter.ToString().Replace(", ", "+"));
            }

            if (maxItems.HasValue)
            {
                requestParameters.Add("maxItems", maxItems.ToString());
            }

            if (_userTokenManager?.UserIsSignedIn == true)
            {
                return(await ApiCallWithUserAuthorizationHeaderRefreshAsync(
                           headers => GetAsync <ContentResponse>(
                               Hostname,
                               $"/1/content/{mediaNamespace}/search",
                               new CancellationToken(false),
                               requestParameters,
                               headers)));
            }
            else
            {
                Dictionary <string, string> requestHeaders = await FormatRequestHeadersAsync(null);

                return(await GetAsync <ContentResponse>(
                           Hostname,
                           $"/1/content/{mediaNamespace}/search",
                           new CancellationToken(false),
                           requestParameters,
                           requestHeaders));
            }
        }
Пример #5
0
        private async Task <ContentResponse> LookupApiAsync(
            IEnumerable <string> itemIds,
            ContentSource?source     = null,
            string language          = null,
            string country           = null,
            ExtraDetails extras      = ExtraDetails.None,
            string continuationToken = null)
        {
            Dictionary <string, string> requestParameters = FormatRequestParameters(continuationToken, language, country, source);

            if (extras != ExtraDetails.None)
            {
                string extra = extras.ToString().Replace(", ", "+");
                requestParameters.Add("extras", extra);
            }

            string ids = itemIds.Aggregate("",
                                           (current, id) =>
                                           current + (!string.IsNullOrEmpty(current) ? "+" : "") + id);

            if (_userTokenManager?.UserIsSignedIn == true)
            {
                return(await ApiCallWithUserAuthorizationHeaderRefreshAsync(
                           headers => GetAsync <ContentResponse>(
                               Hostname,
                               $"/1/content/{ids}/lookup",
                               new CancellationToken(false),
                               requestParameters,
                               headers)));
            }
            else
            {
                Dictionary <string, string> requestHeaders = await FormatRequestHeadersAsync(null);

                return(await GetAsync <ContentResponse>(
                           Hostname,
                           $"/1/content/{ids}/lookup",
                           new CancellationToken(false),
                           requestParameters,
                           requestHeaders));
            }
        }
        private async Task <ContentResponse> SearchApiAsync(Namespace mediaNamespace, string query = null, ContentSource?source = null,
                                                            SearchFilter filter = SearchFilter.Default, string language         = null, string country = null,
                                                            int?maxItems        = null, string continuationToken = null)
        {
            Dictionary <string, string> requestParameters = await FormatRequestParametersAsync(continuationToken, language, country, source);

            if (!String.IsNullOrEmpty(query))
            {
                requestParameters.Add("q", Uri.EscapeDataString(query));
            }
            if (filter != SearchFilter.Default)
            {
                requestParameters.Add("filters", filter.ToString().Replace(", ", "+"));
            }
            if (maxItems.HasValue)
            {
                requestParameters.Add("maxItems", maxItems.ToString());
            }
            return(await GetWithRetryOnExpiredTokenAsync <ContentResponse>("/1/content/" + mediaNamespace + "/search",
                                                                           new CancellationToken(false), requestParameters));
        }
        private async Task <Dictionary <string, string> > FormatRequestParametersAsync(string continuationToken = null,
                                                                                       string language          = null, string country = null, ContentSource?source = null)
        {
            AzureDataMarketAuthenticationCache.AccessToken token = await azureDataMarketAuthenticationCache.CheckAndRenewTokenAsync(new CancellationToken(false));

            Dictionary <string, string> requestParameters = new Dictionary <string, string>
            {
                { "accessToken", Uri.EscapeDataString("Bearer " + token.Token) }
            };

            if (!String.IsNullOrEmpty(continuationToken))
            {
                requestParameters.Add("continuationToken", continuationToken);
            }
            if (!String.IsNullOrEmpty(language))
            {
                requestParameters.Add("language", language);
            }
            if (!String.IsNullOrEmpty(country))
            {
                requestParameters.Add("country", country);
            }
            if (source.HasValue)
            {
                string sources = source.ToString().Replace(", ", "+");
                requestParameters.Add("source", sources);
            }
            return(requestParameters);
        }
        private async Task <ContentResponse> LookupApiAsync(IEnumerable <string> itemIds, ContentSource?source = null,
                                                            string language          = null, string country = null, ExtraDetails extras = ExtraDetails.None,
                                                            string continuationToken = null)
        {
            Dictionary <string, string> requestParameters = await FormatRequestParametersAsync(continuationToken, language, country, source);

            if (extras != ExtraDetails.None)
            {
                string extra = extras.ToString().Replace(", ", "+");
                requestParameters.Add("extras", extra);
            }
            string ids = itemIds.Aggregate("",
                                           (current, id) => current + (!String.IsNullOrEmpty(current) ? "+" : "") + id);

            return(await GetWithRetryOnExpiredTokenAsync <ContentResponse>("/1/content/" + ids + "/lookup", new CancellationToken(false),
                                                                           requestParameters));
        }
Пример #9
0
 /// <summary>
 /// Lookup an item and get details about it.
 /// </summary>
 /// <param name="client">An IXboxMusicClient instance.</param>
 /// <param name="itemId">Id to look up, prefixed by a namespace: {namespace.id}.</param>
 /// <param name="source">The content source: Catalog, Collection or both</param>
 /// <param name="language">ISO 2 letter code.</param>
 /// <param name="country">ISO 2 letter code.</param>
 /// <param name="extras">Enumeration of extra details.</param>
 /// <returns> Content response with details about one or more items.</returns>
 public static Task <ContentResponse> LookupAsync(this IXboxMusicClient client, string itemId, ContentSource?source = null, string language = null,
                                                  string country = null, ExtraDetails extras = ExtraDetails.None)
 {
     return(client.LookupAsync(new List <string> {
         itemId
     }, source, language, country, extras));
 }