public XConnectClient GetClient()
{
CertificateWebRequestHandlerModifierOptions options =
CertificateWebRequestHandlerModifierOptions.Parse("StoreName=My;StoreLocation=LocalMachine;FindType=FindByThumbprint;FindValue=C14AA17037663A3C3A134734AA588B654B431EB2");
var certificateModifier = new CertificateWebRequestHandlerModifier(options);
List <IHttpClientModifier> clientModifiers = new List <IHttpClientModifier>();
var timeoutClientModifier = new TimeoutHttpClientModifier(new TimeSpan(0, 0, 20));
clientModifiers.Add(timeoutClientModifier);
var collectionClient = new CollectionWebApiClient(new Uri("https://sc9.xconnect/odata"), clientModifiers, new[] { certificateModifier });
var searchClient = new SearchWebApiClient(new Uri("https://sc9.xconnect/odata"), clientModifiers, new[] { certificateModifier });
var configurationClient = new ConfigurationWebApiClient(new Uri("https://sc9.xconnect/configuration"), clientModifiers, new[] { certificateModifier });
var config = new XConnectClientConfiguration(
new XdbRuntimeModel(CollectionModel.Model), collectionClient, searchClient, configurationClient);
try
{
config.Initialize();
}
catch (XdbModelConflictException ex)
{
Console.WriteLine(ex.Message);
throw;
}
return(new XConnectClient(config));
}
public async System.Threading.Tasks.Task CreateAsync(string source, string identifier)
{
ContactIdentifier contactIdentifier = new ContactIdentifier(source, identifier, ContactIdentifierType.Known);
var Identifier = contactIdentifier.Identifier;
var XConnectContact = new Contact(new ContactIdentifier[] { contactIdentifier });
XConnectConfigHelper configHelper = new XConnectConfigHelper();
XConnectClientConfiguration cfg = await configHelper.ConfigureClient();
using (var Client = new XConnectClient(cfg))
{
try
{
var clientHelper = new XConnectClientHelper(Client);
if (!string.IsNullOrEmpty(Identifier))
{
XConnectContact = await clientHelper.GetXConnectContactByIdentifierAsync(CollectionConst.XConnect.ContactIdentifiers.Sources.SitecoreCinema, Identifier);
}
Client.AddContact(XConnectContact);
}
catch (XdbExecutionException ex)
{
Sitecore.Diagnostics.Log.Error(ex.Message, this);
}
}
}
/// <summary>
/// You can explicitly request a single interaction, but you must provide both the contact ID and the interaction ID.
/// Most external systems won't have this data, but it could be useful if you want to load details of an interaction results from a search
/// and return additional facet data.
/// </summary>
/// <param name="cfg">The xConnect client configuration to use to make connections</param>
/// <param name="contactId">The contact the interaction is associated with</param>
/// <param name="interactionId">The interaction event identifier</param>
/// <returns></returns>
public virtual async Task <Interaction> GetInteraction(XConnectClientConfiguration cfg, Guid contactId, Guid interactionId)
{
Logger.WriteLine("Retrieving interaction for contact with ID: '{0}'. Interaction ID: '{1}'.", contactId, interactionId);
using (var client = new XConnectClient(cfg))
{
try
{
//Get the interaction reference that will be used to execute the lookup
var interactionReference = new InteractionReference(contactId, interactionId);
//Define the facets that should be expanded
var expandOptions = new InteractionExpandOptions(new string[] { IpInfo.DefaultFacetKey });
expandOptions.Contact = new RelatedContactExpandOptions(new string[] { PersonalInformation.DefaultFacetKey });
expandOptions.Expand <WebVisit>();
//Query the client for the interaction
var interaction = await client.GetAsync <Interaction>(interactionReference, expandOptions);
//Show the information about the interaction
Logger.WriteInteraction(interaction);
return(interaction);
}
catch (XdbExecutionException ex)
{
// Deal with exception
Logger.WriteError("Exception creating interaction", ex);
}
}
return(null);
}
/// <summary>
/// Given a list of Contact GUIDs, delete all of them
/// </summary>
/// <param name="cfg">The configuration to use to load the Contact</param>
/// <param name="contacts">The contacts to delete</param>
public virtual async Task DeleteMultipleContacts(XConnectClientConfiguration cfg, List <Contact> contacts)
{
if (contacts == null)
{
contacts = new List <Contact>();
}
Logger.WriteLine("Deleting Multiple Contacts: [{0}]", contacts.Count);
using (var client = new XConnectClient(cfg))
{
try
{
//Add an operation to the task for each contact in the list
foreach (var contact in contacts)
{
client.DeleteContact(contact);
}
await client.SubmitAsync();
if (client.LastBatch != null)
{
Logger.WriteOperations(client.LastBatch);
}
Logger.WriteLine(">> {0} Contacts successfully deleted.", contacts.Count);
}
catch (XdbExecutionException ex)
{
Logger.WriteError("Exception deleting the Contacts", ex);
}
}
}
/// <summary>
/// Executes a search against the API to look for interactions falling between two particular dates.
/// </summary>
/// <param name="cfg">The xConnect client configuration to use to make connections</param>
/// <param name="startDate">The earliest start point for returned interactions</param>
/// <param name="endDate">The latest end point for returned interactions</param>
/// <returns></returns>
public virtual async Task <List <Interaction> > SearchInteractionsByDate(XConnectClientConfiguration cfg, DateTime startDate, DateTime endDate)
{
Logger.WriteLine("Searching for all interactions between {0} and {1}", startDate, endDate);
using (var client = new XConnectClient(cfg))
{
try {
//Build the query to be triggered
var queryable = client.Interactions.Where(i => i.StartDateTime >= startDate && i.EndDateTime <= endDate);
//Execute the search using the date boundaries provided
var enumerable = await queryable.GetBatchEnumerator(10);
//Output the data that was retrieved and collect into a list to return
var interactions = new List <Interaction>();
while (await enumerable.MoveNext())
{
foreach (var interaction in enumerable.Current)
{
interactions.Add(interaction);
Logger.WriteInteraction(interaction);
}
}
//Return the set of interactions to the calling application
return(interactions);
}
catch (XdbExecutionException ex)
{
// Deal with exception
Logger.WriteError("Exception executing search operation", ex);
}
}
return(null);
}
private async Task <XConnectClientConfiguration> InitializeConnectionAsync()
{
var certificateModifier = new CertificateWebHandlerModifier(_jobData.CertData);
var clientModifiers = new List <IHttpClientModifier>();
var timeoutClientModifier = new TimeoutHttpClientModifier(new TimeSpan(0, 0, 20));
clientModifiers.Add(timeoutClientModifier);
// This overload takes three client end points - collection, search, and configuration
var collectionClient = new CollectionWebApiClient(new Uri($"https://{_jobData.Uri}/odata"), clientModifiers, new[] { certificateModifier });
var searchClient = new SearchWebApiClient(new Uri($"https://{_jobData.Uri}/odata"), clientModifiers, new[] { certificateModifier });
var configurationClient = new ConfigurationWebApiClient(new Uri($"https://{_jobData.Uri}/configuration"), clientModifiers, new[] { certificateModifier });
var cfg = new XConnectClientConfiguration(
new XdbRuntimeModel(CollectionModel.Model), collectionClient, searchClient, configurationClient, true);
try
{
await cfg.InitializeAsync().ConfigureAwait(false);
return(cfg);
}
catch (XdbModelConflictException ce)
{
_log.Error(() => ce.Message, ce);
return(null);
}
}
public static XConnectClient GetClient()
{
string xconnectCollectionCertificateConnectionString = System.Configuration.ConfigurationManager.ConnectionStrings["xconnect.collection.certificate"].ConnectionString;
string xconnectCollectionConnectionString = System.Configuration.ConfigurationManager.ConnectionStrings["xconnect.collection"].ConnectionString;;
CertificateWebRequestHandlerModifierOptions options =
CertificateWebRequestHandlerModifierOptions.Parse("xconnectCollectionCertificateConnectionString");
var certificateModifier = new CertificateWebRequestHandlerModifier(options);
List <IHttpClientModifier> clientModifiers = new List <IHttpClientModifier>();
var timeoutClientModifier = new TimeoutHttpClientModifier(new TimeSpan(0, 0, 20));
clientModifiers.Add(timeoutClientModifier);
var collectionClient = new CollectionWebApiClient(new Uri(xconnectCollectionConnectionString + "/odata"), clientModifiers, new[] { certificateModifier });
var searchClient = new SearchWebApiClient(new Uri(xconnectCollectionConnectionString + "/odata"), clientModifiers, new[] { certificateModifier });
var configurationClient = new ConfigurationWebApiClient(new Uri(xconnectCollectionConnectionString + "/configuration"), clientModifiers, new[] { certificateModifier });
var config = new XConnectClientConfiguration(
new XdbRuntimeModel(CollectionModel.Model), collectionClient, searchClient, configurationClient);
try
{
config.Initialize();
}
catch (XdbModelConflictException ex)
{
Console.WriteLine(ex.Message);
throw;
}
return(new XConnectClient(config));
}
public XConnectClient BuildClient(bool enableExtraction = false)
{
XConnectClientConfiguration clientConfig = BuildXConnectClientConfiguration(enableExtraction);
clientConfig.Initialize();
return(new XConnectClient(clientConfig));
}
private static async Task <XConnectClient> GetXConnectClient()
{
// Valid certificate thumbprints must be passed in
var options =
CertificateHttpClientHandlerModifierOptions.Parse($"StoreName=My;StoreLocation=LocalMachine;FindType=FindByThumbprint;FindValue=55AAF36E6508E0670F2B11F67371993C9EB8428D");
// Optional timeout modifier
var certificateModifier = new CertificateHttpClientHandlerModifier(options);
var clientModifiers = new List <IHttpClientModifier>();
var timeoutClientModifier = new TimeoutHttpClientModifier(new TimeSpan(0, 0, 60));
clientModifiers.Add(timeoutClientModifier);
// This overload takes three client end points - collection, search, and configuration
var collectionClient = new CollectionWebApiClient(new Uri("https://xp930.xconnect/odata"), clientModifiers, new[] { certificateModifier });
var searchClient = new SearchWebApiClient(new Uri("https://xp930.xconnect/odata"), clientModifiers, new[] { certificateModifier });
var configurationClient = new ConfigurationWebApiClient(new Uri("https://xp930.xconnect/configuration"), clientModifiers, new[] { certificateModifier });
XdbModel[] models = { CollectionModel.Model, Custom.Foundation.Xdb.Models.FormsModel.Model };
var cfg = new XConnectClientConfiguration(
new XdbRuntimeModel(models), collectionClient, searchClient, configurationClient);
await cfg.InitializeAsync();
return(new XConnectClient(cfg));
}
private XConnectClient GetClient()
{
XConnectClientConfiguration cfg;
if (string.IsNullOrEmpty(XconnectThumbprint))
{
cfg = new XConnectClientConfiguration(
new XdbRuntimeModel(FaceApiModel.Model),
new Uri(XconnectUrl),
new Uri(XconnectUrl));
}
else
{
CertificateWebRequestHandlerModifierOptions options =
CertificateWebRequestHandlerModifierOptions.Parse("StoreName=My;StoreLocation=LocalMachine;FindType=FindByThumbprint;FindValue=" + XconnectThumbprint);
var certificateModifier = new CertificateWebRequestHandlerModifier(options);
// Step 2 - Client Configuration
var collectionClient = new CollectionWebApiClient(new Uri(XconnectUrl + "/odata"), null, new[] { certificateModifier });
var searchClient = new SearchWebApiClient(new Uri(XconnectUrl + "/odata"), null, new[] { certificateModifier });
var configurationClient = new ConfigurationWebApiClient(new Uri(XconnectUrl + "/configuration"), null, new[] { certificateModifier });
cfg = new XConnectClientConfiguration(
new XdbRuntimeModel(FaceApiModel.Model), collectionClient, searchClient, configurationClient);
}
cfg.Initialize();
var client = new XConnectClient(cfg);
return(client);
}
internal static XConnectClientConfiguration GenerateCFG(XdbModel xdbModel)
{
XConnectClientConfiguration toReturn = null;
var CertificateThumbprint = ConfigurationManager.AppSettings.Get("CertificateThumbprint");
if (!string.IsNullOrEmpty(CertificateThumbprint))
{
var options = CertificateHttpClientHandlerModifierOptions.Parse(Const.XConnect.CertificateStorePrefix + CertificateThumbprint);
var certificateModifier = new CertificateHttpClientHandlerModifier(options);
List <IHttpClientModifier> clientModifiers = new List <IHttpClientModifier>();
var timeoutClientModifier = new TimeoutHttpClientModifier(new TimeSpan(0, 0, 20));
clientModifiers.Add(timeoutClientModifier);
var odataUri = new Uri(MarketingConst.XConnect.EndPoints.Odata);
var ConfigurationUri = new Uri(MarketingConst.XConnect.EndPoints.Configuration);
var httpClientHandlerModifiers = new[] { certificateModifier };
var collectionClient = new CollectionWebApiClient(odataUri, clientModifiers, httpClientHandlerModifiers);
var searchClient = new SearchWebApiClient(odataUri, clientModifiers, httpClientHandlerModifiers);
var configurationClient = new ConfigurationWebApiClient(ConfigurationUri, clientModifiers, httpClientHandlerModifiers);
toReturn = new XConnectClientConfiguration(new XdbRuntimeModel(xdbModel), collectionClient, searchClient, configurationClient);
}
else
{
Console.WriteLine("Missing certificate thumbprint. Re: example config");
}
return(toReturn);
}
/// <summary>
/// Gets Client
/// </summary>
/// <returns></returns>
private static XConnectClient GetClient()
{
var config = new XConnectClientConfiguration(
new XdbRuntimeModel(CollectionModel.Model),
new Uri(Sitecore.Configuration.Settings.GetSetting(GenericConstants.xconnectEndPoint)),
new Uri(Sitecore.Configuration.Settings.GetSetting(GenericConstants.xconnectEndPoint)));
try
{
config.Initialize();
}
catch (XdbModelConflictException ex)
{
Sitecore.Diagnostics.Log.Error(
string.Format("XdbModelConflictException Occured in the Method {0}",
System.Reflection.MethodBase.GetCurrentMethod().Name),
ex);
}
catch (Exception exception)
{
Sitecore.Diagnostics.Log.Error(
string.Format("Error Occured in the Method {0}",
System.Reflection.MethodBase.GetCurrentMethod().Name),
exception);
}
return(new XConnectClient(config));
}
public XConnectClientConfiguration GetCFG(XdbModel xdbModel)
{
var options = CertificateHttpClientHandlerModifierOptions.Parse(CollectionConst.XConnect.Certificate.CertificateStore + CollectionConst.XConnect.Certificate.CertificateThumbprint);
var certificateModifier = new CertificateHttpClientHandlerModifier(options);
List <IHttpClientModifier> clientModifiers = new List <IHttpClientModifier>();
var timeoutClientModifier = new TimeoutHttpClientModifier(new TimeSpan(0, 0, 20));
clientModifiers.Add(timeoutClientModifier);
var collectionClient = new CollectionWebApiClient(new Uri(CollectionConst.XConnect.EndPoints.Odata),
clientModifiers, new[] { certificateModifier });
var searchClient = new SearchWebApiClient(new Uri(CollectionConst.XConnect.EndPoints.Odata),
clientModifiers, new[] { certificateModifier }
);
var configurationClient = new ConfigurationWebApiClient(new Uri(CollectionConst.XConnect.EndPoints.Configuration),
clientModifiers, new[] { certificateModifier });
var cfg = new XConnectClientConfiguration(
new XdbRuntimeModel(xdbModel),
collectionClient, searchClient, configurationClient);
return(cfg);
}
/// <summary>
/// Create a contact
/// </summary>
/// <param name="cfg">The client configuration for connecting</param>
/// <param name="twitterIdentifiers">The list of identifiers for each contact</param>'
public virtual async Task <List <ContactIdentifier> > CreateMultipleContacts(XConnectClientConfiguration cfg, List <string> twitterIdentifiers)
{
//Ensure collection is non-null
if (twitterIdentifiers == null)
{
twitterIdentifiers = new List <string>();
}
// Print out the identifier that is going to be used
Logger.WriteLine("Creating Multiple Contacts [{0}]", twitterIdentifiers.Count);
//Build up the list of ContactIdentifiers that will be used
List <ContactIdentifier> contactIdentifiers = new List <ContactIdentifier>();
foreach (var twitterId in twitterIdentifiers)
{
var identifier = new ContactIdentifier("twitter", twitterId, ContactIdentifierType.Known);
contactIdentifiers.Add(identifier);
}
// Initialize a client using the validated configuration
using (var client = new XConnectClient(cfg))
{
try
{
//Create all the contact objects and add to the client
foreach (var contactIdentifier in contactIdentifiers)
{
// Create a new contact object from the identifier
var knownContact = new Contact(new ContactIdentifier[] { contactIdentifier });
//Add personal information
var personalInfoFacet = new PersonalInformation()
{
FirstName = "Myrtle", LastName = contactIdentifier.Identifier, JobTitle = "Programmer Writer", Birthdate = DateTime.Now.Date
};
//Set the personal info on the contact
client.SetFacet <PersonalInformation>(knownContact, PersonalInformation.DefaultFacetKey, personalInfoFacet);
//Add to the client
client.AddContact(knownContact);
}
// Submit contact
await client.SubmitAsync();
// Get the last batch that was executed
Logger.WriteOperations(client.LastBatch);
}
catch (XdbExecutionException ex)
{
// Deal with exception
Logger.WriteError("Exception creating contacts", ex);
}
}
return(contactIdentifiers);
}
private static async Task <XConnectClient> GetXConnectClient()
{
var uri = new Uri("https://sc92demo.xconnect");
var config = new XConnectClientConfiguration(CollectionModel.Model, uri);
await config.InitializeAsync();
return(new XConnectClient(config));
}
/// <summary>
/// Helper method to get XConnect Client object
/// </summary>
/// <returns></returns>
private XConnectClient GetXConnectClient()
{
var xconnectConfig = new XConnectClientConfiguration(_xDbModel, new Uri("https://netflixnext.xconnect"));
xconnectConfig.Initialize();
return(new XConnectClient(xconnectConfig));
}
private static async Task <XConnectClient> GetXConnectClient()
{
var uri = new Uri("http://xpfplatformtests_xconnect/");
var config = new XConnectClientConfiguration(CollectionModel.Model, uri);
await config.InitializeAsync();
return(new XConnectClient(config));
}
private async Task <XConnectClient> CreateXConnectClient()
{
if (_xConnectClientConfiguration == null)
{
_xConnectClientConfiguration = await CreateXConnectClientConfiguration();
}
return(new XConnectClient(_xConnectClientConfiguration));
}
/// <summary>
/// Find ID values for all contacts that have not had any activity since a specified DateTime.
/// If a bound is not provided, the logic assumes current time - 30 days.
///
/// Based on documentation example: https://doc.sitecore.com/developers/92/sitecore-experience-platform/en/search-contacts.html
/// </summary>
/// <param name="cfg">The client configuration for connecting</param>
/// <param name="lastActivity">The time to look for the contact's last activity</param>
/// <returns>The matching contact object</returns>
public virtual async Task <List <System.Guid> > GetContactIdsByLastActivity(XConnectClientConfiguration cfg, DateTime?lastActivity)
{
//Create a collection that will store the IDs of the results
List <System.Guid> matchingContactIds = new List <System.Guid>();
//Establish a timebound to search for. If not provided, default to a value.
DateTime searchStartTime = lastActivity.HasValue ? lastActivity.Value : DateTime.Now.AddDays(-30);
Logger.WriteLine("Retrieving all Contacts without interactions since:" + searchStartTime.ToShortDateString());
// Initialize a client using the validated configuration
using (var client = new XConnectClient(cfg))
{
try
{
//Set up options to restrict the number of interactions we return for each contact
var contactExpandOptions = new ContactExpandOptions();
contactExpandOptions.Interactions = new RelatedInteractionsExpandOptions()
{
Limit = 20
};
//Create a queryable to search by the date
IAsyncQueryable <Contact> queryable = client.Contacts
.Where(c => (!c.Interactions.Any()) || !c.Interactions.Any(x => x.StartDateTime > searchStartTime))
.WithExpandOptions(contactExpandOptions);
//Invoke the query
var enumerator = await queryable.GetBatchEnumerator(10);
//Collect all the matching contact IDs
while (await enumerator.MoveNext())
{
foreach (var contact in enumerator.Current)
{
if (contact.Id.HasValue)
{
matchingContactIds.Add(contact.Id.Value);
}
}
}
Logger.WriteLine(">> Total number of matches found '{0}'", matchingContactIds.Count);
}
catch (XdbExecutionException ex)
{
// Deal with exception
Logger.WriteError("Exception executing search", ex);
}
}
return(matchingContactIds);
}
/// <summary>
/// Retrieves the Contacts from xConnect for each matching contactID
/// </summary>
/// <param name="cfg">The configuration to use to open connections to xConnect</param>
/// <param name="contactIds">The list of contacts to retrieve</param>
/// <returns></returns>
public virtual async Task <List <Contact> > GetMultipleContacts(XConnectClientConfiguration cfg, List <Guid> contactIds)
{
if (contactIds == null)
{
contactIds = new List <Guid>();
}
Logger.WriteLine("Getting Multiple Contacts: [{0}]", contactIds.Count);
var contacts = new List <Contact>();
// Initialize a client using the validated configuration
using (var client = new XConnectClient(cfg))
{
try
{
//Configure the options to extract the personal information facet
var contactOptions = new ContactExpandOptions(new string[] { PersonalInformation.DefaultFacetKey });
//Get a list of reference objects for the contactIds provided
var references = new List <IEntityReference <Contact> >();
foreach (var contactId in contactIds)
{
references.Add(new ContactReference(contactId));
}
//Get all the matches
var contactsResult = await client.GetAsync <Contact>(references, contactOptions);
//Get the Contact objects from the results
foreach (var result in contactsResult)
{
if (result.Exists)
{
contacts.Add(result.Entity);
}
}
//Output information about the contact list
if (client.LastBatch != null)
{
Logger.WriteOperations(client.LastBatch);
}
Logger.WriteLine("> Retrieved {0} matching Contacts.", contacts.Count);
}
catch (XdbExecutionException ex)
{
// Deal with exception
Logger.WriteError("Exception retrieving contact", ex);
}
}
return(contacts);
}
public ActionResult SlackSearch(SlackSearchViewModel model)
{
#region Setting things up for xConnect
// TO DO: This should be in app.config
//var xConnectCertificateConnectionString = ConfigurationManager.AppSettings["xConnectCertificateConnectionString"];
var xConnectCertificateConnectionString = "StoreName=My;StoreLocation=LocalMachine;FindType=FindByThumbprint;FindValue=3DE93B08A1C99FDC874B5A035EF02C66F3CB77E0";
// (CTW) Getting xConnect Root Url from config
//var xConnectRootUrl = ConfigurationManager.AppSettings["xConnectRootUrl"];
var xConnectRootUrl = "https://hc.sc.xconnect";
CertificateWebRequestHandlerModifierOptions options =
CertificateWebRequestHandlerModifierOptions.Parse(xConnectCertificateConnectionString);
var certificateModifier = new CertificateWebRequestHandlerModifier(options);
List <IHttpClientModifier> clientModifiers = new List <IHttpClientModifier>();
var timeoutClientModifier = new TimeoutHttpClientModifier(new TimeSpan(0, 0, 20));
clientModifiers.Add(timeoutClientModifier);
var collectionClient = new CollectionWebApiClient(new Uri(xConnectRootUrl + "/odata"), clientModifiers, new[] { certificateModifier });
var searchClient = new SearchWebApiClient(new Uri(xConnectRootUrl + "/odata"), clientModifiers, new[] { certificateModifier });
var configurationClient = new ConfigurationWebApiClient(new Uri(xConnectRootUrl + "/configuration"), clientModifiers, new[] { certificateModifier });
var cfg = new XConnectClientConfiguration(
new XdbRuntimeModel(CollectionModel.Model), collectionClient, searchClient, configurationClient);
#endregion
try
{
cfg.Initialize();
}
catch (XdbModelConflictException ce)
{
Console.WriteLine("ERROR:" + ce.Message);
return(null);
}
// Initialize a client using the validated configuration
using (var client = new XConnectClient(cfg))
{
// TO DO: This should be loaded via reflection
IArticleProvider articleProvider = new SimpleArticleProvider
{
Client = client
};
model.ArticleList = articleProvider.GetArticles("SLACK_ALIAS", model.SlackId);
return(View("slacksearchview", model));
}
}
public async System.Threading.Tasks.Task InitCFGAsync(XConnectClientConfiguration cfg)
{
try
{
await cfg.InitializeAsync();
}
catch (XdbModelConflictException ce)
{
Errors.Add("ERROR:" + ce.Message);
return;
}
}
public void Initialize()
{
_logger.Write("Initializing xConnect...");
var model = _modelProvider.Model;
var config = new XConnectClientConfiguration(new XdbRuntimeModel(model), new Uri(_xconnectConfiguration.XconnectUrl), new Uri(_xconnectConfiguration.XconnectUrl));
config.Initialize();
_client = new XConnectClient(config);
_logger.WriteLine("xConnect initialization complete");
}
public static void GetContact()
{
// Valid certificate thumbprints must be passed in
CertificateWebRequestHandlerModifierOptions options =
CertificateWebRequestHandlerModifierOptions.Parse("StoreName=My;StoreLocation=LocalMachine;FindType=FindByThumbprint;FindValue=DAEDD8105CFFAD6E95F25488E72EF0B5C6C9328B");
var certificateModifier = new CertificateWebRequestHandlerModifier(options);
// Optional timeout modifier
List <IHttpClientModifier> clientModifiers = new List <IHttpClientModifier>();
var timeoutClientModifier = new TimeoutHttpClientModifier(new TimeSpan(0, 0, 20));
clientModifiers.Add(timeoutClientModifier);
// This overload takes three client end points - collection, search, and configuration
var collectionClient = new CollectionWebApiClient(new Uri("https://sc902.xconnect/odata"), clientModifiers, new[] { certificateModifier });
var searchClient = new SearchWebApiClient(new Uri("https://sc902.xconnect/odata"), clientModifiers, new[] { certificateModifier });
var configurationClient = new ConfigurationWebApiClient(new Uri("https://sc902.xconnect/configuration"), clientModifiers, new[] { certificateModifier });
var cfg = new XConnectClientConfiguration(
new XdbRuntimeModel(CollectionModel.Model, MySiteCollectionModel.Model), collectionClient, searchClient, configurationClient);
try
{
cfg.Initialize();
}
catch (XdbModelConflictException ce)
{
System.Console.WriteLine("ERROR:" + ce.Message);
return;
}
using (var client = new XConnectClient(cfg))
{
var reference = new IdentifiedContactReference("Website", "*****@*****.**");
var contact = client.Get <Sitecore.XConnect.Contact>(reference, new ContactExpandOptions(PersonalInformation.DefaultFacetKey, BusinessIndustry.DefaultFacetKey, EmailAddressList.DefaultFacetKey)
{
Interactions = new RelatedInteractionsExpandOptions(IpInfo.DefaultFacetKey)
{
StartDateTime = DateTime.MinValue,
EndDateTime = DateTime.MaxValue,
Limit = 3
}
});
}
}
/// <summary>
/// Create a contact
/// </summary>
/// <param name="cfg">The client configuration for connecting</param>
/// <param name="twitterId">The identifier of the contact to create</param>'
public virtual async Task <ContactIdentifier> CreateContact(XConnectClientConfiguration cfg, string twitterId)
{
// Identifier for a 'known' contact
var identifier = new ContactIdentifier("twitter", twitterId, ContactIdentifierType.Known);
var identifiers = new ContactIdentifier[] { identifier };
// Print out the identifier that is going to be used
Logger.WriteLine("Creating Contact with Identifier:" + identifier.Identifier);
// Initialize a client using the validated configuration
using (var client = new XConnectClient(cfg))
{
try
{
// Create a new contact object from the identifier
var knownContact = new Contact(identifiers);
//Add personal information
var personalInfoFacet = new PersonalInformation()
{
FirstName = "Myrtle", LastName = "McSitecore", JobTitle = "Programmer Writer", Birthdate = DateTime.Now.Date
};
//Set the personal info on the contact
client.SetFacet <PersonalInformation>(knownContact, PersonalInformation.DefaultFacetKey, personalInfoFacet);
//Add to the client
client.AddContact(knownContact);
// Submit contact
await client.SubmitAsync();
// Get the last batch that was executed
Logger.WriteOperations(client.LastBatch);
}
catch (XdbExecutionException ex)
{
// Deal with exception
Logger.WriteError("Exception creating contact", ex);
}
}
return(identifier);
}
/// <summary>
/// Retrieve a created contact with interactions within the range provided
/// </summary>
/// <param name="cfg">The client configuration for connecting</param>
/// <param name="twitterId">The identifier of the contact to create</param>
/// <param name="interactionStartTime">The start range of interactions to return</param>
/// <param name="interactionEndTime">The end range of interactions to return</param>
/// <returns>The matching contact object</returns>
public virtual async Task <Contact> GetContactWithInteractions(XConnectClientConfiguration cfg, string twitterId, DateTime?interactionStartTime, DateTime?interactionEndTime)
{
Contact existingContact = null;
Logger.WriteLine("Retrieving Contact with Identifier:" + twitterId);
// Initialize a client using the validated configuration
using (var client = new XConnectClient(cfg))
{
try
{
var contactOptions = new ContactExpandOptions(new string[] { PersonalInformation.DefaultFacetKey });
//Add interaction range if necessary
if (interactionStartTime.HasValue || interactionEndTime.HasValue)
{
contactOptions.Interactions = new RelatedInteractionsExpandOptions(IpInfo.DefaultFacetKey)
{
StartDateTime = interactionStartTime,
EndDateTime = interactionEndTime
};
}
//Build up options for the query
var reference = new IdentifiedContactReference("twitter", twitterId);
// Get a known contact
existingContact = await client.GetAsync <Contact>(reference, contactOptions);
if (existingContact == null)
{
Logger.WriteLine("No contact found with ID '{0}'", twitterId);
return(null);
}
//Output information about the contact
Logger.WriteContact(existingContact);
}
catch (XdbExecutionException ex)
{
// Deal with exception
Logger.WriteError("Exception retrieving contact", ex);
}
}
return(existingContact);
}
private XConnectClient GetClient()
{
// Valid certificate thumbprint must be passed in
CertificateWebRequestHandlerModifierOptions options =
CertificateWebRequestHandlerModifierOptions.Parse($"StoreName=My;StoreLocation=LocalMachine;FindType=FindByThumbprint;FindValue={XConnectThumbprint}");
// Optional timeout modifier
var certificateModifier = new CertificateWebRequestHandlerModifier(options);
List <IHttpClientModifier> clientModifiers = new List <IHttpClientModifier>();
var timeoutClientModifier = new TimeoutHttpClientModifier(new TimeSpan(0, 0, 20));
clientModifiers.Add(timeoutClientModifier);
// This overload takes three client end points - collection, search, and configuration
var collectionClient = new CollectionWebApiClient(new Uri($"{XConnectUrl.TrimEnd(new char['/'])}/odata"), clientModifiers, new[] { certificateModifier });
var searchClient = new SearchWebApiClient(new Uri($"{XConnectUrl.TrimEnd(new char['/'])}/odata"), clientModifiers, new[] { certificateModifier });
var configurationClient = new ConfigurationWebApiClient(new Uri($"{XConnectUrl.TrimEnd(new char['/'])}/configuration"), clientModifiers, new[] { certificateModifier });
//Reference: https://sitecore.stackexchange.com/questions/8910/the-type-of-this-instance-does-not-correspond-to-any-type-in-the-model
XdbModel[] models = { CollectionModel.Model, GoogleApiModel.Model };
var xConnectClientConfiguration = new XConnectClientConfiguration(
new XdbRuntimeModel(models),
collectionClient,
searchClient,
configurationClient);
try
{
xConnectClientConfiguration.Initialize();
}
catch (XdbModelConflictException ex)
{
Console.WriteLine(ex.Message);
throw;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
throw;
}
return(new XConnectClient(xConnectClientConfiguration));
}
public static async Task <XConnectClient> Create()
{
const string XCONNECT_ENDPOINT_KEY = "xconnect.collection";
var connectionStrings = WebConfigurationManager.ConnectionStrings;
var endpoint = connectionStrings[XCONNECT_ENDPOINT_KEY]?.ConnectionString;
Uri endpointUri;
if (!Uri.TryCreate(endpoint, UriKind.Absolute, out endpointUri))
{
throw new Exception($"Endpoint to xConnect has not been specified. The key name must be [{XCONNECT_ENDPOINT_KEY}]");
}
CollectionWebApiClient collectionClient;
SearchWebApiClient searchClient;
ConfigurationWebApiClient configurationClient;
XConnectClientConfiguration cfg;
var certificate = connectionStrings["xconnect.collection.certificate"]?.ConnectionString;
List <IHttpClientModifier> modifiers = null;
CertificateWebRequestHandlerModifier[] certificateModifiers = null;
//if a certificate was specified in config
if (string.IsNullOrEmpty(certificate) == false)
{
var certOptions = CertificateWebRequestHandlerModifierOptions.Parse(certificate);
certificateModifiers = new[] { new CertificateWebRequestHandlerModifier(certOptions) };
modifiers = new List <IHttpClientModifier>()
{
new TimeoutHttpClientModifier(new TimeSpan(0, 0, 20))
};
}
collectionClient = new CollectionWebApiClient(new Uri(endpointUri, "odata/"), modifiers, certificateModifiers);
searchClient = new SearchWebApiClient(new Uri(endpointUri, "odata/"), modifiers, certificateModifiers);
configurationClient = new ConfigurationWebApiClient(new Uri(endpointUri, "configuration/"), modifiers, certificateModifiers);
cfg = new XConnectClientConfiguration(new XdbRuntimeModel(ModelFactory.Instance), collectionClient, searchClient, configurationClient, true);
await cfg.InitializeAsync();
return(new XConnectClient(cfg));
}
/// <summary>
/// Create an interaction for the specified contact loaded from xConnect
/// </summary>
/// <param name="cfg">The xConnect client configuration to use to make connections</param>
/// <param name="contact">The contact to create an interaction for</param>
/// <param name="channelId">The channel to create an interaction on</param>
/// <param name="goalId">The ID of the goal for the interaction event</param>
/// <param name="ipInfo">The ip address the goal was triggered from</param>
/// <param name="eventTime">(Optional) The time the interaction occurred. If not provided, defaults to Null and DateTime.UtcNow will be used for the interaction</param>
/// <returns></returns>
public virtual async Task <Interaction> RegisterGoalInteraction(XConnectClientConfiguration cfg, Contact contact, string channelId, string goalId, IpInfo ipInfo, DateTime?eventTime = null)
{
//Determine what time stamp to put on the interaction
var interactionTimestamp = eventTime.HasValue ? eventTime.Value : DateTime.UtcNow;
Logger.WriteLine("Creating interaction for contact with ID: '{0}'. Channel: '{1}'. Goal: '{2}'. Time: '{3}'", contact.Id, channelId, goalId, interactionTimestamp);
using (var client = new XConnectClient(cfg))
{
try
{
//Instantiate the interaction details
var interaction = new Interaction(contact, InteractionInitiator.Brand, Guid.Parse(channelId), "");
//Create the event - all interactions must have at least one event
var xConnectEvent = new Goal(Guid.Parse(goalId), interactionTimestamp);
interaction.Events.Add(xConnectEvent);
//Add in IP information for where the goal was triggered from
if (ipInfo != null)
{
client.SetFacet <IpInfo>(interaction, IpInfo.DefaultFacetKey, ipInfo);
}
//Add the interaction to the client
client.AddInteraction(interaction);
//Submit the interaction
await client.SubmitAsync();
// Get the last batch that was executed
Logger.WriteOperations(client.LastBatch);
return(interaction);
}
catch (XdbExecutionException ex)
{
// Deal with exception
Logger.WriteError("Exception creating interaction", ex);
}
}
return(null);
}
private static XConnectClient GetClient()
{
var config = new XConnectClientConfiguration(
new XdbRuntimeModel(CollectionModel.Model),
new Uri("https://sc9_xconnect"),
new Uri("https://sc9_xconnect"));
try
{
config.Initialize();
}
catch (XdbModelConflictException ex)
{
Console.WriteLine(ex.Message);
throw;
}
return(new XConnectClient(config));
}
