public async void GetPagination()
{
var articles = await client.GetItemsAsync(new LimitParameter(2), new SkipParameter(1));
Assert.Equal(2, articles.Pagination.Count);
Assert.Equal(1, articles.Pagination.Skip);
Assert.Equal(2, articles.Pagination.Limit);
Assert.NotNull(articles.Pagination.NextPageUrl);
}
public IEnumerable <IDocument> Execute(IReadOnlyList <IDocument> inputs, IExecutionContext context)
{
var items = _client.GetItemsAsync(QueryParameters).Result;
foreach (var item in items.Items)
{
var metadata = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>("name", item.System.Name),
new KeyValuePair <string, object>("codename", item.System.Codename)
};
foreach (var element in item.Elements)
{
string type = element.Value.type;
var parser = _elementParserFactory.GetParser(type);
parser.ParseMetadata(metadata, element);
}
var content = item.GetString(contentField);
var doc = context.GetDocument(context.GetContentStream(content), metadata);
yield return(doc);
}
}
public void GetItemsAsync()
{
var client = new DeliveryClient(PROJECT_ID);
var response = Task.Run(() => client.GetItemsAsync(new EqualsFilter("system.type", "cafe"))).Result;
Assert.GreaterOrEqual(response.Items.Count, 1);
}
public async void QueryParameters()
{
string url = $"{baseUrl}/items?elements.personas%5Ball%5D=barista%2Ccoffee%2Cblogger&elements.personas%5Bany%5D=barista%2Ccoffee%2Cblogger&system.sitemap_locations%5Bcontains%5D=cafes&elements.product_name=Hario%20V60&elements.price%5Bgt%5D=1000&elements.price%5Bgte%5D=50&system.type%5Bin%5D=cafe%2Ccoffee&elements.price%5Blt%5D=10&elements.price%5Blte%5D=4&elements.country%5Brange%5D=Guatemala%2CNicaragua&depth=2&elements=price%2Cproduct_name&limit=10&order=elements.price%5Bdesc%5D&skip=2&language=en";
mockHttp.When($"{url}").
Respond("application/json", " { 'items': [],'modular_content': {},'pagination': {'skip': 2,'limit': 10,'count': 0,'next_page': ''}}");
DeliveryClient client = InitializeDeliverClientWithACustomeTypeProvider();
var parameters = new IQueryParameter[]
{
new AllFilter("elements.personas", "barista", "coffee", "blogger"),
new AnyFilter("elements.personas", "barista", "coffee", "blogger"),
new ContainsFilter("system.sitemap_locations", "cafes"),
new EqualsFilter("elements.product_name", "Hario V60"),
new GreaterThanFilter("elements.price", "1000"),
new GreaterThanOrEqualFilter("elements.price", "50"),
new InFilter("system.type", "cafe", "coffee"),
new LessThanFilter("elements.price", "10"),
new LessThanOrEqualFilter("elements.price", "4"),
new RangeFilter("elements.country", "Guatemala", "Nicaragua"),
new DepthParameter(2),
new ElementsParameter("price", "product_name"),
new LimitParameter(10),
new OrderParameter("elements.price", SortOrder.Descending),
new SkipParameter(2),
new LanguageParameter("en")
};
var response = await client.GetItemsAsync(parameters);
Assert.Equal(0, response.Items.Count);
}
public async void SecuredProductionAddCorrectHeader()
{
var securityKey = "someKey";
var options = new DeliveryOptions
{
ProjectId = _guid,
UseSecuredProductionApi = true,
SecuredProductionApiKey = securityKey
};
_mockHttp.Expect($"{_baseUrl}/items")
.WithHeaders("Authorization", $"Bearer {securityKey}")
.Respond("application/json", File.ReadAllText(Path.Combine(Environment.CurrentDirectory, "Fixtures\\DeliveryClient\\items.json")));
var mockHttpClient = _mockHttp.ToHttpClient();
var client = new DeliveryClient(options)
{
HttpClient = mockHttpClient
};
await client.GetItemsAsync();
_mockHttp.VerifyNoOutstandingExpectation();
}
public void QueryParameters()
{
var client = new DeliveryClient(PROJECT_ID);
var parameters = new IQueryParameter[]
{
new AllFilter("elements.personas", "barista", "coffee", "blogger"),
new AnyFilter("elements.personas", "barista", "coffee", "blogger"),
new ContainsFilter("system.sitemap_locations", "cafes"),
new EqualsFilter("elements.product_name", "Hario V60"),
new GreaterThanFilter("elements.price", "1000"),
new GreaterThanOrEqualFilter("elements.price", "50"),
new InFilter("system.type", "cafe", "coffee"),
new LessThanFilter("elements.price", "10"),
new LessThanOrEqualFilter("elements.price", "4"),
new RangeFilter("elements.country", "Guatemala", "Nicaragua"),
new DepthParameter(2),
new ElementsParameter("price", "product_name"),
new LimitParameter(10),
new OrderParameter("elements.price", SortOrder.Descending),
new SkipParameter(2)
};
var response = Task.Run(() => client.GetItemsAsync(parameters)).Result;
Assert.AreEqual(0, response.Items.Count);
}
public async void Retries_WithCustomResilencePolicyWithMaxRetrySet_PolicyUsedMaxRetryIgnored()
{
int policyRetryAttempts = 1;
int expectedAttepts = policyRetryAttempts + 1;
int ignoredRetryAttempt = 3;
int actualHttpRequestCount = 0;
_mockHttp.When($"{_baseUrl}/items")
.Respond((request) => GetResponseAndLogRequest(HttpStatusCode.NotImplemented, ref actualHttpRequestCount));
var httpClient = _mockHttp.ToHttpClient();
var mockResilencePolicyProvider = A.Fake <IResiliencePolicyProvider>();
A.CallTo(() => mockResilencePolicyProvider.Policy)
.Returns(Policy.HandleResult <HttpResponseMessage>(result => true).RetryAsync(policyRetryAttempts));
var deliveryOptions = new DeliveryOptions()
{
ProjectId = _guid,
MaxRetryAttempts = ignoredRetryAttempt
};
var client = new DeliveryClient(deliveryOptions)
{
HttpClient = httpClient,
ResiliencePolicyProvider = mockResilencePolicyProvider
};
await Assert.ThrowsAsync <DeliveryException>(async() => await client.GetItemsAsync());
A.CallTo(() => mockResilencePolicyProvider.Policy).MustHaveHappened();
Assert.Equal(expectedAttepts, actualHttpRequestCount);
}
public async void GetItemsAsync()
{
var client = new DeliveryClient(PROJECT_ID);
var response = await client.GetItemsAsync(new EqualsFilter("system.type", "cafe"));
Assert.NotEmpty(response.Items);
}
public async Task <ProjectModel> DeploySampleAsync(string token, Guid subscriptionId)
{
using (HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, $"{KenticoCloudApiUrl}project/sample/undersubscription/{subscriptionId}"))
{
using (HttpResponseMessage response = await GetResponseAsync(token, request))
{
var project = await GetResultAsync <ProjectModel>(response);
if (project != null)
{
var client = new DeliveryClient(project.ProjectId.ToString());
IEnumerable <ContentItem> items;
int i = 0;
do
{
items = (await client.GetItemsAsync()).Items;
i++;
Thread.Sleep(PROJECT_EXISTENCE_VERIFICATION_RETRY_INTERVAL * 1000);
} while (i < PROJECT_EXISTENCE_VERIFICATION_RETRY_COUNT && (items == null || items.Count() < PROJECT_EXISTENCE_VERIFICATION_REQUIRED_ITEMS));
if (items.Count() >= PROJECT_EXISTENCE_VERIFICATION_REQUIRED_ITEMS)
{
return(project);
}
}
throw new DeliveryException(System.Net.HttpStatusCode.NotFound, "There was an error creating the project in Kentico Cloud. Check the project and set its project ID as a \"ProjectId\" environment variable.");
}
}
}
public async Task <ActionResult> Index([FromQuery] Guid itemId, [FromQuery] string originalAction, [FromQuery] string itemType, [FromQuery] string originalController, [FromQuery] string language)
{
var translatedController = await _localizedRoutingProvider.ProvideRouteAsync(language, originalController, originalController, ProvideRouteType.OriginalToTranslated);
var tranclatedAction = await _localizedRoutingProvider.ProvideRouteAsync(language, originalAction, originalController, ProvideRouteType.OriginalToTranslated);
if (tranclatedAction == null || translatedController == null)
{
return(NotFound());
}
// Specific item is not selected, url will not be changed after redirect
if (itemId == Guid.Empty || string.IsNullOrEmpty(itemType))
{
return(RedirectToAction(tranclatedAction, translatedController, new { culture = language }));
}
var item = (await DeliveryClient.GetItemsAsync <object>(
new SystemTypeEqualsFilter(itemType),
new EqualsFilter("system.id", itemId.ToString()),
new LanguageParameter(language),
new ElementsParameter("url_pattern"))).Items.FirstOrDefault();
if (!(item is IDetailItem detaiItem))
{
return(NotFound());
}
return(RedirectToAction(tranclatedAction, translatedController, new { culture = language, urlSlug = detaiItem.UrlPattern }));
}
/// <summary>
/// Returns strongly typed content items that match the optional filtering parameters. By default, retrieves one level of linked items.
/// </summary>
/// <typeparam name="T">Type of the model. (Or <see cref="object" /> if the return type is not yet known.)</typeparam>
/// <param name="parameters">A collection of query parameters, for example, for filtering, ordering, or setting the depth of linked items.</param>
/// <returns>The <see cref="DeliveryItemListingResponse{T}" /> instance that contains the content items. If no query parameters are specified, all content items are returned.</returns>
public async Task <DeliveryItemListingResponse <T> > GetItemsAsync <T>(IEnumerable <IQueryParameter> parameters)
{
var queryParameters = parameters?.ToList();
return(await CacheManager.GetOrAddAsync(
CacheHelper.GetItemsTypedKey(queryParameters),
() => DeliveryClient.GetItemsAsync <T>(queryParameters),
response => response.Items.Any()));
}
public async Task <ActionResult> Detail(string codename, string location)
{
ViewBag.location = location;
DeliveryItemListingResponse <Speaker> response = await DeliveryClient.GetItemsAsync <Speaker>(
new EqualsFilter("system.codename", codename)
);
return(View(response.Items[0]));
}
public async Task <ActionResult> Index(string location)
{
ViewBag.location = location;
DeliveryItemListingResponse <Speaker> response = await DeliveryClient.GetItemsAsync <Speaker>(
new EqualsFilter("system.type", "speaker")
);
return(View(response.Items));
}
public async Task <ViewResult> Index(string location)
{
ViewBag.location = location;
DeliveryItemListingResponse <Registration> response = await DeliveryClient.GetItemsAsync <Registration>(
new EqualsFilter("system.type", "registration")
);
return(View(response.Items[0]));
}
public async Task <ActionResult> Detail(string id, string location)
{
ViewBag.location = location;
DeliveryItemListingResponse <Speaker> response = await DeliveryClient.GetItemsAsync <Speaker>(
new EqualsFilter("elements.speaker_id", id)
);
return(View(response.Items[0]));
}
public async Task <ViewResult> Index()
{
var response = await DeliveryClient.GetItemsAsync <Article>(
new LimitParameter(3),
new DepthParameter(0),
new OrderParameter("elements.post_date")
);
return(View(response.Items));
}
public async Task <ViewResult> Index()
{
var response = await DeliveryClient.GetItemsAsync <Location>(
new EqualsFilter("system.type", "location"),
new EqualsFilter("system.language", Language),
new LanguageParameter(Language),
new DepthParameter(0)
);
return(View(response.Items));
}
public async Task <ActionResult> Index(string location)
{
ViewBag.location = location;
DeliveryItemListingResponse <Venue> response = await DeliveryClient.GetItemsAsync <Venue>(
new EqualsFilter("system.type", "venue"),
new ContainsFilter("elements.location", location.ToLower())
);
return(View(response.Items));
}
public void CastContentItems()
{
// Arrange
var client2 = new DeliveryClient(SANDBOX_PROJECT_ID);
// Act
DeliveryItemListingResponse response = client2.GetItemsAsync().Result;
IEnumerable <CompleteContentItemModel> list = response.Items.Where(i => i.System.Type == "complete_content_type").Select(a => a.CastTo <CompleteContentItemModel>());
// Assert
Assert.True(list.Any());
}
public async void GetItemsAsync()
{
mockHttp.When($"{baseUrl}/items").
WithQueryString("system.type=cafe").
Respond("application/json", File.ReadAllText(Path.Combine(AppContext.BaseDirectory, "Fixtures\\DeliveryClient\\allendale.json")));
DeliveryClient client = InitializeDeliverClientWithACustomeTypeProvider();
var response = await client.GetItemsAsync(new EqualsFilter("system.type", "cafe"));
Assert.NotEmpty(response.Items);
}
public void CastListingResponse()
{
// Arrange
var client2 = new DeliveryClient(SANDBOX_PROJECT_ID);
// Act
var response = client2.GetItemsAsync().Result;
var stronglyTypedListingResponse = response.CastTo <CompleteContentItemModel>();
// Assert
Assert.NotNull(stronglyTypedListingResponse);
Assert.True(stronglyTypedListingResponse.Items.Any());
}
public async Task <ActionResult> Detail(string urlSlug, string location)
{
ViewBag.location = location;
DeliveryItemListingResponse <AgendaItem> response = await DeliveryClient.GetItemsAsync <AgendaItem>(
new EqualsFilter("system.type", "agenda_item"),
new ContainsFilter("elements.location", location.ToLower()),
new EqualsFilter("elements.url_slug", urlSlug),
new DepthParameter(2)
);
return(View(response.Items[0]));
}
public async Task <List <BlogPost> > GetBlogPosts()
{
List <BlogPost> lstBlogPosts = new List <BlogPost>();
try
{
var response = await client.GetItemsAsync <BlogPost>(
new EqualsFilter("system.type", BlogPost.Codename),
new ElementsParameter(BlogPost.TitleCodename, BlogPost.DateCodename, BlogPost.AuthorCodename, BlogPost.UrlSlugCodename, BlogPost.HeaderImageCodename, BlogPost.TopicCodename, BlogPost.PerexCodename),
new LimitParameter(10),
new OrderParameter("elements." + BlogPost.DateCodename, SortOrder.Descending)
);
foreach (BlogPost blog in response.Items)
{
lstBlogPosts.Add(blog);
}
}
catch (Exception)
{
}
return(lstBlogPosts);
}
public void CastContentItems()
{
const string SANDBOX_PROJECT_ID = "e1167a11-75af-4a08-ad84-0582b463b010";
// Arrange
var client = new DeliveryClient(SANDBOX_PROJECT_ID);
// Act
DeliveryItemListingResponse response = client.GetItemsAsync().Result;
IEnumerable <CompleteContentItemModel> list = response.Items.Where(i => i.System.Type == "complete_content_type").Select(a => a.CastTo <CompleteContentItemModel>());
// Assert
Assert.True(list.Any());
}
public async Task <ActionResult> Index(string location)
{
ViewBag.location = location;
var response = await DeliveryClient.GetItemsAsync <Home>(
new EqualsFilter("system.type", "home"),
new ContainsFilter("elements.location", location.ToLower())
);
var item = response.Items[0];
item.EditURL = base.GetEditURL(item.System.Language, item.System.Id);
return(View(item));
}
public void CastListingResponse()
{
const string SANDBOX_PROJECT_ID = "e1167a11-75af-4a08-ad84-0582b463b010";
// Arrange
var client = new DeliveryClient(SANDBOX_PROJECT_ID);
// Act
var response = client.GetItemsAsync().Result;
var stronglyTypedListingResponse = response.CastTo <CompleteContentItemModel>();
// Assert
Assert.NotNull(stronglyTypedListingResponse);
Assert.True(stronglyTypedListingResponse.Items.Any());
}
public async Task <DeliveryItemListingResponse <T> > GetItemsAsync <T>(IEnumerable <IQueryParameter> parameters)
{
var identifierTokens = new List <string> {
KenticoCloudCacheHelper.CONTENT_ITEM_LISTING_TYPED_IDENTIFIER
};
identifierTokens.AddNonNullRange(KenticoCloudCacheHelper.GetIdentifiersFromParameters(parameters));
return(await CacheManager.GetOrCreateAsync(
identifierTokens,
() => DeliveryClient.GetItemsAsync <T>(parameters),
response => response.Items.Count <= 0,
GetContentItemListingDependencies,
ProjectOptions.CreateCacheEntriesInBackground));
}
public async void GetPagination()
{
mockHttp.When($"{baseUrl}/items").
WithQueryString("limit=2&skip=1").
Respond("application/json", File.ReadAllText(Path.Combine(AppContext.BaseDirectory, "Fixtures\\DeliveryClient\\articles.json")));
DeliveryClient client = InitializeDeliverClientWithACustomeTypeProvider();
var articles = await client.GetItemsAsync(new LimitParameter(2), new SkipParameter(1));
Assert.Equal(2, articles.Pagination.Count);
Assert.Equal(1, articles.Pagination.Skip);
Assert.Equal(2, articles.Pagination.Limit);
Assert.NotNull(articles.Pagination.NextPageUrl);
}
public async Task <ActionResult> Index(string id, string location)
{
ViewBag.location = location;
DeliveryItemListingResponse <AgendaBlock> response = await DeliveryClient.GetItemsAsync <AgendaBlock>(
new EqualsFilter("system.type", "agenda_block"),
new ContainsFilter("elements.location", location.ToLower()),
new DepthParameter(4)
);
var item = response.Items[0];
item.EditURL = base.GetEditURL(item.System.Language, item.System.Id);
return(View(item));
}
public async Task <ActionResult> Index()
{
DeliveryItemListingResponse <Home> response = await DeliveryClient.GetItemsAsync <Home>(
new EqualsFilter("system.type", "home")
);
if (response.Items.Count > 1)
{
return(View(response.Items));
}
else
{
var loc = response.Items.First().Location.First().Name;
return(RedirectToAction("Index", "Home", new { location = loc }));
}
}
