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)); }