Esempio n. 1
0
        private async Task <List <ContentItemIdentifier> > GetAllUserItemIdentifiers()
        {
            List <ContentItemIdentifier>            listIds  = new List <ContentItemIdentifier>();
            ListingResponseModel <ContentItemModel> response = await managementClient.ListContentItemsAsync();

            // this is guid of Content Type "User" in the KC project
            ObjectIdentifier userContentType = new ObjectIdentifier()
            {
                Id = Guid.Parse("eaf7e4c9-0a4d-46dc-b787-ef02c9860592")
            };

            while (true)
            {
                foreach (var item in response)
                {
                    if (item.Type == userContentType)
                    {
                        listIds.Add(ContentItemIdentifier.ById(item.Id));
                    }
                }

                if (!response.HasNextPage())
                {
                    break;
                }
                response = await response.GetNextPage();
            }

            return(listIds);
        }
Esempio n. 2
0
        private async Task DeleteAllItems(List <ContentItemModel> contentItems)
        {
            var allTasks  = new List <Task>();
            var throttler = new SemaphoreSlim(initialCount: 2);

            foreach (var item in contentItems)
            {
                await throttler.WaitAsync();

                allTasks.Add(
                    Task.Run(async() =>
                {
                    try
                    {
                        logger.Info("Deleting item:" + item.Id);
                        await managementClient.DeleteContentItemAsync(ContentItemIdentifier.ById(item.Id));
                    }
                    catch (KenticoCloud.ContentManagement.Exceptions.ContentManagementException e)
                    {
                        logger.Error(e, "Something went wrong deleting item.");
                    }
                    finally
                    {
                        throttler.Release();
                    }
                }));
            }

            await Task.WhenAll(allTasks);
        }
Esempio n. 3
0
        internal async Task <ContentItemVariantModel <UserModel> > CreateUser(IntercomUser user)
        {
            string itemName;

            if (user.Type == "admin")
            {
                itemName = user.Name;
            }
            else
            {
                itemName = user.Id;
            }

            var userItem = await CreateUserItem(itemName, user.Id);

            UserModel userModel = new UserModel
            {
                Name         = user.Name,
                Type         = user.Type,
                Email        = user.Email,
                Id           = user.Id,
                IntercomLink = "<p><a href=\"" + IntercomFunctions.GetIntercomUserLink(user.Id, user.Type) + "\">Link to intercom</a></p>"
            };

            var userVariant = await CreateUserVariant(userModel, ContentItemIdentifier.ById(userItem.Id));

            var publishUser = await PublishItemVariant(userItem.Id.ToString());

            return(userVariant);
        }
Esempio n. 4
0
        internal async Task <ContentItemVariantModel <UserModel> > TryGetExistingUserVariant(string userId)
        {
            if (!userItemVariants.ContainsKey(userId))
            {
                ContentItemVariantModel <UserModel> userVariant = null;
                try
                {
                    ContentItemIdentifier        userItemIdentifier = ContentItemIdentifier.ByExternalId(userId);
                    ContentItemVariantIdentifier variantIdentifier  = new ContentItemVariantIdentifier(userItemIdentifier, LanguageIdentifier.DEFAULT_LANGUAGE);
                    userVariant = await GetUserVariant(variantIdentifier);

                    logger.Debug("Downloaded existing user variant: " + userVariant.Elements.Name);
                    userItemVariants.Add(userVariant.Elements.Id, userVariant);
                }
                catch (ContentManagementException e)
                {
                    if (e.StatusCode != HttpStatusCode.NotFound)
                    {
                        throw e;
                    }

                    return(null);
                }
            }
            return(userItemVariants[userId]);
        }
Esempio n. 5
0
        public void BuildItemUrl_ItemExternalId_ReturnsCorrectUrl()
        {
            var identifier  = ContentItemIdentifier.ByExternalId(ITEM_EXTERNAL_ID);
            var actualUrl   = _builder.BuildItemUrl(identifier);
            var expectedUrl = $"{ENDPOINT}/projects/{PROJECT_ID}/items/external-id/{EXPECTED_ITEM_EXTERNAL_ID}";

            Assert.Equal(expectedUrl, actualUrl);
        }
        public void BuildListVariantsUrl_ItemId_ReturnsCorrectUrl()
        {
            var identifier  = ContentItemIdentifier.ById(ITEM_ID);
            var actualUrl   = _builder.BuildListVariantsUrl(identifier);
            var expectedUrl = $"{ENDPOINT}/projects/{PROJECT_ID}/items/{ITEM_ID}/variants";

            Assert.Equal(expectedUrl, actualUrl);
        }
Esempio n. 7
0
        public void BuildItemUrl_ItemCodename_ReturnsCorrectUrl()
        {
            var identifier  = ContentItemIdentifier.ByCodename(ITEM_CODENAME);
            var actualUrl   = _builder.BuildItemUrl(identifier);
            var expectedUrl = $"{ENDPOINT}/projects/{PROJECT_ID}/items/codename/{ITEM_CODENAME}";

            Assert.Equal(expectedUrl, actualUrl);
        }
Esempio n. 8
0
        public void BuildContentItemVariantsUrl_ItemCodenameVariantCodename_ReturnsCorrectUrl()
        {
            var itemIdentifier    = ContentItemIdentifier.ByCodename(ITEM_CODENAME);
            var variantIdentifier = LanguageIdentifier.ByCodename(VARIANT_CODENAME);
            var identifier        = new ContentItemVariantIdentifier(itemIdentifier, variantIdentifier);
            var actualUrl         = _builder.BuildVariantsUrl(identifier);
            var expectedUrl       = $"{ENDPOINT}/projects/{PROJECT_ID}/items/codename/{ITEM_CODENAME}/variants/codename/{VARIANT_CODENAME}";

            Assert.Equal(expectedUrl, actualUrl);
        }
Esempio n. 9
0
        public void BuildContentItemVariantsUrl_ItemExternalIdVariantId_ReturnsCorrectUrl()
        {
            var itemIdentifier    = ContentItemIdentifier.ByExternalId(ITEM_EXTERNAL_ID);
            var variantIdentifier = LanguageIdentifier.ById(VARIANT_ID);
            var identifier        = new ContentItemVariantIdentifier(itemIdentifier, variantIdentifier);
            var actualUrl         = _builder.BuildVariantsUrl(identifier);
            var expectedUrl       = $"{ENDPOINT}/projects/{PROJECT_ID}/items/external-id/{EXPECTED_ITEM_EXTERNAL_ID}/variants/{VARIANT_ID}";

            Assert.Equal(expectedUrl, actualUrl);
        }
        /// <summary>
        /// Deletes given content item.
        /// </summary>
        /// <param name="identifier">The identifier of the content item.</param>
        public async Task DeleteContentItemAsync(ContentItemIdentifier identifier)
        {
            if (identifier == null)
            {
                throw new ArgumentNullException(nameof(identifier));
            }

            var endpointUrl = _urlBuilder.BuildItemUrl(identifier);

            await _actionInvoker.InvokeMethodAsync(endpointUrl, HttpMethod.Delete);
        }
        /// <summary>
        /// Returns strongly typed content item.
        /// </summary>
        /// <param name="identifier">The identifier of the content item.</param>
        /// <returns>The <see cref="ContentItemModel"/> instance that represents requested content item.</returns>
        public async Task <ContentItemModel> GetContentItemAsync(ContentItemIdentifier identifier)
        {
            if (identifier == null)
            {
                throw new ArgumentNullException(nameof(identifier));
            }

            var endpointUrl = _urlBuilder.BuildItemUrl(identifier);
            var response    = await _actionInvoker.InvokeReadOnlyMethodAsync <ContentItemModel>(endpointUrl, HttpMethod.Get);

            return(response);
        }
Esempio n. 12
0
        internal static async Task <ContentItemVariantModel> PrepareTestVariant(ContentManagementClient client, string languageCodename, object elements, ContentItemModel item)
        {
            var addedItemIdentifier                = ContentItemIdentifier.ByCodename(item.CodeName);
            var addedLanguageIdentifier            = LanguageIdentifier.ByCodename(languageCodename);
            var addedContentItemLanguageIdentifier = new ContentItemVariantIdentifier(addedItemIdentifier, addedLanguageIdentifier);
            var variantUpdateModel = new ContentItemVariantUpsertModel()
            {
                Elements = elements
            };

            return(await client.UpsertContentItemVariantAsync(addedContentItemLanguageIdentifier, variantUpdateModel));
        }
Esempio n. 13
0
        private ConversationModel CreateConversationModel(Conversation conversation)
        {
            var    messages = CreateRichTextCompatibleConversationString(conversation);
            var    tags     = CreateTagsString(conversation);
            string intercomConversationLinkRichText = "<p><a href=\"" + IntercomFunctions.GetIntercomConversationLink(conversation) + "\">Link to intercom</a></p>";

            List <ContentItemIdentifier> assignees = new List <ContentItemIdentifier>()
            {
            };
            List <ContentItemIdentifier> author = new List <ContentItemIdentifier>()
            {
            };

            if (conversation.assignee.id != null) //unassigned conversation
            {
                assignees.Add(ContentItemIdentifier.ByExternalId(currentConversationUsers
                                                                 .Where(x => x.Id.Equals(conversation.assignee.id, StringComparison.OrdinalIgnoreCase))
                                                                 .FirstOrDefault()
                                                                 .Id));
            }

            author.Add(ContentItemIdentifier.ByExternalId(currentConversationUsers
                                                          .Where(x => x.Id.Equals(conversation.conversation_message.author.id, StringComparison.OrdinalIgnoreCase))
                                                          .FirstOrDefault()
                                                          .Id));

            ConversationModel conversationModel = new ConversationModel
            {
                IntercomLink = intercomConversationLinkRichText,
                Author       = author,
                CreatedAt    = Tools.FromUnixTimestamp(conversation.created_at),
                LastUpdated  = Tools.FromUnixTimestamp(conversation.updated_at),
                Assignee     = assignees,
                Messages     = messages,
                RatingValue  = conversation.conversation_rating.rating,
                RatingNote   = conversation.conversation_rating.remark,
                Tags         = tags,
                SearchBody   = CreateSearchBody(conversation),

                /*Participants = userItemVariants
                 *  .Where(userReferences => participants.Any(participant => participant.Id.Equals(userReferences.Key, StringComparison.OrdinalIgnoreCase)))
                 *  .Select(userReference => userReference.Value)
                 *  .ToList(),*/
                Participants = currentConversationUsers
                               .Select(x => ContentItemIdentifier.ByExternalId(x.Id))
                               .ToList(),
                MessageCount   = IntercomFunctions.GetConversationMessageCount(conversation),
                ConversationId = conversation.id
            };

            return(conversationModel);
        }
Esempio n. 14
0
        public static (ContentItemIdentifier, LanguageIdentifier, ContentItemVariantIdentifier) GetIdentifiers(string ContentItemCodeName)
        {
            //Retrieive an ItemIdentifier by codename of the content item we want to create a new version of
            ContentItemIdentifier itemIdentifier = ContentItemIdentifier.ByCodename(ContentItemCodeName);

            //Retreive the language identifier of the content item in Konent for the content item (even if we only have one)
            LanguageIdentifier langIdentifier = LanguageIdentifier.ByCodename(RowlingAppConstants.DefaultLanguageCode);

            //Retreive the content item language variant of the content item we want to update (the real unique identifier)
            ContentItemVariantIdentifier identifier = new ContentItemVariantIdentifier(itemIdentifier, langIdentifier);

            return(itemIdentifier, langIdentifier, identifier);
        }
        /// <summary>
        /// Updates given content item.
        /// </summary>
        /// <param name="identifier">The identifier of the content item.</param>
        /// <param name="contentItem">Represents updated content item.</param>
        /// <returns>The <see cref="ContentItemModel"/> instance that represents updated content item.</returns>
        public async Task <ContentItemModel> UpdateContentItemAsync(ContentItemIdentifier identifier, ContentItemUpdateModel contentItem)
        {
            if (identifier == null)
            {
                throw new ArgumentNullException(nameof(identifier));
            }

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

            var endpointUrl = _urlBuilder.BuildItemUrl(identifier);
            var response    = await _actionInvoker.InvokeMethodAsync <ContentItemUpdateModel, ContentItemModel>(endpointUrl, HttpMethod.Put, contentItem);

            return(response);
        }
Esempio n. 16
0
        public async Task <string> UpsertTaxonomy(Movie movie, string listing_prediction)
        {
            MovieImport stronglyTypedElements = new MovieImport
            {
                ListedIn = new[] { TaxonomyTermIdentifier.ByCodename(listing_prediction) }
            };

            // Specifies the content item and the language variant
            ContentItemIdentifier        itemIdentifier     = ContentItemIdentifier.ByCodename(movie.System.Codename);
            LanguageIdentifier           languageIdentifier = LanguageIdentifier.ByCodename(movie.System.Language);
            ContentItemVariantIdentifier identifier         = new ContentItemVariantIdentifier(itemIdentifier, languageIdentifier);

            // Upserts a language variant of your content item
            ContentItemVariantModel <MovieImport> response = await client.UpsertContentItemVariantAsync(identifier, stronglyTypedElements);

            return(response.Elements.Title + " updated.");
        }
        /// <summary>
        /// Inserts or updates content item according to external identifier.
        /// </summary>
        /// <param name="externalId">The external identifier of the content item.</param>
        /// <param name="contentItem">Represents inserted or updated content item.</param>
        /// <returns>The <see cref="ContentItemModel"/> instance that represents inserted or updated content item.</returns>
        public async Task <ContentItemModel> UpsertContentItemByExternalIdAsync(string externalId, ContentItemUpsertModel contentItem)
        {
            if (string.IsNullOrEmpty(externalId))
            {
                throw new ArgumentException("The external id is not specified.", nameof(externalId));
            }

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

            var endpointUrl = _urlBuilder.BuildItemUrl(ContentItemIdentifier.ByExternalId(externalId));
            var response    = await _actionInvoker.InvokeMethodAsync <ContentItemUpsertModel, ContentItemModel>(endpointUrl, HttpMethod.Put, contentItem);

            return(response);
        }
        private string GetItemUrlSegment(ContentItemIdentifier identifier)
        {
            if (identifier.Id != null)
            {
                return(string.Format(URL_TEMPLATE_ITEM_ID, identifier.Id));
            }

            if (!string.IsNullOrEmpty(identifier.Codename))
            {
                return(string.Format(URL_TEMPLATE_ITEM_CODENAME, identifier.Codename));
            }

            if (!string.IsNullOrEmpty(identifier.ExternalId))
            {
                return(BuildItemUrlSegmentFromExternalId(identifier.ExternalId));
            }
            throw new ArgumentException("You must provide item's id, codename or externalId");
        }
Esempio n. 19
0
        private static void ImportMovies(string folderPath, ContentManagementClient client)
        {
            foreach (var movie in DatabaseEntry.CreateFromFolder(Path.Combine(folderPath, "Movies")))
            {
                Console.WriteLine($"Importing {movie.GetText("Name")}");

                var imageExternalIds = ImportMoviePhotos(movie, folderPath, client);

                var externalId = $"Movie - {movie.ExternalId}";

                var item = new ContentItemUpsertModel
                {
                    Name             = movie.GetText("Name"),
                    Type             = ContentTypeIdentifier.ByCodename("movie"),
                    SitemapLocations = movie.GetListItems("Sitemap location").Select(x => SitemapNodeIdentifier.ByCodename(GetCodename(x)))
                };

                client.UpsertContentItemByExternalIdAsync(externalId, item);

                var itemIdentifier     = ContentItemIdentifier.ByExternalId(externalId);
                var languageIdentifier = LanguageIdentifier.DEFAULT_LANGUAGE;

                var variant = new ContentItemVariantUpsertModel
                {
                    Elements = new
                    {
                        name         = movie.GetText("Name"),
                        description  = movie.GetText("Description"),
                        synopsis     = movie.GetText("Synopsis"),
                        release_date = movie.GetDateTime("Release date"),
                        genre        = movie.GetListItems("Genres").Select(x => TaxonomyTermIdentifier.ByCodename(GetCodename(x))),
                        cast         = movie.GetListItems("Cast").Select(x => ContentItemIdentifier.ByExternalId($"Actor - {x}")),
                        imdb_rating  = movie.GetNumber("IMDB rating"),
                        rating       = new [] { MultipleChoiceOptionIdentifier.ByCodename(GetCodename(movie.GetText("Rating"))) },
                        slug         = movie.GetText("Slug"),
                        photos       = imageExternalIds.Select(imageExternalId => AssetIdentifier.ByExternalId(imageExternalId))
                    },
                };

                client.UpsertContentItemVariantAsync(new ContentItemVariantIdentifier(itemIdentifier, languageIdentifier), variant);
            }
        }
Esempio n. 20
0
        internal async Task <(ContentItemVariantModel <ConversationModel> variant, bool success)> SyncSingle(Conversation intercomConversation, ContentItemVariantModel <ConversationModel> conversationVariant, List <ContentItemVariantModel <UserModel> > conversationUserVariants)
        {
            currentConversationId    = intercomConversation.id;
            currentConversationUsers = new List <UserModel>()
            {
            };
            currentConversationUsers.AddRange(conversationUserVariants.Select(x => x.Elements));

            ContentItemModel conversationItem = null;
            Guid             itemIdentifier   = Guid.Empty;

            // If conversation doesn't exist, create item for it
            if (conversationVariant == null)
            {
                try
                {
                    logger.Debug("Creating item for conversation: " + currentConversationId);
                    conversationItem = await CreateConversationItem(currentConversationId);

                    itemIdentifier = conversationItem.Id;
                }
                catch (ContentManagementException e)
                {
                    logger.Error(e, "Unable to create item for conversation: " + currentConversationId);
                    return(null, false);
                }
            }
            else
            {
                itemIdentifier = conversationVariant.Item.Id;
            }

            // Fill model with data
            var model = CreateConversationModel(intercomConversation);

            logger.Debug("Creating item variant for conversation: " + currentConversationId);
            var variant = await UpsertConversationVariant(model, ContentItemIdentifier.ById(itemIdentifier));

            var publishConversation = await PublishItemVariant(itemIdentifier.ToString());

            return(variant, true);
        }
Esempio n. 21
0
        public async static Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req, TraceWriter log, ExecutionContext context)
        {
            try
            {
                var config = new ConfigurationBuilder()
                             .SetBasePath(context.FunctionAppDirectory)
                             .AddJsonFile("local.settings.json", optional: true, reloadOnChange: true)
                             .AddEnvironmentVariables()
                             .Build();


                string strLanguageCode = config["KenticoCloudLanguageCode"];

                ContentManagementOptions options = new ContentManagementOptions
                {
                    ProjectId = config["KenticoCloudProjectID"],
                    ApiKey    = config["KenticoCloudContentManagementAPIKey"]
                };

                // Initializes an instance of the ContentManagementClient client
                ContentManagementClient client = new ContentManagementClient(options);

                // Defines the content elements to update
                Task <string> body = new StreamReader(req.Body).ReadToEndAsync();

                ArticleModel NewArticleModel = JsonConvert.DeserializeObject <ArticleModel>(body.Result.ToString());

                // Specifies the content item and the language variant
                ContentItemIdentifier        itemIdentifier     = ContentItemIdentifier.ByCodename(NewArticleModel.OriginalCodename);
                LanguageIdentifier           languageIdentifier = LanguageIdentifier.ByCodename(strLanguageCode);
                ContentItemVariantIdentifier identifier         = new ContentItemVariantIdentifier(itemIdentifier, languageIdentifier);

                // Upserts a language variant of your content item
                ContentItemVariantModel <Article> responseUpdate = await client.UpsertContentItemVariantAsync <Article>(identifier, NewArticleModel.NewArticle);

                return((ActionResult) new OkObjectResult($"SUCCESS: Language variant added!"));
            }
            catch (Exception ex)
            {
                return(new OkObjectResult("FAILURE: " + ex.Message));
            }
        }
Esempio n. 22
0
        internal async Task DeleteItems(List <string> externalIds)
        {
            foreach (var itemId in externalIds)
            {
                try
                {
                    await managementClient.DeleteContentItemAsync(ContentItemIdentifier.ByExternalId(itemId));

                    //processedItems.Add(itemId, true);
                }
                catch (Exception e)
                {
                    logger.Error(e, "Deleting of item " + itemId + "failed.");
                }
                finally
                {
                    //processedItems.Add(itemId, false);
                }
            }
        }
Esempio n. 23
0
        private async Task <List <ContentItemIdentifier> > GetAllItemIdentifiers()
        {
            List <ContentItemIdentifier>            listIds  = new List <ContentItemIdentifier>();
            ListingResponseModel <ContentItemModel> response = await managementClient.ListContentItemsAsync();

            while (true)
            {
                foreach (var item in response)
                {
                    listIds.Add(ContentItemIdentifier.ById(item.Id));
                }

                if (!response.HasNextPage())
                {
                    break;
                }
                response = await response.GetNextPage();
            }

            return(listIds);
        }
Esempio n. 24
0
        /// <summary>
        /// Adds language variant content to the content item with the supplied codename
        /// </summary>
        /// <param name="codename">Codename of the content item needed</param>
        /// <returns></returns>
        public async Task <Guid> CreateItemVariantAsync(string codename)
        {
            const string htmlMarkup = @"<h1>Some content</h1>
                        <p>This is the content</p>";

            if (!IsValidHtml(htmlMarkup))
            {
                return(Guid.Empty);
            }

            var content = new SimplePage
            {
                PageTitle   = "Test import",
                PageContent = htmlMarkup,
                DishColour  = new[]
                {
                    TaxonomyTermIdentifier.ByCodename("green")
                },
                PageTeaser = new AssetIdentifier[0]
            };

            // Specifies the content item and the language variant
            ContentItemIdentifier        itemIdentifier     = ContentItemIdentifier.ByCodename(codename);
            LanguageIdentifier           languageIdentifier = LanguageIdentifier.DEFAULT_LANGUAGE;
            ContentItemVariantIdentifier identifier         = new ContentItemVariantIdentifier(itemIdentifier: itemIdentifier, languageIdentifier: languageIdentifier);

            // Upserts a language variant of your content item
            try
            {
                ContentItemVariantModel <SimplePage> response = await _managementClient.UpsertContentItemVariantAsync <SimplePage>(identifier, content);

                return(response.Item.Id);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"ERROR: {ex.Message}");
                return(Guid.Empty);
            }
        }
Esempio n. 25
0
        private static void ImportActors(string folderPath, ContentManagementClient client)
        {
            foreach (var actor in DatabaseEntry.CreateFromFolder(Path.Combine(folderPath, "Actors")))
            {
                Console.WriteLine($"Importing {actor.GetText("Name")}");

                var imageExternalId = ImportActorPhoto(actor, folderPath, client);

                var externalId = $"Actor - {actor.ExternalId}";

                var item = new ContentItemUpsertModel
                {
                    Name = actor.GetText("Name"),
                    Type = ContentTypeIdentifier.ByCodename("actor"),
                };

                client.UpsertContentItemByExternalIdAsync(externalId, item);

                var itemIdentifier     = ContentItemIdentifier.ByExternalId(actor.ExternalId);
                var languageIdentifier = LanguageIdentifier.DEFAULT_LANGUAGE;

                var variant = new ContentItemVariantUpsertModel
                {
                    Elements = new
                    {
                        name  = actor.GetText("Name"),
                        born  = actor.GetDateTime("Born"),
                        bio   = actor.GetText("Bio"),
                        photo = new [] { AssetIdentifier.ByExternalId(imageExternalId) }
                    },
                };

                client.UpsertContentItemVariantAsync(
                    new ContentItemVariantIdentifier(itemIdentifier, languageIdentifier),
                    variant
                    );
            }
        }
Esempio n. 26
0
        /// <summary>
        /// Updates the given content item.
        /// </summary>
        /// <param name="client">Content management client instance.</param>
        /// <param name="identifier">Identifies which content item will be updated. </param>
        /// <param name="contentItem">Specifies data for updated content item.</param>
        /// <returns>The <see cref="ContentItemModel"/> instance that represents updated content item.</returns>
        public static async Task <ContentItemModel> UpdateContentItemAsync(this ContentManagementClient client, ContentItemIdentifier identifier, ContentItemModel contentItem)
        {
            if (identifier == null)
            {
                throw new ArgumentNullException(nameof(identifier));
            }

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

            var contentItemUpdateModel = new ContentItemUpdateModel(contentItem);

            return(await client.UpdateContentItemAsync(identifier, contentItemUpdateModel));
        }
        /// <summary>
        /// Returns strongly typed listing of content item variants with strongly typed elements for specified content item.
        /// </summary>
        /// <typeparam name="T">Type of the content item elements</typeparam>
        /// <param name="identifier">The identifier of the content item.</param>
        /// <returns>A strongly-typed collection with content item variants.</returns>
        public async Task <List <ContentItemVariantModel <T> > > ListContentItemVariantsAsync <T>(ContentItemIdentifier identifier) where T : new()
        {
            if (identifier == null)
            {
                throw new ArgumentNullException(nameof(identifier));
            }

            var endpointUrl = _urlBuilder.BuildListVariantsUrl(identifier);
            var response    = await _actionInvoker.InvokeReadOnlyMethodAsync <List <ContentItemVariantModel> >(endpointUrl, HttpMethod.Get);

            return(response.Select(x => _modelProvider.GetContentItemVariantModel <T>(x)).ToList());
        }
        internal string BuildItemUrl(ContentItemIdentifier identifier)
        {
            var itemSegment = GetItemUrlSegment(identifier);

            return(GetUrl(itemSegment));
        }
        /// <summary>
        /// Returns strongly typed listing of content item variants for specified content item.
        /// </summary>
        /// <param name="identifier">The identifier of the content item.</param>
        /// <returns>The <see cref="IEnumerable{ContentItemVariantModel}"/> instance that represents the listing of content item variants.</returns>
        public async Task <IEnumerable <ContentItemVariantModel> > ListContentItemVariantsAsync(ContentItemIdentifier identifier)
        {
            if (identifier == null)
            {
                throw new ArgumentNullException(nameof(identifier));
            }

            var endpointUrl = _urlBuilder.BuildListVariantsUrl(identifier);
            var response    = await _actionInvoker.InvokeReadOnlyMethodAsync <IEnumerable <ContentItemVariantModel> >(endpointUrl, HttpMethod.Get);

            return(response);
        }
        internal string BuildListVariantsUrl(ContentItemIdentifier identifier)
        {
            var itemSegment = GetItemUrlSegment(identifier);

            return(GetUrl(string.Concat(itemSegment, URL_VARIANT)));
        }