private void AssignAdminRole(IOrganizationService service, Guid id)
{
string adminRoleName = "System Administrator";
try
{
QueryExpression query = new QueryExpression
{
EntityName = "role",
ColumnSet = new ColumnSet("name"),
Criteria = new FilterExpression
{
Conditions =
{
new ConditionExpression
{
AttributeName = "name",
Operator = ConditionOperator.Equal,
Values = {adminRoleName}
}
}
}
};
EntityCollection roles = service.RetrieveMultiple(query);
EntityReferenceCollection entityRefCln = new EntityReferenceCollection();
foreach (Entity entity in roles.Entities)
{
entityRefCln.Add(entity.ToEntityReference());
}
service.Associate("team", id, new Relationship("teamroles_association"), entityRefCln);
}
catch (Exception ex)
{
}
}
/// <summary>
/// </summary>
/// <param name="entityName"></param>
/// <param name="entityId"></param>
/// <param name="relationship"></param>
/// <param name="relatedEntities"></param>
/// <exception cref="NotImplementedException"></exception>
public void Associate(string entityName, Guid entityId, Relationship relationship, EntityReferenceCollection relatedEntities)
{
if (this.Original != null)
{
this.Original.Associate(entityName, entityId, relationship, relatedEntities);
}
}
public virtual void Disassociate(string entityName, Guid entityId, Relationship relationship, EntityReferenceCollection relatedEntities)
{
CapturedInput.EntityId = entityId;
CapturedInput.EntityName = entityName;
CapturedInput.Relationship = relationship;
CapturedInput.RelatedEntities = relatedEntities;
}
public void ApplyRulesToUser(EntityReferenceCollection ec, Guid userId)
{
var request = new InstantiateFiltersRequest
{
UserId = userId,
TemplateCollection = ec
};
service.Execute(request);
}
/// <summary>
/// Binds the references to those already in the data store (or skips those which are new).
/// </summary>
/// <param name="references">The collection of references to be bound.</param>
public virtual void BindReferences(EntityReferenceCollection references)
{
// TODO: Comment out logging
// Logging commented out to boost performance
using (LogGroup logGroup = LogGroup.Start("Binding the provided references with those in the data store.", LogLevel.Debug))
{
if (references == null)
throw new ArgumentNullException("references");
LogWriter.Debug("Total #: " + references.Count.ToString());
for (int i = 0; i < references.Count; i++)
{
EntityReference reference = references[i];
bool isBound = DataAccess.Data.IsBound(reference);
bool exists = DataAccess.Data.IsStored(reference);
if (exists && !isBound)
{
LogWriter.Debug("Already exists: " + exists.ToString());
Type type1 = EntityState.GetType(reference.Type1Name);
Type type2 = EntityState.GetType(reference.Type2Name);
EntityReference foundReference = DataAccess.Data.Referencer
.GetReference(type1,
reference.Entity1ID,
reference.Property1Name,
type2,
reference.Entity2ID,
reference.Property2Name,
false);
if (foundReference != null)
{
// Copy the unbound info to the bound object
references[i].CopyTo(foundReference);
// Put the bound object back into the list in place of the unbound object
references[i] = foundReference;
LogWriter.Debug("Found corresponding reference. Binding.");
}
else
throw new Exception("Reference matched IsStored check but failed to load.");
}
else
LogWriter.Debug("Doesn't exist. Skipping.");
}
}
}
/// <summary>
/// Create and configure the organization service proxy.
/// Create a team, a queue and a role.
/// Add read queue privileges to the role.
/// Assign the role to the team so that they can read the queue.
/// Assign the queue to the team.
/// Optionally delete any entity records that were created for this sample.
/// </summary>
/// <param name="serverConfig">Contains server connection information.</param>
/// <param name="promptForDelete">When True, the user will be prompted to delete
/// all created entities.</param>
public void Run(ServerConnection.Configuration serverConfig, bool promptForDelete)
{
try
{
// Connect to the Organization service.
// The using statement assures that the service proxy will be properly disposed.
using (_serviceProxy = new OrganizationServiceProxy(serverConfig.OrganizationUri, serverConfig.HomeRealmUri,
serverConfig.Credentials, serverConfig.DeviceCredentials))
{
_service = (IOrganizationService)_serviceProxy;
// Call the method to create any data that this sample requires.
CreateRequiredRecords();
//<snippetAssociateDisassociateDE1>
// The account ID would typically be passed in as an argument or determined by a query.
// The contact ID would typically be passed in as an argument or determined by a query.
// Associate the accounts to the contact record.
//Create a collection of the entity ids that will be associated to the contact.
EntityReferenceCollection relatedEntities = new EntityReferenceCollection();
relatedEntities.Add(new EntityReference("account", _account1Id));
relatedEntities.Add(new EntityReference("account", _account2Id));
relatedEntities.Add(new EntityReference("account", _account3Id));
// Create an object that defines the relationship between the contact and account.
Relationship relationship = new Relationship("account_primary_contact");
//Associate the contact with the 3 accounts.
_service.Associate("contact", _contactId, relationship, relatedEntities);
Console.WriteLine("The entities have been associated.");
//Disassociate the records.
_service.Disassociate("contact", _contactId, relationship, relatedEntities);
//</snippetAssociateDisassociateDE1>
Console.WriteLine("The entities have been disassociated.");
DeleteRequiredRecords(promptForDelete);
}
}
// Catch any service fault exceptions that Microsoft Dynamics CRM throws.
catch (FaultException<Microsoft.Xrm.Sdk.OrganizationServiceFault>)
{
// You can handle an exception here or pass it back to the calling method.
throw;
}
}
/// <summary>
/// Deletes the provided obsolete references.
/// </summary>
/// <param name="references">The array of references to delete.</param>
public virtual void DeleteObsoleteReferences(EntityReferenceCollection references)
{
using (LogGroup logGroup2 = LogGroup.Start("Deleting provided obsolete references.", LogLevel.Debug))
{
LogWriter.Debug("References: " + references.Count);
foreach (EntityReference reference in references)
{
if (DataAccess.Data.IsStored(reference))
{
LogWriter.Debug("Deleting reference.");
DataAccess.Data.Stores[reference].Deleter.Delete((IEntity)reference);
}
else
LogWriter.Debug("Reference not stored. Skipping.");
}
}
}
/// <summary>
/// Create an email record using the given dictionary to replace dynamic fields
/// </summary>
/// <param name="templateName">Name of existing Email template</param>
/// <param name="userId">User GUID that will be used to Instantiate Template. See CRM SDK InstantiateTemplateRequest</param>
/// <param name="dictionary">[Optional] Collection of dynamic fields within the template to be replaced</param>
/// <param name="context">[Optional] Exisiting CRM record that sets the root context where dynamics
/// fields values within the template will be taken from</param>
/// <param name="regarding">[Optional] Email regarding record</param>
/// <param name="from">Email sender (activityparty record type)</param>
/// <param name="toRecipient">List of recipients (activityparty record type)</param>
/// <param name="attachments">List of attachment names (e.g. "DXTools - Payments.pdf")</param>
/// <param name="allowDuplicateAttachments">
/// If allowDuplicateAttachments = True, two or more attachments are allowed with the same filename
/// </param>
/// <param name="onlyAttachmentsInTemplate">
/// If onlyUseAttachmentsInTemplate = True, the attachments to be considered will be only the ones
/// in the given template. Otherwise, it will search across any attachment
/// </param>
/// <returns>New Email record</returns>
public Entity CreateEmail(string templateName, Guid userId, Dictionary <string, string> dictionary, EntityReference context, EntityReference regarding, EntityReference from, EntityReferenceCollection toRecipient, string[] attachments, bool allowDuplicateAttachments, bool onlyUseAttachmentsInTemplate)
{
Entity template = RetrieveEmailTemplate(templateName);
Entity email = GetEmailInstantiateFromTemplate(template, userId);
ProcessEmailText(email, dictionary, context);
CreateEmail(email, regarding, from, toRecipient);
CreateActivityMimeAttachments(template, email, attachments, allowDuplicateAttachments, onlyUseAttachmentsInTemplate);
return(email);
}
/// <summary>
/// Create an email record using the given dictionary to replace dynamic fields
/// </summary>
/// <param name="templateName">Name of existing Email template</param>
/// <param name="userId">User GUID that will be used to Instantiate Template. See CRM SDK InstantiateTemplateRequest</param>
/// <param name="context">Exisiting CRM record that sets the root context where dynamics
/// fields values within the template will be taken from</param>
/// <param name="regarding">[Optional] Email regarding record</param>
/// <param name="from">Email sender (activityparty record type)</param>
/// <param name="toRecipient">List of recipients (activityparty record type)</param>
/// <param name="attachments">List of attachment names (e.g. "DXTools - Payments.pdf")</param>
/// <param name="allowDuplicateAttachments">
/// If allowDuplicateAttachments = True, two or more attachments are allowed with the same filename
/// </param>
/// <param name="onlyUseAttachmentsInTemplate">
/// If onlyAttachmentsInTemplate = True, the attachments to be considered will be only the ones
/// in the given template. Otherwise, it will search across any attachment
/// </param>
/// <returns>New Email record</returns>
public Entity CreateEmail(string templateName, Guid userId, EntityReference context, EntityReference regarding, EntityReference from, EntityReferenceCollection toRecipient, string[] attachments, bool allowDuplicateAttachments, bool onlyUseAttachmentsInTemplate)
{
return(CreateEmail(templateName, userId, null, context, regarding, from, toRecipient, attachments, allowDuplicateAttachments, onlyUseAttachmentsInTemplate));
}
/// <summary>
/// Create and configure the organization service proxy.
/// Verify if knowledge management is enabled for the
/// Incident entity.
/// Create sample records (account and incident).
/// Create a knowledge base record.
/// Associate the knowledge base record to entity record.
/// Dissociate the knowledge base record from entity record.
/// Optionally delete/revert any records
/// that were created/changed for this sample.
/// </summary>
/// <param name="serverConfig">Contains server connection information.</param>
/// <param name="promptForDelete">When True, the user will be prompted to delete all
/// created entities.</param>
public void Run(ServerConnection.Configuration serverConfig, bool promptForDelete)
{
try
{
// Connect to the Organization service.
// The using statement assures that the service proxy will be properly disposed.
using (_serviceProxy = new OrganizationServiceProxy(serverConfig.OrganizationUri, serverConfig.HomeRealmUri, serverConfig.Credentials, serverConfig.DeviceCredentials))
{
// This statement is required to enable early-bound type support.
_serviceProxy.EnableProxyTypes();
if (CheckCRMVersion() == true)
{
// Check if knowledge management is enabled
// for the Incident entity.
CheckKnowledgeManagementStatus();
// Create required records for the sample.
CreateRequiredRecords();
// Create a knowledge base record instance
KnowledgeBaseRecord kbRecord = new KnowledgeBaseRecord
{
// These are sample values. Replace them with
// appropriate values as per your integrated
// Parature instance.
PrivateUrl = "https://www.demo.parature.com/internal",
PublicUrl = "https://www.demo.parature.com",
Title = "How to track shipping?",
UniqueId = "8000/8467/Article/23782"
};
_kbRecordId = _serviceProxy.Create(kbRecord);
Console.WriteLine("Created knowledge base record with ID: '{0}'.\n", _kbRecordId.ToString());
// Associate the knowledge base record with an incident record
// Step 1: Create a collection of knowledge base record that will be
// associated to the incident. In this case, we have only a single
// knowledge base record to be associated.
EntityReferenceCollection relatedEntities = new EntityReferenceCollection();
relatedEntities.Add(new EntityReference(KnowledgeBaseRecord.EntityLogicalName, _kbRecordId));
// Step 2: Create an object that defines the relationship between knowledge base record and incident.
// Use the many-to-many relationship name (KnowledgeBaseRecord_Incident) between knowledge base
// record and incident.
Relationship relationship = new Relationship("KnowledgeBaseRecord_Incident");
// Step 3: Associate the knowledge base record with the incident record.
_serviceProxy.Associate(Incident.EntityLogicalName, _incidentId, relationship,
relatedEntities);
// Check to see if the association record is created in the
// IncidentKnowledgeBaseRecord intersect entity
QueryExpression associationQuery = new QueryExpression
{
EntityName = IncidentKnowledgeBaseRecord.EntityLogicalName,
ColumnSet = new ColumnSet("incidentid", "knowledgebaserecordid"),
Criteria = new FilterExpression
{
Conditions =
{
new ConditionExpression
{
AttributeName = "incidentid",
Operator = ConditionOperator.Equal,
Values = { _incidentId }
},
new ConditionExpression
{
AttributeName = "knowledgebaserecordid",
Operator = ConditionOperator.Equal,
Values = { _kbRecordId }
}
}
},
PageInfo = new PagingInfo
{
PageNumber = 1,
Count = 1
}
};
DataCollection <Entity> entityCollection = _serviceProxy.RetrieveMultiple(associationQuery).Entities;
if (entityCollection.Count() > 0)
{
Console.WriteLine("Associated knowledge base record with the incident record.");
// Disassociate the records.
_serviceProxy.Disassociate(Incident.EntityLogicalName, _incidentId, relationship,
relatedEntities);
Console.WriteLine("Disasociated knowledge base record from the incident record.\n");
}
else
{
Console.WriteLine("Could not associate knowledge base record with the incident record.\n");
}
// Prompt the user to delete the records and attribute created by the sample.
DeleteRequiredRecords(promptForDelete);
}
else
{
Console.WriteLine("Aborting the sample.");
}
}
}
// Catch any service fault exceptions that Microsoft Dynamics CRM throws.
catch (FaultException <Microsoft.Xrm.Sdk.OrganizationServiceFault> )
{
// You can handle an exception here or pass it back to the calling method.
throw;
}
}
public abstract IEntity[] GetEntitiesWithReference(IEntity entity, string propertyName, EntityReferenceCollection references);
/// <summary>internal</summary>
protected internal virtual void AssociateCore(
string entityName,
Guid entityId,
Relationship relationship,
EntityReferenceCollection relatedEntities)
{
bool?retry = new bool?();
do
{
bool forceClose = false;
try
{
using (new OrganizationServiceContextInitializer(this))
{
this.ServiceChannel.Channel.Associate(entityName, entityId, relationship, relatedEntities);
break;
}
}
catch (MessageSecurityException ex)
{
forceClose = true;
retry = this.ShouldRetry(ex, retry);
if (!retry.GetValueOrDefault())
{
throw;
}
}
catch (EndpointNotFoundException ex)
{
forceClose = true;
retry = new bool?(this.HandleFailover(retry));
if (!retry.GetValueOrDefault())
{
throw;
}
}
catch (TimeoutException ex)
{
forceClose = true;
retry = new bool?(this.HandleFailover(retry));
if (!retry.GetValueOrDefault())
{
throw;
}
}
catch (FaultException <OrganizationServiceFault> ex)
{
forceClose = true;
retry = this.HandleFailover((BaseServiceFault)ex.Detail, retry);
if (!retry.GetValueOrDefault())
{
throw;
}
}
catch
{
forceClose = true;
throw;
}
finally
{
this.CloseChannel(forceClose);
}
}while (retry.HasValue && retry.Value);
}
public void Associate(string entityName, Guid entityId, Relationship relationship, EntityReferenceCollection relatedEntities)
{
throw new NotImplementedException();
}
protected internal Guid CreateEntity(Entity e)
{
if (e == null)
{
throw new InvalidOperationException("The entity must not be null");
}
var clone = e.Clone(e.GetType());
if (clone.Id == Guid.Empty)
{
clone.Id = Guid.NewGuid(); // Add default guid if none present
}
// Hack for Dynamic Entities where the Id property doesn't populate the "entitynameid" primary key
var primaryKeyAttribute = $"{e.LogicalName}id";
if (!clone.Attributes.ContainsKey(primaryKeyAttribute))
{
clone[primaryKeyAttribute] = clone.Id;
}
ValidateEntity(clone);
// Create specific validations
if (clone.Id != Guid.Empty && Data.ContainsKey(clone.LogicalName) &&
Data[clone.LogicalName].ContainsKey(clone.Id))
{
throw new InvalidOperationException($"There is already a record of entity {clone.LogicalName} with id {clone.Id}, can't create with this Id.");
}
// Create specific validations
if (clone.Attributes.ContainsKey("statecode"))
{
throw new InvalidOperationException($"When creating an entity with logical name '{clone.LogicalName}', or any other entity, it is not possible to create records with the statecode property. Statecode must be set after creation.");
}
AddEntityWithDefaults(clone, false, this.UsePipelineSimulation);
if (e.RelatedEntities.Count > 0)
{
foreach (var relationshipSet in e.RelatedEntities)
{
var relationship = relationshipSet.Key;
var entityReferenceCollection = new EntityReferenceCollection();
foreach (var relatedEntity in relationshipSet.Value.Entities)
{
var relatedId = CreateEntity(relatedEntity);
entityReferenceCollection.Add(new EntityReference(relatedEntity.LogicalName, relatedId));
}
if (FakeMessageExecutors.ContainsKey(typeof(AssociateRequest)))
{
var request = new AssociateRequest
{
Target = clone.ToEntityReference(),
Relationship = relationship,
RelatedEntities = entityReferenceCollection
};
FakeMessageExecutors[typeof(AssociateRequest)].Execute(request, this);
}
else
{
throw PullRequestException.NotImplementedOrganizationRequest(typeof(AssociateRequest));
}
}
}
return(clone.Id);
}
public virtual void Disassociate(string entityName, Guid entityId, Relationship relationship, EntityReferenceCollection relatedEntities)
{
Service.Disassociate(entityName, entityId, relationship, relatedEntities);
}
private void Disassociate(CrmDbContext context, ContentMap map, EntityReference target, Relationship relationship, EntityReferenceCollection relatedEntities)
{
target.ThrowOnNull("target");
relationship.ThrowOnNull("relationship");
relatedEntities.ThrowOnNull("relatedEntities");
ADXTrace.Instance.TraceInfo(TraceCategory.Application, string.Format("Target: LogicalName={0}, Id={1}", EntityNamePrivacy.GetEntityName(target.LogicalName), target.Id));
ADXTrace.Instance.TraceInfo(TraceCategory.Application, string.Format("Relationship: SchemaName={0}, PrimaryEntityRole={1}", relationship.SchemaName, relationship.PrimaryEntityRole));
foreach (var entity in relatedEntities)
{
ADXTrace.Instance.TraceInfo(TraceCategory.Application, string.Format("Related: LogicalName={0}, Id={1}", EntityNamePrivacy.GetEntityName(entity.LogicalName), entity.Id));
}
var entities = new List <EntityReference>();
if (this.EventHubJobSettings.IsEnabled)
{
//logic to ignore to get Intersect entity which we already have in eventhub model.
EntityReference intersectEntity = new EntityReference();
intersectEntity.LogicalName = target.LogicalName;
intersectEntity.Id = target.Id;
entities.Add(intersectEntity);
}
else
{
// validate that the relationships do in fact not exist by querying for the intersects
entities = map.Using(ContentMapLockType.Read, () => RetrieveDisassociatedIntersectEntities(context, map, target, relationship, relatedEntities).ToList());
}
if (entities != null)
{
// add intersect entities to the content map
map.Using(ContentMapLockType.Write, () => map.RemoveRange(entities));
}
}
public void Disassociate(string entityName, Guid entityId, Relationship relationship, EntityReferenceCollection relatedEntities)
{
this.ExecuteSoapRequest <DisassociateRequest, DisassociateResponse>(
new DisassociateRequest(entityName, entityId, relationship, relatedEntities));
}
public virtual void Disassociate(ContentMap map, EntityReference target, Relationship relationship, EntityReferenceCollection relatedEntities)
{
using (var context = this.CreateContext())
{
this.Disassociate(context, map, target, relationship, relatedEntities);
}
}
private static void Associate(CrmDbContext context, ContentMap map, EntityReference target, Relationship relationship, EntityReferenceCollection relatedEntities)
{
target.ThrowOnNull("target");
relationship.ThrowOnNull("relationship");
relatedEntities.ThrowOnNull("relatedEntities");
ADXTrace.Instance.TraceInfo(TraceCategory.Application, string.Format("Target: LogicalName={0}, Id={1}", EntityNamePrivacy.GetEntityName(target.LogicalName), target.Id));
ADXTrace.Instance.TraceInfo(TraceCategory.Application, string.Format("Relationship: SchemaName={0}, PrimaryEntityRole={1}", relationship.SchemaName, relationship.PrimaryEntityRole));
foreach (var entity in relatedEntities)
{
ADXTrace.Instance.TraceInfo(TraceCategory.Application, string.Format("Related: LogicalName={0}, Id={1}", EntityNamePrivacy.GetEntityName(entity.LogicalName), entity.Id));
}
// validate that the relationships do in fact exist by querying for the intersects
var entities = map.Using(ContentMapLockType.Read, () => RetrieveIntersectEntities(context, map, target, relationship, relatedEntities));
if (entities != null)
{
// add intersect entities to the content map
map.Using(ContentMapLockType.Write, () => map.AddRange(entities));
foreach (var added in entities)
{
ADXTrace.Instance.TraceInfo(TraceCategory.Application, string.Format("Added: LogicalName={0}, Id={1}", EntityNamePrivacy.GetEntityName(added.LogicalName), added.Id));
}
}
}
/// <summary>
/// Creates the Association
/// </summary>
/// <param name="service">The service.</param>
/// <param name="entityName">Type: String. The logical name of the entity that is specified in the <paramref name="entityId" /> parameter.</param>
/// <param name="entityId">Type: Guid. The Id of the record to which the related records are associated.</param>
/// <param name="relationship">Type: <see cref="T:Microsoft.Xrm.Sdk.Relationship" />. The name of the relationship to be used to create the link.</param>
/// <param name="relatedEntities">Type: <see cref="T:Microsoft.Xrm.Sdk.EntityReferenceCollection" />. A collection of entity references (references to records) to be associated.</param>
public Guid[] CreateAssociation(IOrganizationService service, string entityName, Guid entityId, Relationship relationship, EntityReferenceCollection relatedEntities)
{
if (!DefinitionsByRelationshipName.TryGetValue(relationship.SchemaName, out var definition))
{
throw new KeyNotFoundException($"Schema name {relationship.SchemaName} was not found in the DefinitionsByRelationshipName dictionary.");
}
var primaryAttributeName = entityName == definition.PrimaryEntityType
? definition.PrimaryEntityIdName
: definition.AssociatedEntityIdName;
var associatedAttributeName = entityName == definition.PrimaryEntityType
? definition.AssociatedEntityIdName
: definition.PrimaryEntityIdName;
var ids = new List <Guid>();
foreach (var relation in relatedEntities.Select(relatedEntity => new Entity(definition.AssociationLogicalName)
{
[primaryAttributeName] = entityId,
[associatedAttributeName] = relatedEntity.Id
}))
{
ids.Add(service.Create(relation));
}
return(ids.ToArray());
}
internal IAsyncResult BeginAssociate(string entityName, Guid entityId, Relationship relationship, EntityReferenceCollection relatedEntities, AsyncCallback callback, object asyncState, CancellationToken cancellationToken)
=> AsyncCallOperation <int> .Begin("Associate", callback, asyncState, cancellationToken,
createContext : () => new OrganizationServiceContextInitializer(this),
tryBegin : TryRun,
tryEnd : TryRun,
beginOperation : (_callback, _state) => base.ServiceChannel.Channel.BeginAssociate(entityName, entityId, relationship, relatedEntities, _callback, _state),
endOperation : (_asynResult) => { base.ServiceChannel.Channel.EndAssociate(_asynResult); return(0); },
cancelOperation : (_asyncResult) => base.ServiceChannel.Abort());
/// <inheritdoc />
public void Disassociate(string entityName, Guid entityId, Relationship relationship, EntityReferenceCollection relatedEntities)
{
var message = Settings.LogDetailedRequests
? $"Disassociate Request for {entityName}, with Id {entityId}, Relationship {relationship.SchemaName}, and Related Entities {relatedEntities.Select(e => e.ToStringDebug()).ToCsv()}."
: "Disassociate Request";
if (Settings.TimeRequests)
{
var timer = new Stopwatch();
try
{
TraceStart(message);
timer.Start();
Service.Disassociate(entityName, entityId, relationship, relatedEntities);
return;
}
finally
{
TraceEnd(timer);
}
}
TraceExecute(message);
Service.Disassociate(entityName, entityId, relationship, relatedEntities);
}
/// <summary>
/// Imports the specified profile.
/// </summary>
/// <param name="profile">The profile.</param>
/// <param name="transportReportFileName">Name of the transport report file.</param>
private void Import(NtoNAssociationsTransportProfile profile, string transportReportFileName)
{
int totalTreatedRecords = 0;
int totalImportFailures = 0;
int totalImportSuccess = 0;
int ReconnectionRetryCount = 5;
try
{
NtoNTransportReport report = new NtoNTransportReport(transportReportFileName);
//Get Transport Report
if (File.Exists(transportReportFileName))
{
report = ReadTransportReport(transportReportFileName);
}
MSCRMConnection connection = profile.getTargetConneciton(); ;
_serviceProxy = cm.connect(connection);
IOrganizationService service = (IOrganizationService)_serviceProxy;
LogManager.WriteLog("Start importing data in " + connection.ConnectionName);
//Mesure import time
DateTime importStartDT = DateTime.Now;
//es = ReadEnvStructure(profile.SourceConnectionName);
foreach (SelectedNtoNRelationship ee in profile.SelectedNtoNRelationships)
{
//Check if there are any records to import
if (ee.ExportedRecords == 0)
{
continue;
}
//Mesure import time
DateTime entityImportStartDT = DateTime.Now;
string entityFolderPath = Folder + "\\" + profile.ProfileName + "\\Data\\" + ee.RelationshipSchemaName;
string[] filePaths = Directory.GetFiles(entityFolderPath, "*.xml");
LogManager.WriteLog("Importing " + ee.RelationshipSchemaName + " records.");
int treatedRecordsForEntity = 0;
int importedRecordsForEntity = 0;
int importFailuresForEntity = 0;
foreach (string filePath in filePaths)
{
List<Type> knownTypes = new List<Type>();
knownTypes.Add(typeof(Entity));
XmlDictionaryReaderQuotas XRQ = new XmlDictionaryReaderQuotas();
XRQ.MaxStringContentLength = int.MaxValue;
using(FileStream fs = new FileStream(filePath, FileMode.Open))
using (XmlDictionaryReader reader = XmlDictionaryReader.CreateTextReader(fs, XRQ))
{
DataContractSerializer ser = new DataContractSerializer(typeof(EntityCollection), knownTypes);
EntityCollection fromDisk = (EntityCollection)ser.ReadObject(reader, true);
foreach (Entity en in fromDisk.Entities)
{
EntityReference relatedEntity1 = new EntityReference();
EntityReference relatedEntity2 = new EntityReference();
try
{
Guid relatedEntity1Id = getRelatedEntityGuid(en[ee.Entity1IntersectAttribute]);
Guid relatedEntity2Id = getRelatedEntityGuid(en[ee.Entity2IntersectAttribute]);
relatedEntity1 = new EntityReference { LogicalName = ee.Entity1LogicalName, Id = relatedEntity1Id };
relatedEntity2 = new EntityReference { LogicalName = ee.Entity2LogicalName, Id = relatedEntity2Id };
if (!AlreadyAssociated(_serviceProxy, ee, relatedEntity1Id, relatedEntity2Id))
{
if (ee.IntersectEntityName == "listmember")
{
Guid entity_id = Guid.Empty;
Guid list_id = Guid.Empty;
if (ee.Entity1LogicalName == "list")
{
entity_id = relatedEntity2Id;
list_id = relatedEntity1Id;
}
else
{
entity_id = relatedEntity1Id;
list_id = relatedEntity2Id;
}
AddMemberListRequest request = new AddMemberListRequest();
request.EntityId = entity_id;
request.ListId = list_id;
AddMemberListResponse response = (AddMemberListResponse)service.Execute(request);
}
else if (ee.IntersectEntityName == "campaignitem")
{
Guid entity_id = Guid.Empty;
Guid list_id = Guid.Empty;
string EntityName = "";
if (ee.Entity1LogicalName == "campaign")
{
entity_id = relatedEntity2Id;
list_id = relatedEntity1Id;
EntityName = (string)en["entitytype"];
relatedEntity2.LogicalName = EntityName;
}
else
{
entity_id = relatedEntity1Id;
list_id = relatedEntity2Id;
EntityName = (string)en["entitytype"];
relatedEntity1.LogicalName = EntityName;
}
AddItemCampaignRequest req = new AddItemCampaignRequest();
req.CampaignId = relatedEntity1Id;
req.EntityName = EntityName;
req.EntityId = entity_id;
AddItemCampaignResponse resp = (AddItemCampaignResponse)service.Execute(req);
}
else if (ee.IntersectEntityName == "campaignactivityitem")
{
Guid entity_id = Guid.Empty;
Guid list_id = Guid.Empty;
string EntityName = "";
if (ee.Entity1LogicalName == "campaignactivity")
{
entity_id = relatedEntity2Id;
list_id = relatedEntity1Id;
EntityName = (string)en["itemobjecttypecode"];
relatedEntity2.LogicalName = EntityName;
}
else
{
entity_id = relatedEntity1Id;
list_id = relatedEntity2Id;
EntityName = (string)en["itemobjecttypecode"];
relatedEntity1.LogicalName = EntityName;
}
AddItemCampaignActivityRequest req = new AddItemCampaignActivityRequest();
req.CampaignActivityId = relatedEntity1Id;
req.EntityName = EntityName;
req.ItemId = entity_id;
AddItemCampaignActivityResponse resp = (AddItemCampaignActivityResponse)service.Execute(req);
}
else
{
EntityReferenceCollection relatedEntities = new EntityReferenceCollection();
relatedEntities.Add(relatedEntity2);
Relationship relationship = new Relationship(ee.RelationshipSchemaName);
relationship.PrimaryEntityRole = EntityRole.Referencing;
service.Associate(relatedEntity1.LogicalName, relatedEntity1.Id, relationship, relatedEntities);
}
}
importedRecordsForEntity++;
totalImportSuccess++;
}
catch (FaultException<Microsoft.Xrm.Sdk.OrganizationServiceFault> ex)
{
totalImportFailures++;
importFailuresForEntity++;
NtoNRelationshipsImportFailure failure = new NtoNRelationshipsImportFailure
{
CreatedOn = DateTime.Now.ToString(),
NtoNRelationshipName = ee.RelationshipSchemaName,
Reason = ex.Detail.Message,
UrlEntity1 = profile.getSourceConneciton().ServerAddress + "main.aspx?pagetype=entityrecord&etn=" + relatedEntity1.LogicalName + "&id=" + relatedEntity1.Id.ToString(),
UrlEntity2 = profile.getSourceConneciton().ServerAddress + "main.aspx?pagetype=entityrecord&etn=" + relatedEntity2.LogicalName + "&id=" + relatedEntity2.Id.ToString()
};
report.TotalImportFailures += 1;
//Insert the Failure line in the Failures Report
WriteNewImportFailureLine(failure, importFailuresReportFileName);
}
catch (Exception ex)
{
//Check if the authentification session is expired
if (ex.InnerException != null && ex.InnerException.Message.StartsWith("ID3242"))
{
LogManager.WriteLog("Error:The CRM authentication session expired. Reconnection attempt n° " + ReconnectionRetryCount);
ReconnectionRetryCount--;
//On 5 failed reconnections exit
if (ReconnectionRetryCount == 0)
throw;
_serviceProxy = cm.connect(connection);
service = (IOrganizationService)_serviceProxy;
LogManager.WriteLog("Error:The CRM authentication session expired.");
totalImportFailures++;
importFailuresForEntity++;
NtoNRelationshipsImportFailure failure = new NtoNRelationshipsImportFailure
{
CreatedOn = DateTime.Now.ToString(),
NtoNRelationshipName = ee.RelationshipSchemaName,
Reason = ex.InnerException.Message,
UrlEntity1 = profile.getSourceConneciton().ServerAddress + "main.aspx?pagetype=entityrecord&etn=" + relatedEntity1.LogicalName + "&id=" + relatedEntity1.Id.ToString(),
UrlEntity2 = profile.getSourceConneciton().ServerAddress + "main.aspx?pagetype=entityrecord&etn=" + relatedEntity2.LogicalName + "&id=" + relatedEntity2.Id.ToString()
};
report.TotalImportFailures += 1;
//Insert the Failure line in the Failures Report
WriteNewImportFailureLine(failure, importFailuresReportFileName);
}
else
{
throw;
}
}
totalTreatedRecords++;
treatedRecordsForEntity++;
updateTransportReport(report, ee, importedRecordsForEntity, importFailuresForEntity, entityImportStartDT);
}
}
}
LogManager.WriteLog("Treated " + treatedRecordsForEntity + " " + ee.RelationshipSchemaName + " records with " + importedRecordsForEntity + " successfully imported records and " + importFailuresForEntity + " failures.");
}
TimeSpan importTimeSpan = DateTime.Now - importStartDT;
LogManager.WriteLog("Import finished for " + connection.ConnectionName + ". Treated " + totalTreatedRecords + " records in " + importTimeSpan.ToString().Substring(0, 10) + ". Successfuly imported " + totalImportSuccess + " records and " + totalImportFailures + " failures.");
WriteTransportReport(report, transportReportFileName);
}
catch (FaultException<Microsoft.Xrm.Sdk.OrganizationServiceFault> ex)
{
LogManager.WriteLog("Error:" + ex.Detail.Message + "\n" + ex.Detail.TraceText);
}
catch (Exception ex)
{
if (ex.InnerException != null)
LogManager.WriteLog("Error:" + ex.Message + "\n" + ex.InnerException.Message);
else
{
LogManager.WriteLog("Error:" + ex.Message);
}
}
}
public void Disassociate(string entityName, Guid entityId, Relationship relationship, EntityReferenceCollection relatedEntities)
{
ThrowExceptionIfDisposed();
try
{
_serviceProxy.Disassociate(entityName, entityId, relationship, relatedEntities);
}
catch (Exception ex)
{
Helpers.DTEHelper.WriteExceptionToLog(ex);
throw;
}
}
public void Disassociate(string entityName, Guid entityId, Relationship relationship, EntityReferenceCollection relatedEntities)
{
OrganizationService.Disassociate(entityName, entityId, relationship, relatedEntities);
}
public void Associate(string entityName, Guid entityId, Relationship relationship, EntityReferenceCollection relatedEntities)
{
service.Associate(entityName, entityId, relationship, relatedEntities);
}
/// <summary>
/// This method first connects to the Outlook service. Afterwards,
/// client information is retrieved and the client state is changed.
/// </summary>
/// <param name="serverConfig">Contains server connection information.</param>
/// <param name="promptforDelete">When True, the user will be prompted to delete all
/// created entities.</param>
public void Run(ServerConnection.Configuration serverConfig, bool promptforDelete)
{
try
{
// Connect to the Organization service.
// The using statement assures that the service proxy will be properly disposed.
using (_serviceProxy = new OrganizationServiceProxy(serverConfig.OrganizationUri, serverConfig.HomeRealmUri,serverConfig.Credentials, serverConfig.DeviceCredentials))
{
// This statement is required to enable early-bound type support.
_serviceProxy.EnableProxyTypes();
//<snippetRetrieveDataFilters1>
// Create and Retrieve Offline Filter
// In your Outlook client, this will appear in the System Filters tab
// under File | CRM | Synchronize | Outlook Filters.
Console.Write("Creating offline filter");
String contactName = String.Format("offlineFilteredContact {0}",
DateTime.Now.ToLongTimeString());
String fetchXml = String.Format("<fetch version=\"1.0\" output-format=\"xml-platform\" mapping=\"logical\"><entity name=\"contact\"><attribute name=\"contactid\" /><filter type=\"and\">" +
"<condition attribute=\"ownerid\" operator=\"eq-userid\" /><condition attribute=\"description\" operator=\"eq\" value=\"{0}\" />" +
"<condition attribute=\"statecode\" operator=\"eq\" value=\"0\" /></filter></entity></fetch>", contactName);
SavedQuery filter = new SavedQuery();
filter.FetchXml = fetchXml;
filter.IsQuickFindQuery = false;
filter.QueryType = SavedQueryQueryType.OfflineFilters;
filter.ReturnedTypeCode = Contact.EntityLogicalName;
filter.Name = "ReadOnlyFilter_" + contactName;
filter.Description = "Sample offline filter for Contact entity";
_offlineFilter = _serviceProxy.Create(filter);
Console.WriteLine(" and retrieving offline filter");
SavedQuery result = (SavedQuery)_serviceProxy.Retrieve(
SavedQuery.EntityLogicalName,
_offlineFilter,
new ColumnSet("name", "description"));
Console.WriteLine("Name: {0}", result.Name);
Console.WriteLine("Description: {0}", result.Description);
Console.WriteLine();
// Create and Retrieve Offline Template
// In your Outlook client, this will appear in the User Filters tab
// under File | CRM | Synchronize | Outlook Filters.
Console.Write("Creating offline template");
String accountName = String.Format("offlineFilteredAccount {0}",
DateTime.Now.ToLongTimeString());
fetchXml = String.Format("<fetch version=\"1.0\" output-format=\"xml-platform\" mapping=\"logical\"><entity name=\"account\"><attribute name=\"accountid\" /><filter type=\"and\">" +
"<condition attribute=\"ownerid\" operator=\"eq-userid\" /><condition attribute=\"name\" operator=\"eq\" value=\"{0}\" />" +
"<condition attribute=\"statecode\" operator=\"eq\" value=\"0\" /></filter></entity></fetch>", accountName);
SavedQuery template = new SavedQuery();
template.FetchXml = fetchXml;
template.IsQuickFindQuery = false;
template.QueryType = SavedQueryQueryType.OfflineTemplate;
template.ReturnedTypeCode = Account.EntityLogicalName;
template.Name = "ReadOnlyFilter_" + accountName;
template.Description = "Sample offline template for Account entity";
_offlineTemplate = _serviceProxy.Create(template);
Console.WriteLine(" and retrieving offline template");
result = (SavedQuery)_serviceProxy.Retrieve(
SavedQuery.EntityLogicalName,
_offlineTemplate,
new ColumnSet("name", "description"));
Console.WriteLine("Name: {0}", result.Name);
Console.WriteLine("Description: {0}", result.Description);
Console.WriteLine();
//</snippetRetrieveDataFilters1>
//<snippetRetrieveDataFilters2>
// Call InstantiateFiltersRequest
Console.WriteLine("Retrieving user's ID and creating the template collection");
WhoAmIRequest whoAmI = new WhoAmIRequest();
Guid id = ((WhoAmIResponse)_serviceProxy.Execute(whoAmI)).UserId;
EntityReferenceCollection templates = new EntityReferenceCollection();
templates.Add(new EntityReference(
SavedQuery.EntityLogicalName,
_offlineTemplate));
Console.WriteLine("Activating the selected offline templates for this user");
InstantiateFiltersRequest request = new InstantiateFiltersRequest
{
UserId = id,
TemplateCollection = templates
};
InstantiateFiltersResponse response =
(InstantiateFiltersResponse)_serviceProxy.Execute(request);
Console.WriteLine();
//</snippetRetrieveDataFilters2>
//<snippetRetrieveDataFilters3>
// Call ResetUserFiltersRequest
Console.WriteLine("Resetting the user's offline templates to the defaults");
ResetUserFiltersRequest resetRequest = new ResetUserFiltersRequest
{
QueryType = SavedQueryQueryType.OfflineFilters
};
ResetUserFiltersResponse resetResponse =
(ResetUserFiltersResponse)_serviceProxy.Execute(resetRequest);
Console.WriteLine();
//</snippetRetrieveDataFilters3>
DeleteRequiredRecords(promptforDelete);
}
}
// Catch any service fault exceptions that Microsoft Dynamics CRM throws.
catch (FaultException<Microsoft.Xrm.Sdk.OrganizationServiceFault>)
{
// You can handle an exception here or pass it back to the calling method.
throw;
}
}
public DisassociateRequest(string entityName, Guid entityId, Relationship relationship, EntityReferenceCollection relatedEntities)
{
this.EntityName = entityName;
this.EntityId = entityId;
this.Relationship = relationship;
this.RelatedEntities = relatedEntities;
}
/// <summary>
/// Delete all remaining entity records that were created by this sample.
/// <param name="prompt">When true, the user is prompted whether
/// the records created in this sample should be deleted; otherwise, false.</param>
/// </summary>
public void DeleteEntityRecords(OrganizationServiceProxy service,
EntityReferenceCollection records, bool prompt)
{
bool deleteRecords = true;
if (prompt)
{
Console.WriteLine("\nDo you want these entity records deleted? (y/n) [y]: ");
String answer = Console.ReadLine();
deleteRecords = (answer.StartsWith("y") || answer.StartsWith("Y") || answer == String.Empty);
}
if (deleteRecords)
{
while (records.Count > 0)
{
EntityReference entityRef = records[records.Count - 1];
Console.WriteLine("Deleting {0} '{1}' ...", entityRef.LogicalName, entityRef.Name);
service.Delete(entityRef.LogicalName, entityRef.Id);
records.Remove(entityRef);
}
Console.WriteLine("Entity records have been deleted.");
}
}
/// <summary>
/// Persists the provided references into the data store. Checks each of the provided references and saves those that are missing.
/// </summary>
/// <param name="references">The collection of entity references to persist.</param>
public virtual void PersistReferences(EntityReferenceCollection references)
{
using (LogGroup logGroup = LogGroup.Start("Persisting the provided references.", LogLevel.Debug))
{
if (references != null)
{
LogWriter.Debug("Reference count: " + references.Count.ToString());
// TODO: Check if binding is needed. Shouldn't be because
// existing references are skipped and only new references get saved
//BindReferences(references);
foreach (EntityReference reference in references)
{
// If the reference is new then save it
if (!Provider.IsStored(reference))
{
LogWriter.Debug("Reference is new. Saving.");
Provider.Saver.Save(reference);
}
// Otherwise just leave the existing reference as-is
// Existing references shouldn't need to change
}
}
}
}
/// <summary>
/// Deletes a link between records.
/// </summary>
/// <param name="entityName">The logical name of the entity specified in the entityId parameter.</param>
/// <param name="entityId">The ID of the record from which the related records will be disassociated.</param>
/// <param name="relationship">The name of the relationship to be used to remove the link.</param>
/// <param name="relatedEntities">A collection of entity references (references to records) to be disassociated.</param>
public virtual void Disassociate(string entityName, Guid entityId, Relationship relationship, EntityReferenceCollection relatedEntities)
{
}
/// <summary>
/// Retrieves the active references from the provided property. This only includes those references currently active and not those in the data store.
/// </summary>
/// <param name="entity">The entity containing the property that the references are assigned to.</param>
/// <param name="property">The property that the references are assigned to.</param>
/// <param name="mirrorPropertyName">The name of the mirror property.</param>
/// <returns>The active entity reference if it exists.</returns>
protected virtual EntityReference GetActiveReferenceFromSingleReferenceProperty(IEntity entity, PropertyInfo property, string mirrorPropertyName)
{
EntityReferenceCollection collection = new EntityReferenceCollection();
using (LogGroup logGroup = LogGroup.Start("Retrieving the reference from a single reference property.", LogLevel.Debug))
{
LogWriter.Debug("Single reference property.");
IEntity[] referencedEntities = EntitiesUtilities.GetReferencedEntities(entity, property);
if (referencedEntities != null && referencedEntities.Length > 0)
{
IEntity referencedEntity = referencedEntities[0];
// TODO: Check if this can be simplified by skipping the collection part.
// It's only a single reference so the collection is unnecessary
collection = new EntityReferenceCollection(entity, property.Name, new IEntity[] {referencedEntity}, mirrorPropertyName);
//foreach (EntityReference r in references)
//{
//LogWriter.Debug("Adding reference with ID: " + r.ID.ToString());
//LogWriter.Debug("Source entity ID: " + r.Entity1ID.ToString());
//LogWriter.Debug("Referenced entity ID: " + r.Entity2ID.ToString());
//LogWriter.Debug("Source entity name: " + r.Type1Name);
//LogWriter.Debug("Referenced entity name: " + r.Type2Name);
//}
}
else
LogWriter.Debug("referencedEntities == null || referencedEntities.Length = 0");
}
if (collection.Count > 0)
return (EntityReference)collection[0];
else
return null;
}
/// <summary>
/// Retrieves all the references to the specified entity. The specified entity can be either the source or reference entity as references work both ways.
/// </summary>
/// <param name="entityType">The type of the entity to retrieve the corresponding references for.</param>
/// <param name="entityID">The ID of the entity to retrieve the corresponding references for.</param>
/// <param name="referenceType">The type of entity at the other side of the reference to the one specified.</param>
/// <param name="activateAll">A value indicating whether to activate the references by loading the corresponding entities and setting them to the SourceEntity and ReferenceEntity properties.</param>
/// <returns>A collection of references that match the provided parameters.</returns>
public override EntityReferenceCollection GetReferences(Type entityType, Guid entityID, Type referenceType, bool activateAll)
{
EntityReferenceCollection collection = new EntityReferenceCollection();
using (LogGroup logGroup = LogGroup.StartDebug("Retrieving references."))
{
if (entityType == null)
throw new ArgumentNullException("entityType");
if (referenceType == null)
throw new ArgumentNullException("referenceType");
LogWriter.Debug("Entity type: " + entityType.ToString());
LogWriter.Debug("Reference type: " + referenceType.ToString());
Db4oDataStore dataStore = (Db4oDataStore)GetDataStore(entityType.Name, referenceType.Name);
if(dataStore.DoesExist)
{
EntityReferenceCollection list = new EntityReferenceCollection();
IQuery query1 = dataStore.ObjectContainer.Query();
query1.Constrain(typeof(EntityReference));
IConstraint constraint1 = query1.Descend("type1Name").Constrain(EntitiesUtilities.GetShortType(entityType.Name)).Equal().And(
query1.Descend("type2Name").Constrain(EntitiesUtilities.GetShortType(referenceType.Name)).Equal());
if (entityID != Guid.Empty)
constraint1.And(query1.Descend("entity1ID").Constrain(entityID).Equal());
IQuery query2 = dataStore.ObjectContainer.Query();
query2.Constrain(typeof(EntityReference));
IConstraint constraint2 = query2.Descend("type2Name").Constrain(EntitiesUtilities.GetShortType(entityType.Name)).Equal().And(
query2.Descend("type1Name").Constrain(EntitiesUtilities.GetShortType(referenceType.Name)).Equal());
if (entityID != Guid.Empty)
constraint2.And(query2.Descend("entity2ID").Constrain(entityID).Equal());
IObjectSet os1 = query1.Execute();
while (os1.HasNext())
{
EntityReference reference = (EntityReference)os1.Next();
list.Add(reference);
}
IObjectSet os2 = query2.Execute();
while (os2.HasNext())
{
EntityReference reference = (EntityReference)os2.Next();
list.Add(reference);
}
if (list.Count == 0)
{
LogWriter.Debug("No references loaded from the data store.");
}
else
{
LogWriter.Debug("Count: " + list.Count);
foreach (EntityReference r in list)
{
using (LogGroup logGroup2 = LogGroup.StartDebug("Processing reference."))
{
EntityReference reference = (EntityReference)r.SwitchFor(entityType, entityID);
LogWriter.Debug("Loaded reference - Entity ID 1: " + reference.Entity1ID);
LogWriter.Debug("Loaded reference - Entity ID 2: " + reference.Entity2ID);
LogWriter.Debug("Loaded reference - Property 1 name: " + reference.Property1Name);
LogWriter.Debug("Loaded reference - Property 2 name: " + reference.Property2Name);
LogWriter.Debug("Loaded reference - Type name 1: " + reference.Type1Name);
LogWriter.Debug("Loaded reference - Type name 2: " + reference.Type2Name);
if (reference.Entity1ID != Guid.Empty
&& reference.Entity2ID != Guid.Empty)
{
// LogWriter.Debug("Adding to the collection.");
collection.Add(reference);
}
else
{
LogWriter.Error("Reference not added to the collection. IDs are empty. This shouldn't happen but the system can ignore it and continue. Invalid references like these should probably be deleted.");
}
}
}
}
}
LogWriter.Debug("References #: " + collection.Count.ToString());
if (activateAll)
{
LogWriter.Debug("Activating references.");
foreach (EntityReference reference in collection)
{
Provider.Activator.ActivateReference(reference);
}
}
LogWriter.Debug("References #: " + collection.Count.ToString());
}
return collection;
}
/// <summary>
/// Retrieves the active references from the provided entity property. This only includes those references currently active and not those in the data store.
/// </summary>
/// <param name="entity">The entity containing the property that the references are assigned to.</param>
/// <param name="property">The property that the references are assigned to.</param>
/// <param name="mirrorPropertyName">The name of the mirror property.</param>
/// <returns>An array of the entity references.</returns>
protected virtual EntityReference[] GetActiveReferencesFromMultipleReferenceProperty(IEntity entity, PropertyInfo property, string mirrorPropertyName)
{
EntityReferenceCollection collection = new EntityReferenceCollection(entity);
using (LogGroup logGroup = LogGroup.Start("Retrieving the references from a multiple reference property.", LogLevel.Debug))
{
LogWriter.Debug("Multiple reference property.");
object propertyValue = property.GetValue(entity, null);
LogWriter.Debug("Property value: " + (propertyValue == null ? "[null]" : propertyValue.ToString()));
Collection<IEntity> referencedEntities = new Collection<IEntity>();
referencedEntities.AddRange(EntitiesUtilities.GetReferencedEntities(entity, property));
LogWriter.Debug("# of referenced entities found: " + referencedEntities.Count);
EntityReferenceCollection references = new EntityReferenceCollection(entity, property.Name, referencedEntities.ToArray(), mirrorPropertyName);
LogWriter.Debug("Reference objects created.");
foreach (EntityReference reference in references)
{
LogWriter.Debug("Adding reference with ID: " + reference.ID.ToString());
LogWriter.Debug("Source entity ID: " + reference.Entity1ID.ToString());
LogWriter.Debug("Referenced entity ID: " + reference.Entity2ID.ToString());
LogWriter.Debug("Source entity name: " + reference.Type1Name);
LogWriter.Debug("Referenced entity name: " + reference.Type2Name);
LogWriter.Debug("Source property name: " + reference.Property1Name);
LogWriter.Debug("Mirror property name: " + reference.Property2Name);
collection.Add((EntityReference)reference);
}
}
return collection.ToArray();
}
private void CreateEmail(Entity email, EntityReference regarding, EntityReference from, EntityReferenceCollection toRecipient)
{
if (from != null)
{
Entity fromActivityParty = new Entity("activityparty");
fromActivityParty["partyid"] = from;
email["from"] = new Entity[] { fromActivityParty };
}
if (toRecipient != null)
{
Entity[] toActivityParties = new Entity[toRecipient.Count];
for (int x = 0; x < toRecipient.Count; x++)
{
toActivityParties[x] = new Entity("activityparty");
toActivityParties[x]["partyid"] = toRecipient[x];
}
email["to"] = toActivityParties;
}
if (regarding != null)
{
email["regardingobjectid"] = regarding;
}
TraceService.Trace("Email is going to be created");
email.Id = this.OrganizationService.Create(email);
TraceService.Trace("Email has been created correctly. ID:{0}", email.Id);
}
public object Disassociate(dynamic options)
{
string entityName = options.entityName;
Guid entityId = new Guid(options.entityId);
Relationship relationship = new Relationship(options.relationship);
var relatedEntitiesList = new List<EntityReference>();
foreach (var rel in options.relatedEntities)
{
relatedEntitiesList.Add(new EntityReference(rel.entityName, new Guid(rel.entityId)));
}
EntityReferenceCollection relatedEntities = new EntityReferenceCollection(relatedEntitiesList);
_service.Disassociate(entityName, entityId, relationship, relatedEntities);
return null;
}
/// <summary>Creates a link between records.</summary> /// <param name="relatedEntities">Type: <see cref="T:Microsoft.Xrm.Sdk.EntityReferenceCollection"></see>. property_relatedentities to be associated.</param> /// <param name="relationship">Type: <see cref="T:Microsoft.Xrm.Sdk.Relationship"></see>. The name of the relationship to be used to create the link. </param> /// <param name="entityName">Type: Returns_String. The logical name of the entity that is specified in the entityId parameter.</param> /// <param name="entityId">Type: Returns_Guid. property_entityid to which the related records are associated.</param> /// <param name="callback"></param> /// <param name="asyncState"></param> public IAsyncResult BeginAssociate(string entityName, Guid entityId, Relationship relationship, EntityReferenceCollection relatedEntities, AsyncCallback callback, object asyncState) => BeginAssociate(entityName, entityId, relationship, relatedEntities, callback, asyncState, CancellationToken.None);
public void Test_GetReference_Sync_Exclude()
{
using (LogGroup logGroup = LogGroup.Start("Testing the GetReference function with a synchronous reference to ensure it retrieves the correct reference.", NLog.LogLevel.Debug))
{
TestUtilities.CreateDummyReferences(100);
TestUser user = new TestUser();
user.ID = Guid.NewGuid();
user.FirstName = "Test";
user.LastName = "User";
TestUser user2 = new TestUser();
user2.ID = Guid.NewGuid();
user2.FirstName = "Test";
user2.LastName = "User 2";
TestRole role = new TestRole();
role.ID = Guid.NewGuid();
role.Name = "Test Role";
TestRole role2 = new TestRole();
role2.ID = Guid.NewGuid();
role2.Name = "Test Role 2";
user.Roles = new TestRole[] {role};
user2.Roles = new TestRole[] { role2 };
//role2.Users = new TestUser[] {user, user2};
LogWriter.Debug("User 1 ID: " + user.ID.ToString());
LogWriter.Debug("User 2 ID: " + user2.ID.ToString());
LogWriter.Debug("Role 1 ID: " + role.ID.ToString());
LogWriter.Debug("Role 2 ID: " + role2.ID.ToString());
EntityReferenceCollection userReferences = DataAccess.Data.Referencer.GetActiveReferences(user);
EntityReferenceCollection user2References = DataAccess.Data.Referencer.GetActiveReferences(user2);
Assert.AreEqual(1, userReferences.Count, "userReferences.Length is incorrect");
Assert.AreEqual(1, user2References.Count, "user2References.Length is incorrect");
EntityReference originalReference1 = userReferences[0];
EntityReference originalReference2 = user2References[0];
LogWriter.Debug("Original reference - Entity 1 ID: " + originalReference1.Entity1ID.ToString());
LogWriter.Debug("Original reference - Entity 2 ID: " + originalReference1.Entity2ID.ToString());
LogWriter.Debug("Original reference - Property 1 name: " + originalReference1.Property1Name);
LogWriter.Debug("Original reference - Property 2 name: " + originalReference1.Property2Name);
LogWriter.Debug("Original reference - Type 1 name: " + originalReference1.Type1Name);
LogWriter.Debug("Original reference - Type 2 name: " + originalReference1.Type2Name);
DataAccess.Data.Saver.Save(role2);
DataAccess.Data.Saver.Save(role);
DataAccess.Data.Saver.Save(user);
DataAccess.Data.Saver.Save(user2);
string referenceStoreName = DataUtilities.GetDataStoreName("TestUser", "TestRole");
EntityReferenceCollection referenceEntities = DataAccess.Data.Referencer.GetReferences(user.GetType().Name, role.GetType().Name);
Assert.AreEqual(2, referenceEntities.Count, "Incorrect number of references found in the store after saving entities.");
// Switch the references around if necessary
if (referenceEntities[0].Entity1ID == originalReference2.Entity1ID)
{
EntityReference r1 = referenceEntities[1];
EntityReference r2 = referenceEntities[0];
referenceEntities = new EntityReferenceCollection();
referenceEntities.Add(r1);
referenceEntities.Add(r2);
}
bool firstReferenceMatches = (((referenceEntities[0].Includes(originalReference1.Entity1ID, originalReference1.Property1Name)
&& referenceEntities[0].Includes(originalReference1.Entity2ID, originalReference1.Property2Name))
||
((referenceEntities[0].Includes(originalReference2.Entity1ID, originalReference2.Property1Name)
&& referenceEntities[0].Includes(originalReference2.Entity2ID, originalReference2.Property2Name)))));
bool secondReferenceMatches = (((referenceEntities[1].Includes(originalReference1.Entity1ID, originalReference1.Property1Name)
&& referenceEntities[1].Includes(originalReference1.Entity2ID, originalReference1.Property2Name))
||
((referenceEntities[1].Includes(originalReference2.Entity1ID, originalReference2.Property1Name)
&& referenceEntities[1].Includes(originalReference2.Entity2ID, originalReference2.Property2Name)))));
Assert.IsTrue(firstReferenceMatches,
"First reference doesn't match original references.");
Assert.IsTrue(secondReferenceMatches,
"Second reference doesn't match original references.");
EntityReference reference = DataAccess.Data.Referencer.GetReference(user.GetType(),
user.ID,
"Roles",
role.GetType(),
role2.ID,
"Users",
false);
Assert.IsNull(reference, "The return value should be null.");
}
}
public OrganizationResponse Execute(OrganizationRequest request, XrmFakedContext ctx)
{
var req = request as QualifyLeadRequest;
var orgService = ctx.GetOrganizationService();
if (req.LeadId == null)
{
throw new Exception("Lead Id must be set in request.");
}
var leads = (from l in ctx.CreateQuery("lead")
where l.Id == req.LeadId.Id
select l);
var leadsCount = leads.Count();
if (leadsCount != 1)
{
throw new Exception(string.Format("Number of Leads by given LeadId should be 1. Instead it is {0}.", leadsCount));
}
// Made here to get access to CreatedEntities collection
var response = new QualifyLeadResponse();
response["CreatedEntities"] = new EntityReferenceCollection();
// Create Account
if (req.CreateAccount) // ParentAccount
{
var account = new Entity("account")
{
Id = Guid.NewGuid()
};
account.Attributes["originatingleadid"] = req.LeadId;
orgService.Create(account);
response.CreatedEntities.Add(account.ToEntityReference());
}
// Create Contact
if (req.CreateContact)
{
var contact = new Entity("contact")
{
Id = Guid.NewGuid()
};
contact.Attributes["originatingleadid"] = req.LeadId;
orgService.Create(contact);
response.CreatedEntities.Add(contact.ToEntityReference());
}
// Create Opportunity
if (req.CreateOpportunity)
{
var opportunity = new Entity("opportunity")
{
Id = Guid.NewGuid()
};
// Set OpportunityCurrencyId if given
// MSDN link:
// https://msdn.microsoft.com/en-us/library/microsoft.crm.sdk.messages.qualifyleadrequest.opportunitycurrencyid.aspx
if (req.OpportunityCurrencyId != null)
{
opportunity.Attributes["transactioncurrencyid"] = req.OpportunityCurrencyId;
}
// Associate Account or Contact with Opportunity
// MSDN link:
// https://msdn.microsoft.com/en-us/library/microsoft.crm.sdk.messages.qualifyleadrequest.opportunitycustomerid.aspx
if (req.OpportunityCustomerId != null)
{
var logicalName = req.OpportunityCustomerId.LogicalName;
// Associate Account or Contact
if (logicalName.Equals("account") || logicalName.Equals("contact"))
{
opportunity.Attributes["customerid"] = req.OpportunityCustomerId;
}
// Wrong Entity was given as parameter
else
{
throw new Exception(string.Format("Opportunity Customer Id should be connected with Account or Contact. Instead OpportunityCustomerId was given with Entity.LogicalName = {0}", logicalName));
}
}
opportunity.Attributes["originatingleadid"] = req.LeadId;
orgService.Create(opportunity);
response.CreatedEntities.Add(opportunity.ToEntityReference());
}
// Actual Lead
var lead = leads.First();
lead.Attributes["statuscode"] = req.Status.Value;
orgService.Update(lead);
return(response);
}
internal void ApplySelectedFiltersToUsers(bool applyToActiveUsers = false)
{
if (lvViews.SelectedItems.Count == 0)
{
return;
}
var templates = new EntityReferenceCollection();
foreach (ListViewItem item in lvViews.SelectedItems)
{
templates.Add(new EntityReference(entityName, ((Entity)item.Tag).Id));
}
List<Entity> users = null;
if (!applyToActiveUsers)
{
var usDialog = new UserSelectionDialog(service);
if (usDialog.ShowDialog(this) == DialogResult.OK)
{
users = usDialog.SelectedUsers;
}
else
{
return;
}
}
if (users == null || users.Count > 0)
{
loadingPanel = InformationPanel.GetInformationPanel(this, "Processing...", 340, 120);
var bwApplyFiltersToUsers = new BackgroundWorker {WorkerReportsProgress = true};
bwApplyFiltersToUsers.DoWork += bwApplyFiltersToUsers_DoWork;
bwApplyFiltersToUsers.ProgressChanged += bwApplyFiltersToUsers_ProgressChanged;
bwApplyFiltersToUsers.RunWorkerCompleted += bwApplyFiltersToUsers_RunWorkerCompleted;
bwApplyFiltersToUsers.RunWorkerAsync(new object[] {templates, users});
}
}
public void Activate(IEntity entity, string propertyName, Type propertyType, int depth, EntityReferenceCollection references)
{
using (LogGroup logGroup = LogGroup.StartDebug("Activating the '" + propertyName + "' property on the '" + entity.ShortTypeName + "' type."))
{
if (entity == null)
throw new ArgumentNullException("entity");
if (propertyName == null || propertyName == String.Empty)
throw new ArgumentException("propertyName", "Cannot be null or String.Empty.");
PropertyInfo property = EntitiesUtilities.GetProperty(entity.GetType(), propertyName, propertyType);
if (property == null)
throw new Exception("Cannot find property with name '" + propertyName + "' and type '" + (propertyType == null ? "[null]" : propertyType.ToString()) + "' on the type '" + entity.ShortTypeName + "'.");
Type referenceType = DataUtilities.GetEntityType(entity, property);
// If the reference type is not null then activate the property
// otherwise skip it because it means it's a dynamic reference property which hasn't been set
if (referenceType != null)
{
LogWriter.Debug("Reference entity type: " + referenceType.ToString());
IEntity[] referencedEntities = Provider.Indexer.GetEntitiesWithReference(entity, property.Name, references);
if (referencedEntities == null)
LogWriter.Debug("# of entities found: [null]");
else
LogWriter.Debug("# of entities found:" + referencedEntities.Length);
// Multiple references.
if (EntitiesUtilities.IsMultipleReference(entity.GetType(), property))
{
LogWriter.Debug("Multiple reference property");
ActivateMultipleReferenceProperty(entity, property, referencedEntities);
}
// Single reference.
else
{
LogWriter.Debug("Single reference property");
ActivateSingleReferenceProperty(entity, property, referencedEntities);
}
}
}
}
public void Disassociate(string entityName, Guid entityId, Relationship relationship,
EntityReferenceCollection relatedEntities)
{
if (relatedEntities.Count > 0)
{
var request = new DisassociateRequest
{
Target = CreateLookup(entityName, entityId),
Relationship = relationship,
RelatedEntities = relatedEntities
};
Execute(request);
}
}
public void Associate(string entityName, Guid entityId, Relationship relationship, EntityReferenceCollection relatedEntities)
{
_connection.Associate(entityName, entityId, relationship, relatedEntities);
}
/// <summary>
/// Create and configure the organization service proxy.
/// Create an account record
/// Retrieve the account record
/// Update the account record
/// Optionally delete any entity records that were created for this sample.
/// </summary>
/// <param name="serverConfig">Contains server connection information.</param>
/// <param name="promptForDelete">When True, the user will be prompted to delete
/// all created entities.</param>
public void Run(ServerConnection.Configuration serverConfig, bool promptForDelete)
{
while (true)
{
Console.Write("Find Account Name: ");
accountName = Console.ReadLine();
if (accountName != string.Empty)
{
break;
}
else
{
Console.WriteLine("Account Name can't be empty!");
}
}
while (true)
{
Console.Write("Contacts First Name: ");
fName = Console.ReadLine();
if (fName != string.Empty)
{
break;
}
else
{
Console.WriteLine("Contact Name can't be empty!");
}
}
while (true)
{
Console.Write("Contacts Last Name: ");
lName = Console.ReadLine();
if (lName != string.Empty)
{
break;
}
else
{
Console.WriteLine("Contact Name can't be empty!");
}
}
try
{
// Connect to the Organization service.
// The using statement assures that the service proxy will be properly disposed.
using (_serviceProxy = new OrganizationServiceProxy(serverConfig.OrganizationUri, serverConfig.HomeRealmUri, serverConfig.Credentials, serverConfig.DeviceCredentials))
{
_service = (IOrganizationService)_serviceProxy;
_orgContext = new OrganizationServiceContext(_service);
var account = FindAccount(accountName);
_accountId = account.Id;
if (_accountId == null)
{
Console.WriteLine("Account was not found!");;
}
else
{
EntityReferenceCollection myEntityReferenceCollection = CreateAContact(_accountId, account);
//EntityReferenceCollection myEntityReferenceCollection = CreateContact(_accountId);
//AssociateConctactWithAccount(myEntityReferenceCollection);
}
}
}
// Catch any service fault exceptions that Microsoft Dynamics CRM throws.
catch (FaultException <Microsoft.Xrm.Sdk.OrganizationServiceFault> )
{
// You can handle an exception here or pass it back to the calling method.
throw;
}
}
/// <summary>
/// Creates any entity records that this sample requires.
/// </summary>
public void CreateRequiredRecords()
{
Contact contact1 = new Contact
{
FirstName = "Colin",
LastName = "Wilcox",
Address1_City = "Redmond",
Address1_StateOrProvince = "WA",
Address1_PostalCode = "98052",
Anniversary = new DateTime(2010, 3, 5),
CreditLimit = new Money(300),
Description = "Alpine Ski House",
StatusCode = new OptionSetValue(1),
AccountRoleCode = new OptionSetValue(1),
NumberOfChildren = 1,
Address1_Latitude = 47.6741667,
Address1_Longitude = -122.1202778,
CreditOnHold = false
};
_contactId1 = _serviceProxy.Create(contact1);
Console.Write("Created a sample contact 1: {0}, ", contact1.FirstName + " " + contact1.LastName);
Contact contact2 = new Contact
{
FirstName = "Brian",
LastName = "Smith",
Address1_City = "Bellevue",
FamilyStatusCode = new OptionSetValue(3),
Address1_StateOrProvince = "WA",
Address1_PostalCode = "98008",
Anniversary = new DateTime(2010, 4, 5),
CreditLimit = new Money(30000),
Description = "Coho Winery",
StatusCode = new OptionSetValue(1),
AccountRoleCode = new OptionSetValue(2),
NumberOfChildren = 2,
Address1_Latitude = 47.6105556,
Address1_Longitude = -122.1994444,
CreditOnHold = false
};
_contactId2 = _serviceProxy.Create(contact2);
Console.Write("Created a sample contact 2: {0}, ", contact2.FirstName + " " + contact2.LastName);
Contact contact3 = new Contact
{
FirstName = "Darren",
LastName = "Parker",
Address1_City = "Kirkland",
FamilyStatusCode = new OptionSetValue(3),
Address1_StateOrProvince = "WA",
Address1_PostalCode = "98033",
Anniversary = new DateTime(2010, 10, 5),
CreditLimit = new Money(10000),
Description = "Coho Winery",
StatusCode = new OptionSetValue(1),
AccountRoleCode = new OptionSetValue(2),
NumberOfChildren = 2,
Address1_Latitude = 47.6105556,
Address1_Longitude = -122.1994444,
CreditOnHold = false
};
_contactId3 = _serviceProxy.Create(contact3);
Console.Write("Created a sample contact 3: {0}, ", contact3.FirstName + " " + contact3.LastName);
Contact contact4 = new Contact
{
FirstName = "Ben",
LastName = "Smith",
Address1_City = "Kirkland",
FamilyStatusCode = new OptionSetValue(3),
Address1_StateOrProvince = "WA",
Address1_PostalCode = "98033",
Anniversary = new DateTime(2010, 7, 5),
CreditLimit = new Money(12000),
Description = "Coho Winery",
StatusCode = new OptionSetValue(1),
AccountRoleCode = new OptionSetValue(2),
NumberOfChildren = 2,
Address1_Latitude = 47.6105556,
Address1_Longitude = -122.1994444,
CreditOnHold = true
};
_contactId4 = _serviceProxy.Create(contact4);
Console.Write("Created a sample contact 4: {0}, ", contact4.FirstName + " " + contact4.LastName);
Incident incident1 = new Incident
{
Title = "Test Case 1",
PriorityCode = new OptionSetValue(1), // 1 = High
CaseOriginCode = new OptionSetValue(1), // 1 = Phone
CaseTypeCode = new OptionSetValue(2), // 2 = Problem
Description = "Description for Test Case 1.",
FollowupBy = DateTime.Now.AddHours(3.0), // follow-up in 3 hours
CustomerId = new EntityReference(Contact.EntityLogicalName, _contactId2)
};
_incidentId1 = _serviceProxy.Create(incident1);
Console.Write("Created a sample incident 1: {0}, ", incident1.Title);
Relationship relationship1 = new Relationship("incident_customer_contacts");
EntityReferenceCollection relatedEntities1 = new EntityReferenceCollection();
relatedEntities1.Add(new EntityReference(Contact.EntityLogicalName, _contactId1));
_serviceProxy.Associate(Incident.EntityLogicalName, _incidentId1, relationship1, relatedEntities1);
Console.Write("Added relationship between incident 1 and contact 1, ");
Account account1 = new Account
{
Name = "Coho Winery",
Address1_Name = "Coho Vineyard & Winery",
Address1_City = "Redmond"
};
_accountId1 = _serviceProxy.Create(account1);
Console.Write("Created a sample account 1: {0}, ", account1.Name);
Incident incident2 = new Incident
{
Title = "Test Case 2",
PriorityCode = new OptionSetValue(1), // 1 = High
CaseOriginCode = new OptionSetValue(1), // 1 = Phone
CaseTypeCode = new OptionSetValue(2), // 2 = Problem
Description = "Description for Sample Case 2.",
FollowupBy = DateTime.Now.AddHours(3.0), // follow-up in 3 hours
CustomerId = new EntityReference(Contact.EntityLogicalName, _contactId1)
};
_incidentId2 = _serviceProxy.Create(incident2);
Console.Write("Created a sample incident 2: {0}, ", incident2.Title);
Relationship relationship2 = new Relationship("incident_customer_accounts");
EntityReferenceCollection relatedEntities2 = new EntityReferenceCollection();
relatedEntities2.Add(new EntityReference(Account.EntityLogicalName, _accountId1));
_serviceProxy.Associate(Incident.EntityLogicalName, _incidentId2, relationship2, relatedEntities2);
Console.Write("Added relationship between incident 2 and account 1, ");
Lead lead = new Lead()
{
FirstName = "Diogo",
LastName = "Andrade"
};
_leadId = _serviceProxy.Create(lead);
Console.Write("Created a sample Lead: {0} ", lead.FirstName + " " + lead.LastName);
Account account2 = new Account
{
Name = "Contoso Ltd",
ParentAccountId = new EntityReference(Account.EntityLogicalName, _accountId1),
Address1_Name = "Contoso Pharmaceuticals",
Address1_City = "Redmond",
OriginatingLeadId = new EntityReference(Lead.EntityLogicalName, _leadId)
};
_accountId2 = _serviceProxy.Create(account2);
Console.Write("Created a sample account 2: {0}, ", account2.Name);
Relationship relationship3 = new Relationship("account_primary_contact");
EntityReferenceCollection relatedEntities3 = new EntityReferenceCollection();
relatedEntities3.Add(new EntityReference(Account.EntityLogicalName, _accountId2));
_serviceProxy.Associate(Contact.EntityLogicalName, _contactId2, relationship3, relatedEntities3);
Console.WriteLine("Added relationship between account 2 and contact 2.");
}
//<snippetCRUDOperations1>
/// <summary>
/// This method performs entity create, retrieve, and update operations.
/// The delete operation is handled in the DeleteRequiredrecords() method.
/// </summary>
/// <param name="serviceProxy">An established connection to the Organization web service.</param>
/// <param name="records">A collection of entity records created by this sample.</param>
public void Run(OrganizationServiceProxy serviceProxy, EntityReferenceCollection records)
{
// Enable early-bound entity types. This enables use of IntelliSense in Visual Studio
// and avoids spelling errors in attribute names when using the Entity property bag.
serviceProxy.EnableProxyTypes();
// Here we will use the interface instead of the proxy object.
IOrganizationService service = (IOrganizationService)serviceProxy;
// Display information about the logged on user.
Guid userid = ((WhoAmIResponse)service.Execute(new WhoAmIRequest())).UserId;
SystemUser systemUser = (SystemUser)service.Retrieve("systemuser", userid,
new ColumnSet(new string[] { "firstname", "lastname" }));
Console.WriteLine("Logged on user is {0} {1}.", systemUser.FirstName, systemUser.LastName);
// Retrieve the version of Microsoft Dynamics CRM.
RetrieveVersionRequest versionRequest = new RetrieveVersionRequest();
RetrieveVersionResponse versionResponse =
(RetrieveVersionResponse)service.Execute(versionRequest);
Console.WriteLine("Microsoft Dynamics CRM version {0}.", versionResponse.Version);
//<snippetCRUDOperations2>
// Instantiate an account object. Note the use of the option set enumerations defined
// in OptionSets.cs.
Account account = new Account {
Name = "SiroccoTest"
};
account.AccountCategoryCode = new OptionSetValue((int)AccountAccountCategoryCode.PreferredCustomer);
account.CustomerTypeCode = new OptionSetValue((int)AccountCustomerTypeCode.Investor);
// Create an account record named Sirocco.
// Save the record reference so we can delete it during cleanup later.
Guid accountId = service.Create(account);
//</snippetCRUDOperations2>
var eref = new EntityReference(Account.EntityLogicalName, accountId);
eref.Name = account.Name;
records.Add(eref);
Console.Write("{0} {1} created, ", account.LogicalName, account.Name);
// Retrieve the account containing several of its attributes. This results in
// better performance compared to retrieving all attributes.
ColumnSet cols = new ColumnSet(
new String[] { "name", "address1_postalcode", "lastusedincampaign" });
Account retrievedAccount = (Account)service.Retrieve("account", accountId, cols);
Console.Write("retrieved, ");
// The phone number.
retrievedAccount.Telephone1 = "99999999";
// The fax number.
retrievedAccount.Fax = "23442342";
// Update the postal code attribute.
retrievedAccount.Address1_PostalCode = "98052";
// There is no address 2 postal code needed.
retrievedAccount.Address2_PostalCode = null;
// Shows use of a Money value.
retrievedAccount.Revenue = new Money(5000000);
// New contact?????????
//retrievedAccount.Firstname = new Contact("Peter");
// Shows use of a Boolean value.
retrievedAccount.CreditOnHold = false;
// Update the account record.
service.Update(retrievedAccount);
Console.WriteLine("and updated.");
}
public void Disassociate(string entityName, Guid entityId, Relationship relationship, EntityReferenceCollection relatedEntities)
{
}
public void Disassociate(string entityName, Guid entityId, Relationship relationship, EntityReferenceCollection relatedEntities)
{
if (!relatedEntities.Any())
{
throw new ArgumentException("Must contain at least one related entity!", nameof(relatedEntities));
}
if (relatedEntities.Any(e => e.LogicalName != relatedEntities.First().LogicalName))
{
throw new NotImplementedException("Don't currently Support different Entity Types for related Entities!");
}
if (relationship.PrimaryEntityRole.GetValueOrDefault(EntityRole.Referenced) == EntityRole.Referencing)
{
throw new NotImplementedException("Referencing Not Currently Implemented");
}
var referencedIdName = EntityHelper.GetIdAttributeName(entityName);
var referencingIdName = EntityHelper.GetIdAttributeName(relatedEntities.First().LogicalName);
if (referencedIdName == referencingIdName)
{
referencedIdName += "one";
referencingIdName += "two";
}
//if (EntityHelper.IsTypeDefined(Info.EarlyBoundEntityAssembly, Info.EarlyBoundNamespace,
// relationship.SchemaName))
//{
Disassociate1ToN(entityId, relationship, relatedEntities, referencedIdName, referencingIdName);
//}
//else
//{
// foreach (var entity in relatedEntities)
// {
// DisassociateN2N(new EntityReference(entityName, entityId), entity, relationship);
// }
//}
}
private void ApplyTemplateToUsers(List<Guid> rulesIds, string question, RuleManager rm, BackgroundWorker worker)
{
worker.ReportProgress(0, "Waiting for input...");
if (
MessageBox.Show(this, question, "Question",
MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
var usDialog = new UserSelectionDialog(service);
if (usDialog.ShowDialog() == DialogResult.OK)
{
foreach (var user in usDialog.SelectedUsers)
{
worker.ReportProgress(0, string.Format("Applying rule(s) to user(s) '{0}'", user.GetAttributeValue<string>("fullname")));
var erc = new EntityReferenceCollection();
foreach (var ruleId in rulesIds)
{
erc.Add(new EntityReference("savedquery", ruleId));
}
rm.ApplyRulesToUser(erc, user.Id);
}
}
}
}
public void Disassociate( string entityName, Guid entityId, Relationship relationship, EntityReferenceCollection relatedEntities )
{
throw new NotImplementedException();
}
/// <summary>
/// !! Doesn;t work same entity type!!
/// </summary>
public void Disassociate(string relationshipName, string keyAttributeFrom, Guid entityFrom,
string keyAttributeTo, IEnumerable<Guid> relatedEntities)
{
var metadata = GetRelationshipMetadata(relationshipName);
var isReferencing = metadata.Entity1IntersectAttribute == keyAttributeFrom;
var relatedType = isReferencing ? metadata.Entity2LogicalName : metadata.Entity1LogicalName;
var targetType = isReferencing ? metadata.Entity1LogicalName : metadata.Entity2LogicalName;
var relationship = new Relationship(relationshipName)
{
PrimaryEntityRole =
isReferencing ? EntityRole.Referencing : EntityRole.Referenced
};
var entityReferenceCollection = new EntityReferenceCollection();
foreach (var id in relatedEntities)
entityReferenceCollection.Add(CreateLookup(relatedType, id));
Disassociate(targetType, entityFrom, relationship, entityReferenceCollection);
}
/// <summary>Deletes a link between records.</summary>
/// <param name="relatedEntities">Type: <see cref="T:Microsoft.Xrm.Sdk.EntityReferenceCollection"></see>. A collection of entity references (references to records) to be disassociated.</param>
/// <param name="relationship">Type: <see cref="T:Microsoft.Xrm.Sdk.Relationship"></see>. The name of the relationship to be used to remove the link.</param>
/// <param name="entityName">Type: Returns_String. The logical name of the entity that is specified in the entityId parameter.</param>
/// <param name="entityId">Type: Returns_Guid. The ID of the record from which the related records are disassociated.</param>
protected internal virtual void DisassociateCore(string entityName, Guid entityId, Relationship relationship, EntityReferenceCollection relatedEntities)
{
bool?retry = null;
do
{
bool forceClose = false;
try {
using (new OrganizationServiceContextInitializer(this)) {
base.ServiceChannel.Channel.Disassociate(entityName, entityId, relationship, relatedEntities);
}
break;
} catch (System.ServiceModel.Security.MessageSecurityException messageSecurityException) {
forceClose = true;
retry = base.ShouldRetry(messageSecurityException, retry);
if (!retry.GetValueOrDefault())
{
throw;
}
} catch (System.ServiceModel.EndpointNotFoundException) {
forceClose = true;
retry = new bool?(base.HandleFailover(retry));
if (!retry.GetValueOrDefault())
{
throw;
}
} catch (TimeoutException) {
forceClose = true;
retry = new bool?(base.HandleFailover(retry));
if (!retry.GetValueOrDefault())
{
throw;
}
} catch (System.ServiceModel.FaultException <OrganizationServiceFault> faultException) {
forceClose = true;
retry = base.HandleFailover(faultException.Detail, retry);
if (!retry.GetValueOrDefault())
{
throw;
}
} catch {
forceClose = true;
throw;
} finally {
this.CloseChannel(forceClose);
}
}while (retry.HasValue && retry.Value);
}
public override void Disassociate(string entityName, Guid entityId, Relationship relationship, EntityReferenceCollection relatedEntities)
{
if (DisassociateAction != null)
{
DisassociateAction(Service, entityName, entityId, relationship, relatedEntities);
}
else if (DisassociateActions != null)
{
if (DisassociateCache == null)
{
DisassociateCache = Service;
foreach (var disassociate in DisassociateActions)
{
DisassociateCache = new FakeIOrganizationService(DisassociateCache) {DisassociateAction = disassociate};
}
}
DisassociateCache.Disassociate(entityName, entityId, relationship, relatedEntities);
}
else
{
if (ExecutionTracingEnabled)
{
Timer.Time(DisassociateInternal, new Tuple<string, Guid, Relationship, EntityReferenceCollection>(entityName, entityId, relationship, relatedEntities),
"Disassociate {0}:{1} using relationship {2} to releated Entities {3}: {4}",
entityName, entityId, relationship, String.Join(", ", relatedEntities.Select(e => e.GetNameId())));
}
else
{
Service.Disassociate(entityName, entityId, relationship, relatedEntities);
}
}
}
/// <summary>Deletes a link between records.</summary>
/// <param name="relatedEntities">Type: <see cref="T:Microsoft.Xrm.Sdk.EntityReferenceCollection"></see>. A collection of entity references (references to records) to be disassociated.</param>
/// <param name="relationship">Type: <see cref="T:Microsoft.Xrm.Sdk.Relationship"></see>. The name of the relationship to be used to remove the link.</param>
/// <param name="entityName">Type: Returns_String. The logical name of the entity that is specified in the entityId parameter.</param>
/// <param name="entityId">Type: Returns_Guid. The ID of the record from which the related records are disassociated.</param>
public void Disassociate(string entityName, Guid entityId, Relationship relationship, EntityReferenceCollection relatedEntities)
{
this.DisassociateCore(entityName, entityId, relationship, relatedEntities);
}
/// <summary>
/// Prepares the provided entity for deletion by removing dependent referenced, etc.
/// </summary>
/// <param name="entity">The entity to prepare for deletion.</param>
public override void PreDelete(IEntity entity)
{
using (LogGroup logGroup = LogGroup.Start("Preparing to delete the provided entity.", NLog.LogLevel.Debug))
{
if (entity == null)
throw new ArgumentNullException("entity");
Db4oDataStore store = (Db4oDataStore)GetDataStore(entity);
//if (entity.ID == Guid.Empty)
// throw new ArgumentException("entity.ID must be set.");
EntityReferenceCollection toDelete = new EntityReferenceCollection();
if (entity != null && entity.ID != Guid.Empty)
{
//Provider.Activator.Activate(entity);
EntityReferenceCollection latestReferences = Provider.Referencer.GetReferences(entity);
// Delete all references
foreach (PropertyInfo property in entity.GetType().GetProperties())
{
bool isReference = EntitiesUtilities.IsReference(entity.GetType(), property.Name, property.PropertyType);
if (isReference)
{
using (LogGroup logGroup2 = LogGroup.StartDebug("Checking reference property '" + property.Name + "' for obsolete references."))
{
Type referenceType = EntitiesUtilities.GetReferenceType(entity, property.Name);
// If the reference type is not null then continue
if (referenceType != null)
{
EntityReferenceCollection references = DataAccess.Data.Referencer.GetReferences(entity.GetType(),
entity.ID,
property.Name,
referenceType,
false);
if (references.Count > 0)
{
LogWriter.Debug("Found references: " + references.Count.ToString());
foreach (EntityReference reference in references)
{
LogWriter.Debug("Found reference between '" + reference.Type1Name + "' and '" + reference.Type2Name + "'.");
toDelete.Add(reference);
}
}
else
LogWriter.Debug("No references found associated with this property.");
}
// Otherwise skip it because the reference property hasn't been set
}
}
}
}
LogWriter.Debug("References to delete: " + toDelete.Count);
//entitiesToUpdate = toUpdate.ToArray();
Provider.Referencer.DeleteObsoleteReferences(toDelete);
}
}
[STAThread] // Required to support the interactive login experience
static void Main(string[] args)
{
CrmServiceClient service = null;
try
{
service = SampleHelpers.Connect("Connect");
if (service.IsReady)
{
// Create any entity records that the demonstration code requires
SetUpSample(service);
#region Demonstrate
// Associate the accounts to the contact record.
// Create a collection of the entities that will be
// associated to the contact.
var relatedEntities = new EntityReferenceCollection();
relatedEntities.Add(new EntityReference(Account.EntityLogicalName, _account1Id));
relatedEntities.Add(new EntityReference(Account.EntityLogicalName, _account2Id));
relatedEntities.Add(new EntityReference(Account.EntityLogicalName, _account3Id));
// Create an object that defines the relationship between the contact and account.
var relationship = new Relationship("account_primary_contact");
//Associate the contact with the 3 accounts.
service.Associate(Contact.EntityLogicalName, _contactId, relationship,
relatedEntities);
Console.WriteLine("The entities have been associated.");
//Disassociate the records.
service.Disassociate(Contact.EntityLogicalName, _contactId, relationship,
relatedEntities);
Console.WriteLine("The entities have been disassociated.");
#endregion Demonstrate
#region Clean up
CleanUpSample(service);
#endregion Clean up
}
else
{
const string UNABLE_TO_LOGIN_ERROR = "Unable to Login to Common Data Service";
if (service.LastCrmError.Equals(UNABLE_TO_LOGIN_ERROR))
{
Console.WriteLine("Check the connection string values in cds/App.config.");
throw new Exception(service.LastCrmError);
}
else
{
throw service.LastCrmException;
}
}
}
catch (Exception ex)
{
SampleHelpers.HandleException(ex);
}
finally
{
if (service != null)
{
service.Dispose();
}
Console.WriteLine("Press <Enter> to exit.");
Console.ReadLine();
}
}
public void ApplyRuleToActiveUsers(EntityReferenceCollection ec)
{
var qba = new QueryByAttribute("systemuser");
qba.AddAttributeValue("isdisabled", false);
foreach (var user in service.RetrieveMultiple(qba).Entities)
{
var request = new InstantiateFiltersRequest
{
UserId = user.Id,
TemplateCollection = ec
};
service.Execute(request);
}
}
public override void Disassociate(string entityName, Guid entityId, Relationship relationship, EntityReferenceCollection relatedEntities)
{
if (DisassociateAction != null)
{
DisassociateAction(Service, entityName, entityId, relationship, relatedEntities);
}
else if (DisassociateActions != null)
{
if (DisassociateCache == null)
{
DisassociateCache = Service;
foreach (var disassociate in DisassociateActions)
{
DisassociateCache = new FakeIOrganizationService(DisassociateCache)
{
DisassociateAction = disassociate
};
}
}
DisassociateCache.Disassociate(entityName, entityId, relationship, relatedEntities);
}
else
{
if (ExecutionTracingEnabled)
{
Timer.Time(DisassociateInternal, new Tuple <string, Guid, Relationship, EntityReferenceCollection>(entityName, entityId, relationship, relatedEntities),
"Disassociate {0}:{1} using relationship {2} to releated Entities {3}: {4}",
entityName, entityId, relationship, String.Join(", ", relatedEntities.Select(e => e.GetNameId())));
}
else
{
Service.Disassociate(entityName, entityId, relationship, relatedEntities);
}
}
}
//<snippetCRUDOperations1>
/// <summary>
/// This method performs entity create, retrieve, and update operations.
/// The delete operation is handled in the DeleteRequiredrecords() method.
/// </summary>
/// <param name="serviceProxy">An established connection to the Organization web service.</param>
/// <param name="records">A collection of entity records created by this sample.</param>
public void Run(OrganizationServiceProxy serviceProxy, EntityReferenceCollection records)
{
// Enable early-bound entity types. This enables use of IntelliSense in Visual Studio
// and avoids spelling errors in attribute names when using the Entity property bag.
serviceProxy.EnableProxyTypes();
// Here we will use the interface instead of the proxy object.
IOrganizationService service = (IOrganizationService)serviceProxy;
// Display information about the logged on user.
Guid userid = ((WhoAmIResponse)service.Execute(new WhoAmIRequest())).UserId;
SystemUser systemUser = (SystemUser)service.Retrieve("systemuser", userid,
new ColumnSet(new string[] { "firstname", "lastname" }));
Console.WriteLine("Logged on user is {0} {1}.", systemUser.FirstName, systemUser.LastName);
// Retrieve the version of Microsoft Dynamics CRM.
RetrieveVersionRequest versionRequest = new RetrieveVersionRequest();
RetrieveVersionResponse versionResponse =
(RetrieveVersionResponse)service.Execute(versionRequest);
Console.WriteLine("Microsoft Dynamics CRM version {0}.", versionResponse.Version);
//<snippetCRUDOperations2>
// Instantiate an account object. Note the use of the option set enumerations defined
// in OptionSets.cs.
Account account = new Account { Name = "Fourth Coffee" };
account.AccountCategoryCode = new OptionSetValue((int)AccountAccountCategoryCode.PreferredCustomer);
account.CustomerTypeCode = new OptionSetValue((int)AccountCustomerTypeCode.Investor);
// Create an account record named Fourth Coffee.
// Save the record reference so we can delete it during cleanup later.
Guid accountId = service.Create(account);
//</snippetCRUDOperations2>
var eref = new EntityReference(Account.EntityLogicalName, accountId);
eref.Name = account.Name;
records.Add(eref);
Console.Write("{0} {1} created, ", account.LogicalName, account.Name);
// Retrieve the account containing several of its attributes. This results in
// better performance compared to retrieving all attributes.
ColumnSet cols = new ColumnSet(
new String[] { "name", "address1_postalcode", "lastusedincampaign" });
Account retrievedAccount = (Account)service.Retrieve("account", accountId, cols);
Console.Write("retrieved, ");
// Update the postal code attribute.
retrievedAccount.Address1_PostalCode = "98052";
// There is no address 2 postal code needed.
retrievedAccount.Address2_PostalCode = null;
// Shows use of a Money value.
retrievedAccount.Revenue = new Money(5000000);
// Shows use of a Boolean value.
retrievedAccount.CreditOnHold = false;
// Update the account record.
service.Update(retrievedAccount);
Console.WriteLine("and updated.");
}
public async static Task DisassociateAsync(this IOrganizationService sdk, string entityName, Guid entityId, Relationship relationship, EntityReferenceCollection relatedEntities)
{
var t = Task.Factory.StartNew(() =>
{
sdk.Disassociate(entityName, entityId, relationship, relatedEntities);
});
await t;
}
