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));
}
/// <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));
}
public ContentItemVariantUpsertModel GetContentItemVariantUpsertModel <T>(T variantElements) where T : new()
{
var type = typeof(T);
var nameMapping = PropertyMapper.GetNameMapping(type);
var elements = type.GetProperties()
.Where(x => (x.GetMethod?.IsPublic ?? false) && nameMapping.ContainsKey(x.Name) && x.GetValue(variantElements) != null)
.ToDictionary(x => nameMapping[x.Name], x => x.GetValue(variantElements));
var result = new ContentItemVariantUpsertModel
{
Elements = elements
};
return(result);
}
public void ActionInvokerSerializeElementContainingZero_SerializedJsonContainsZero()
{
var httpClient = new FakeContentManagementHttpClient();
var actionInvoker = new ActionInvoker(httpClient, new MessageCreator("{api_key}"));
var contentItemVariantUpsertModel = new ContentItemVariantUpsertModel()
{
Elements = new {
zero = new decimal(0),
optZero = new decimal?(0),
},
};
var result = actionInvoker.InvokeMethodAsync <ContentItemVariantUpsertModel, dynamic>("{endpoint_url}", HttpMethod.Get, contentItemVariantUpsertModel);
Assert.Equal("{\"elements\":{\"zero\":0,\"optZero\":0}}", httpClient.requestBody);
}
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);
}
}
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
);
}
}
/// <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);
}
/// <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.");
}
}
}
