internal string BuildVariantsUrl(ContentItemVariantIdentifier identifier)
{
var itemSegment = GetItemUrlSegment(identifier.ItemIdentifier);
var variantSegment = GetVariantUrlSegment(identifier.LanguageIdentifier);
return(GetUrl(string.Concat(itemSegment, variantSegment)));
}
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]);
}
private async Task <ContentItemVariantModel <UserModel> > CreateUserVariant(UserModel userModel, ContentItemIdentifier itemIdentifier)
{
LanguageIdentifier languageIdentifier = LanguageIdentifier.ByCodename("default");
ContentItemVariantIdentifier variantIdentifier = new ContentItemVariantIdentifier(itemIdentifier, languageIdentifier);
ContentItemVariantModel <UserModel> responseVariant = await managementClient.UpsertContentItemVariantAsync <UserModel>(variantIdentifier, userModel);
return(responseVariant);
}
/// <summary>
/// Deletes given content item variant.
/// </summary>
/// <param name="identifier">The identifier of the content item variant.</param>
public async Task DeleteContentItemVariantAsync(ContentItemVariantIdentifier identifier)
{
if (identifier == null)
{
throw new ArgumentNullException(nameof(identifier));
}
var endpointUrl = _urlBuilder.BuildVariantsUrl(identifier);
await _actionInvoker.InvokeMethodAsync(endpointUrl, HttpMethod.Delete);
}
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);
}
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>
/// Returns strongly typed content item variant.
/// </summary>
/// <param name="identifier">The identifier of the content item variant.</param>
/// <returns>The <see cref="ContentItemVariantModel"/> instance that represents content item variant.</returns>
public async Task <ContentItemVariantModel> GetContentItemVariantAsync(ContentItemVariantIdentifier identifier)
{
if (identifier == null)
{
throw new ArgumentNullException(nameof(identifier));
}
var endpointUrl = _urlBuilder.BuildVariantsUrl(identifier);
var response = await _actionInvoker.InvokeReadOnlyMethodAsync <ContentItemVariantModel>(endpointUrl, HttpMethod.Get);
return(response);
}
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));
}
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>
/// Inserts or updates given content item variant.
/// </summary>
/// <param name="identifier">The identifier of the content item variant.</param>
/// <param name="contentItemVariantUpsertModel">Represents inserted or updated content item variant.</param>
/// <returns>The <see cref="ContentItemVariantModel"/> instance that represents inserted or updated content item variant.</returns>
public async Task <ContentItemVariantModel> UpsertContentItemVariantAsync(ContentItemVariantIdentifier identifier, ContentItemVariantUpsertModel contentItemVariantUpsertModel)
{
if (identifier == null)
{
throw new ArgumentNullException(nameof(identifier));
}
if (contentItemVariantUpsertModel == null)
{
throw new ArgumentNullException(nameof(contentItemVariantUpsertModel));
}
var endpointUrl = _urlBuilder.BuildVariantsUrl(identifier);
var response = await _actionInvoker.InvokeMethodAsync <ContentItemVariantUpsertModel, ContentItemVariantModel>(endpointUrl, HttpMethod.Put, contentItemVariantUpsertModel);
return(response);
}
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.");
}
private async Task <ContentItemVariantModel <ConversationModel> > UpsertConversationVariant(ConversationModel conversation, ContentItemIdentifier itemIdentifier)
{
LanguageIdentifier languageIdentifier = LanguageIdentifier.ByCodename("default");
ContentItemVariantIdentifier variantIdentifier = new ContentItemVariantIdentifier(itemIdentifier, languageIdentifier);
ContentItemVariantModel <ConversationModel> responseVariant = new ContentItemVariantModel <ConversationModel> {
};
try
{
responseVariant = await managementClient.UpsertContentItemVariantAsync <ConversationModel>(variantIdentifier, conversation);
}
catch (Exception e)
{
logger.Debug(e, "Failed to create conversation variant.");
}
return(responseVariant);
}
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));
}
}
internal async Task <ContentItemVariantModel <ConversationModel> > TryGetExistingConversationVariant(string conversationId)
{
ContentItemVariantModel <ConversationModel> conversationVariant = null;
try
{
ContentItemVariantIdentifier variantIdentifier = new ContentItemVariantIdentifier(ContentItemIdentifier.ByExternalId(conversationId), LanguageIdentifier.DEFAULT_LANGUAGE);
conversationVariant = await GetConversationVariant(variantIdentifier);
logger.Debug("Downloaded existing conversation variant: " + conversationVariant.Elements.ConversationId);
}
catch (ContentManagementException e)
{
// If it's 404, conversation doesn't exist (yet)
if (e.StatusCode != HttpStatusCode.NotFound)
{
throw e;
}
}
return(conversationVariant);
}
/// <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);
}
}
/// <summary>
/// Creates or updates the given content item variant.
/// </summary>
/// <param name="client">Content management client instance.</param>
/// <param name="identifier">Identifies which content item variant will be created or updated. </param>
/// <param name="contentItemVariant">Specifies data for created ur updated content item variant.</param>
/// <returns>The <see cref="ContentItemVariantModel"/> instance that represents created or updated content item variant.</returns>
public static async Task <ContentItemVariantModel> UpsertContentItemVariantAsync(this ContentManagementClient client, ContentItemVariantIdentifier identifier, ContentItemVariantModel contentItemVariant)
{
if (identifier == null)
{
throw new ArgumentNullException(nameof(identifier));
}
if (contentItemVariant == null)
{
throw new ArgumentNullException(nameof(contentItemVariant));
}
var contentItemVariantUpsertModel = new ContentItemVariantUpsertModel(contentItemVariant);
return(await client.UpsertContentItemVariantAsync(identifier, contentItemVariantUpsertModel));
}
private async Task <ContentItemVariantModel <ConversationModel> > GetConversationVariant(ContentItemVariantIdentifier variantIdentifier)
{
return(await managementClient.GetContentItemVariantAsync <ConversationModel>(variantIdentifier));
}
private async Task <ContentItemVariantModel <UserModel> > GetUserVariant(ContentItemVariantIdentifier variantIdentifier)
{
return(await managementClient.GetContentItemVariantAsync <UserModel>(variantIdentifier));
}
/// <summary>
/// Inserts or updates given content item variant.
/// </summary>
/// <typeparam name="T">Type of the content item elements</typeparam>
/// <param name="identifier">The identifier of the content item variant.</param>
/// <param name="variantElements">Represents inserted or updated strongly typed content item variant elements.</param>
/// <returns>The <see cref="ContentItemVariantModel{T}"/> instance that represents inserted or updated content item variant.</returns>
public async Task <ContentItemVariantModel <T> > UpsertContentItemVariantAsync <T>(ContentItemVariantIdentifier identifier, T variantElements) where T : new()
{
if (identifier == null)
{
throw new ArgumentNullException(nameof(identifier));
}
if (variantElements == null)
{
throw new ArgumentNullException(nameof(variantElements));
}
var endpointUrl = _urlBuilder.BuildVariantsUrl(identifier);
var variantUpsertModel = _modelProvider.GetContentItemVariantUpsertModel(variantElements);
var response = await _actionInvoker.InvokeMethodAsync <ContentItemVariantUpsertModel, ContentItemVariantModel>(endpointUrl, HttpMethod.Put, variantUpsertModel);
return(_modelProvider.GetContentItemVariantModel <T>(response));
}
/// <summary>
/// </summary>
/// <param name="elements">The Elements property of the content item to be updated</param>
/// <param name="codename">If set, the item with the specified code name will be upserted</param>
static void UpsertSingleItem(Dictionary <string, object> elements, string codename, ContentType type, bool update)
{
ContentItemModel contentItem = null;
ContentItem existingItem = null;
Guid itemid;
// Try to get existing content item for updating
if (update && existingItem == null)
{
existingItem = GetExistingContentItem(codename, type.System.Codename);
}
// If not updating, create content item first
if (!update)
{
contentItem = CreateNewContentItem(codename, type.System.Codename);
if (contentItem.Id != null)
{
itemid = contentItem.Id;
}
else
{
throw new Exception("Error creating new item.");
}
}
else
{
// We are updating existing
if (existingItem != null)
{
itemid = new Guid(existingItem.System.Id);
}
else
{
// Existing item wasn't found, create it
contentItem = CreateNewContentItem(codename, type.System.Codename);
if (contentItem.Id != null)
{
itemid = contentItem.Id;
}
else
{
throw new Exception("Error creating new item.");
}
}
}
// After item is created (or skipped for updateExisting), upsert content
try
{
// Get item variant to upsert
ContentItemIdentifier itemIdentifier = ContentItemIdentifier.ById(itemid);
LanguageIdentifier languageIdentifier = LanguageIdentifier.ById(new Guid("00000000-0000-0000-0000-000000000000"));
ContentItemVariantIdentifier identifier = new ContentItemVariantIdentifier(itemIdentifier, languageIdentifier);
elements = ValidateContentTypeFields(elements, type);
// Set target element value
ContentItemVariantUpsertModel model = new ContentItemVariantUpsertModel()
{
Elements = elements
};
// Upsert item
var upsertTask = clientCM.UpsertContentItemVariantAsync(identifier, model);
var response = upsertTask.GetAwaiter().GetResult();
}
catch (ContentManagementException e)
{
if (e.Message.ToLower().Contains("cannot update published"))
{
throw new Exception("This tool cannot currently update published content. If you wish to update a published item, you will first need to unpublish it within Kentico Kontent.");
}
}
}
