private bool ConversationNeedsUpdate(Conversation intercomConversation, ContentItemVariantModel <ConversationModel> conversationVariant)
{
// we don't want to synchronize open/snoozed conversations
if (intercomConversation.state != "closed")
{
logger.Debug("Skipping conversation because it's not closed: " + intercomConversation.id);
return(false);
}
// conversation doesn't exist yet
if (conversationVariant == null)
{
logger.Trace("Conversation doesn't exist in KK but does in intercom: " + intercomConversation.id);
return(true);
}
// if timestamps match, there is no reason to update
logger.Trace("IC date -> " + intercomConversation.updated_at + " " + long.Parse(Tools.ToUnixTimestamp(conversationVariant.Elements.LastUpdated)) + " <- KK date:");
if (intercomConversation.updated_at == long.Parse(Tools.ToUnixTimestamp(conversationVariant.Elements.LastUpdated)))
{
logger.Debug("Conversation is up to date: " + conversationVariant.Elements.ConversationId);
return(false);
}
return(true);
}
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]);
}
public ContentItemVariantModel <T> GetContentItemVariantModel <T>(ContentItemVariantModel variant) where T : new()
{
var result = new ContentItemVariantModel <T>
{
Item = variant.Item,
Language = variant.Language,
LastModified = variant.LastModified
};
var type = typeof(T);
var instance = new T();
var properties = type.GetProperties().Where(x => x.SetMethod?.IsPublic ?? false).ToList();
foreach (var element in variant.Elements)
{
var property = properties.FirstOrDefault(x => PropertyMapper.IsMatch(x, element.Key));
if (property == null)
{
continue;
}
var value = GetTypedElementValue(property.PropertyType, element.Value);
if (value != null)
{
property.SetValue(instance, value);
}
}
result.Elements = instance;
return(result);
}
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);
}
public void GetContentItemVariantModel_ReturnsExpected()
{
var expected = GetTestModel();
var model = new ContentItemVariantModel
{
Elements = ToDynamic(expected)
};
var actual = _modelProvider.GetContentItemVariantModel <ComplexTestModel>(model).Elements;
AssertElements(expected, actual);
}
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 bool UserNeedsUpdate(dynamic user, ContentItemVariantModel <UserModel> userVariant)
{
if (userVariant == null)
{
return(true);
}
if (userVariant != null && user == null)
{
//this user doesn't exist anymore in intercom???
}
//match fields
return(true);
}
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));
}
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);
}
public async Task <bool> SyncSingle(string conversationId)
{
if (bannedConversations.Contains(conversationId))
{
// This is currently for conversations with big data, which fails in KK
logger.Info("Conversation is banned: " + conversationId);
return(false);
}
Conversation intercomConversation;
// Get the conversation from Intercom
try
{
intercomConversation = intercom.GetConversation(conversationId);
if (intercomConversation == null)
{
logger.Error("Conversation was returned empty: " + conversationId);
return(false);
}
}
catch (Exception e)
{
logger.Error(e, "Wasn't able to get the conversation from intercom: " + conversationId);
return(false);
}
// Try to get conversation from existing project
ContentItemVariantModel <ConversationModel> conversationVariant = null;
if (!emptyProject)
{
conversationVariant = await kontent.TryGetExistingConversationVariant(intercomConversation.id);
}
logger.Debug("Synchronizing conversation to Kentico Kontent: " + conversationId);
if (!ConversationNeedsUpdate(intercomConversation, conversationVariant))
{
return(true);
}
else
{
if (conversationVariant != null)
{
await kontent.UnpublishItemVariant(conversationVariant.Item.Id.ToString());
}
}
// Extract all generic users participating in the conversation (id/type)
var genericParticipants = IntercomFunctions.GetAllConversationParticipants(intercomConversation);
List <ContentItemVariantModel <UserModel> > conversationUsers = new List <ContentItemVariantModel <UserModel> > {
};
logger.Debug("Trying to get existing user variants from Kontent.");
foreach (var genericParticipant in genericParticipants)
{
ContentItemVariantModel <UserModel> userVariant;
userVariant = await kontent.TryGetExistingUserVariant(genericParticipant.Id);
if (userVariant == null)
{
var intercomUser = intercom.GetIntercomUser(genericParticipant);
userVariant = await kontent.CreateUser(intercomUser);
}
conversationUsers.Add(userVariant);
}
var result = await kontent.SyncSingle(intercomConversation, conversationVariant, conversationUsers);
if (!result.success)
{
return(false);
}
conversationVariant = result.variant;
// synchronizovat do algolie
logger.Debug("Synchronizing object to Algolia: " + conversationId);
List <SearchUser> searchUserParticipants = new List <SearchUser>()
{
};
SearchUser assignee;
foreach (var user in conversationUsers)
{
searchUserParticipants.Add(new SearchUser(user.Elements.Name, user.Elements.Email));
}
if (intercomConversation.assignee.id != null)
{
var searchAssignee = intercom.GetIntercomUser(new GenericIntercomUser(intercomConversation.assignee.id, intercomConversation.assignee.type));
assignee = new SearchUser(searchAssignee.Name, searchAssignee.Email);
}
else
{
assignee = new SearchUser("unassigned", "");
}
var searchConversation = new SearchConversation(conversationVariant.Elements, assignee, searchUserParticipants);
await algolia.UpdateObject(searchConversation);
return(true);
}
