public static string ToCommaSeparatedString(this Microsoft.Xrm.Sdk.EntityCollection value)
{
if (value == null)
{
return("None");
}
string output = string.Empty;
foreach (Microsoft.Xrm.Sdk.Entity record in value.Entities)
{
if (record.Contains("partyid"))
{
if (!(output.Equals(String.Empty)))
{
output += ", ";
}
Microsoft.Xrm.Sdk.EntityReference entRef = (Microsoft.Xrm.Sdk.EntityReference)record.Attributes["partyid"];
output += entRef.Name + "";
}
else if (record.Contains("addressused"))
{
string emailAddress = (string)record["addressused"];
if (!(emailAddress.Equals(String.Empty)))
{
if (!(output.Equals(String.Empty)))
{
output += ", ";
}
output += emailAddress;
}
}
else if (record.Contains("name"))
{
string name = (string)record["name"];
if (!(name.Equals(String.Empty)))
{
if (!(output.Equals(String.Empty)))
{
output += ", ";
}
output += name;
}
}
else if (record.Contains("crmcs_name"))
{
string name = (string)record["crmcs_name"];
if (!(name.Equals(String.Empty)))
{
if (!(output.Equals(String.Empty)))
{
output += ", ";
}
output += name;
}
}
}
return(output);
}
/// <summary>
/// Get entity
/// </summary>
/// <param name="organizationService">Organization Service</param>
/// <param name="entityReference">Entity Reference</param>
/// <param name="attributes">Attributes to return</param>
/// <remarks>
/// Get entity record
/// </remarks>
protected static Entity RetrieveEntity(Microsoft.Xrm.Sdk.EntityReference entityReference, string[] attributes, IOrganizationService organizationService)
{
Entity entity = null;
ColumnSet columnSet = new ColumnSet(true);
if (attributes != null && attributes.Length > 0)
{
columnSet = new ColumnSet(attributes);
}
try
{
if (entityReference != null && !entityReference.Id.Equals(Guid.Empty))
{
RetrieveResponse retrieveResponse = (RetrieveResponse)organizationService.Execute(new RetrieveRequest()
{
ColumnSet = columnSet,
Target = entityReference
});
if (retrieveResponse != null && retrieveResponse.Entity != null)
{
entity = retrieveResponse.Entity;
}
}
}
catch { entity = null; }
return(entity);
}
public void AddRoleToUserOrTeam(Microsoft.Xrm.Sdk.EntityReference userOrTeamRef, string parentRootRoleIdOrTemplateId)
{
Microsoft.Xrm.Sdk.EntityReference businessUnitRef;
if (userOrTeamRef.LogicalName == SystemUserDefinition.EntityName)
{
businessUnitRef = Retrieve(userOrTeamRef, SystemUserDefinition.Columns.BusinessUnitId).GetAttributeValue <Microsoft.Xrm.Sdk.EntityReference>(SystemUserDefinition.Columns.BusinessUnitId);
}
else
{
businessUnitRef = Retrieve(userOrTeamRef, TeamDefinition.Columns.BusinessUnitId).GetAttributeValue <Microsoft.Xrm.Sdk.EntityReference>(TeamDefinition.Columns.BusinessUnitId);
}
var roleRef = GetRoleRefForBusinessUnit(businessUnitRef, parentRootRoleIdOrTemplateId);
if (userOrTeamRef.LogicalName == SystemUserDefinition.EntityName)
{
AdminOrganizationService.Associate(SystemUserDefinition.EntityName, userOrTeamRef.Id, new Microsoft.Xrm.Sdk.Relationship(RoleDefinition.ManyToManyRelationships.systemuserroles_association),
new EntityReferenceCollection {
roleRef
});
}
else
{
AdminOrganizationService.Associate(TeamDefinition.EntityName, userOrTeamRef.Id, new Microsoft.Xrm.Sdk.Relationship(RoleDefinition.ManyToManyRelationships.teamroles_association),
new EntityReferenceCollection {
roleRef
});
}
}
public static string GetAliasedValue(CRM.Entity entity, string fieldName)
{
if (entity == null || string.IsNullOrEmpty(fieldName))
{
return(string.Empty);
}
if (!entity.Contains(fieldName))
{
return(string.Empty);
}
CRM.AliasedValue alias = (CRM.AliasedValue)entity[fieldName];
if (alias.Value.GetType().ToString() == "System.Guid" || alias.Value.GetType().ToString() == "System.String" || alias.Value.GetType().ToString() == "System.Boolean" || alias.Value.GetType().ToString() == "System.Int32")
{
return(alias.Value.ToString());
}
if (alias.Value.GetType().ToString() == "System.Double")
{
return(Convert.ToDouble(alias.Value, CultureInfo.GetCultureInfo("en-us")).ToString("###0.000000", CultureInfo.GetCultureInfo("en-us")).Replace(',', '.'));
}
CRM.EntityReference referencia = (CRM.EntityReference)alias.Value;
return(referencia.Name);
}
private void AttachUpdatedDocumentToCase(ref IOrganizationService service, byte[] filebytes, EntityReference _CaseReference, string FileName)
{
string entitytype = "incident";
Guid EntityToAttachTo = Guid.Parse("FDA93807-4EF3-E711-80F2-3863BB2E34E8"); // The GUID of the incident
Entity Note = new Entity("annotation");
Note["objectid"] = new Microsoft.Xrm.Sdk.EntityReference(entitytype, EntityToAttachTo);
Note["objecttypecode"] = entitytype;
Note["subject"] = "Test Subject";
Note["notetext"] = "Test note text";
service.Create(Note);
//string encodedData = System.Convert.ToBase64String(filebytes);
//Entity AnnotationEntityObject = new Entity(_AnnotationEntityName);
//AnnotationEntityObject.Attributes[_ObjectIdFieldName] = _CaseReference;
//AnnotationEntityObject.Attributes[_SubjectFieldName] = FileName;
//AnnotationEntityObject.Attributes[_DocumentBodyFieldName] = encodedData;
//// Set the type of attachment
//AnnotationEntityObject.Attributes[_MimeTypeFieldName] = @"application\pdf";
//// Set the File Name
//AnnotationEntityObject.Attributes[_FileNameFieldName] = FileName;
//service.Create(AnnotationEntityObject);
}
public void AssociateRecords(Microsoft.Xrm.Sdk.EntityReference objectRef, Microsoft.Xrm.Sdk.Relationship relationName, params Microsoft.Xrm.Sdk.EntityReference[] entityReferences)
{
var collec = new EntityReferenceCollection();
collec.AddRange(entityReferences);
AdminOrganizationService.Associate(objectRef.LogicalName, objectRef.Id, relationName, collec);
}
public void AddToQueue(Guid queueId, Microsoft.Xrm.Sdk.EntityReference target)
{
var request = new AddToQueueRequest
{
Target = target,
DestinationQueueId = queueId
};
AdminOrganizationService.Execute(request);
}
public void RemoveUsersFromTeam(Microsoft.Xrm.Sdk.EntityReference teamRef, params Microsoft.Xrm.Sdk.EntityReference[] userRefs)
{
var request = new RemoveMembersTeamRequest
{
MemberIds = userRefs.Select(u => u.Id).ToArray(),
TeamId = teamRef.Id
};
AdminOrganizationService.Execute(request);
}
private Entity RetrieveInternal(Microsoft.Xrm.Sdk.EntityReference objectRef, ColumnSet cs)
{
var request = new RetrieveRequest
{
Target = objectRef,
ColumnSet = cs
};
return(((RetrieveResponse)AdminOrganizationService.Execute(request)).Entity);
}
public ICollection <Microsoft.Xrm.Sdk.EntityReference> GetTeamMemberRefs(Microsoft.Xrm.Sdk.EntityReference teamRef)
{
var queryMembers = new QueryExpression(SystemUserDefinition.EntityName);
queryMembers.ColumnSet.AddColumn(SystemUserDefinition.Columns.Id);
var linkMembers = queryMembers.AddLink(SystemUserDefinition.TeamMembershipRelationName, SystemUserDefinition.Columns.Id, SystemUserDefinition.Columns.Id);
var linkTeam = linkMembers.AddLink(TeamDefinition.EntityName, TeamDefinition.Columns.Id, TeamDefinition.Columns.Id);
linkTeam.LinkCriteria.AddCondition(TeamDefinition.Columns.Id, ConditionOperator.Equal, teamRef.Id);
return(AdminOrganizationService.RetrieveAll(queryMembers, false).Select(e => e.ToEntityReference()).ToList());
}
public void Merge(Microsoft.Xrm.Sdk.EntityReference target, Guid subordonate, Entity content)
{
var request = new MergeRequest
{
Target = target,
SubordinateId = subordonate,
UpdateContent = content,
PerformParentingChecks = true
};
AdminOrganizationService.Execute(request);
}
private Microsoft.Xrm.Sdk.EntityReference GetRoleRefForBusinessUnit(Microsoft.Xrm.Sdk.EntityReference businessUnitRef, string parentRootRoleIdOrTemplateId)
{
var queryRole = new QueryExpression(RoleDefinition.EntityName);
var filterParent = queryRole.Criteria.AddFilter(LogicalOperator.Or);
filterParent.AddCondition(RoleDefinition.Columns.RoleTemplateId, ConditionOperator.Equal, new Guid(parentRootRoleIdOrTemplateId));
filterParent.AddCondition(RoleDefinition.Columns.ParentRootRoleId, ConditionOperator.Equal, new Guid(parentRootRoleIdOrTemplateId));
queryRole.Criteria.AddCondition(RoleDefinition.Columns.BusinessUnitId, ConditionOperator.Equal, businessUnitRef.Id);
return(AdminOrganizationService.RetrieveMultiple(queryRole).Entities.Select(e => e.ToEntityReference()).FirstOrDefault());
}
public void AddUsersToTeam(Microsoft.Xrm.Sdk.EntityReference teamRef, params Microsoft.Xrm.Sdk.EntityReference[] userRefs)
{
if (userRefs.Length == 0)
{
return;
}
var request = new AddMembersTeamRequest
{
MemberIds = userRefs.Select(u => u.Id).ToArray(),
TeamId = teamRef.Id
};
AdminOrganizationService.Execute(request);
}
public Entity Retrieve(Microsoft.Xrm.Sdk.EntityReference objectRef, bool allColumns)
{
#region Parameters check
if (objectRef == null)
{
throw new ArgumentNullException(nameof(objectRef));
}
if (!allColumns)
{
throw new ArgumentNullException(nameof(allColumns));
}
#endregion
return(RetrieveInternal(objectRef, new ColumnSet(allColumns)));
}
public void AssignEntity(Microsoft.Xrm.Sdk.EntityReference objectReference, Microsoft.Xrm.Sdk.EntityReference ownerRef)
{
#region Parameters check
if (objectReference == null)
{
throw new ArgumentNullException(nameof(objectReference));
}
#endregion
AdminOrganizationService.Execute(new AssignRequest
{
Assignee = ownerRef ?? new Microsoft.Xrm.Sdk.EntityReference("systemuser", InitiatingUserId),
Target = objectReference
});
}
public void Delete(Microsoft.Xrm.Sdk.EntityReference objectReference, bool useAdmin = false)
{
#region Parameters check
if (objectReference == null)
{
throw new ArgumentNullException(nameof(objectReference));
}
#endregion
var service = GetService(useAdmin);
service.Execute(new DeleteRequest {
Target = objectReference
});
}
/// <summary>
/// Creates a new account with a given name and then creates a follow-up task linked to the account
/// </summary>
/// <param name="accountName">account name</param>
/// <param name="service">organization service</param>
public static void CreateCrmAccount2(string accountName, IOrganizationService service)
{
//create the account
Entity account = new Entity("account");
account["name"] = accountName;
Guid newId = service.Create(account);
//get the account number
account = service.Retrieve("account", newId, new Microsoft.Xrm.Sdk.Query.ColumnSet(new string[] { "name", "accountid", "accountnumber" }));
string accountNumber = account["accountnumber"].ToString();
//create the task
Entity task = new Entity("task");
task["subject"] = "Finish account set up for " + accountName + " - " + accountNumber;
task["regardingobjectid"] = new Microsoft.Xrm.Sdk.EntityReference("account", newId);
service.Create(task);
}
public void SetState(Microsoft.Xrm.Sdk.EntityReference objectRef, int stateCode, int statusCode, bool useAdmin = false)
{
#region Parameters check
if (objectRef == null)
{
throw new ArgumentNullException(nameof(objectRef));
}
#endregion
var service = GetService(useAdmin);
service.Execute(new SetStateRequest
{
EntityMoniker = objectRef,
State = new OptionSetValue(stateCode),
Status = new OptionSetValue(statusCode)
});
}
public ICollection <Guid> GetUserRoleIds(Microsoft.Xrm.Sdk.EntityReference userRef)
{
var query = new QueryExpression(RoleDefinition.EntityName);
query.ColumnSet.AddColumns(RoleDefinition.Columns.RoleTemplateId, RoleDefinition.Columns.ParentRootRoleId);
var userRoleLink = query.AddLink(SystemUserRolesDefinition.EntityName, RoleDefinition.Columns.Id, SystemUserRolesDefinition.Columns.RoleId);
var userLink = userRoleLink.AddLink(SystemUserDefinition.EntityName, SystemUserRolesDefinition.Columns.SystemUserId, SystemUserDefinition.Columns.Id);
userLink.LinkCriteria.AddCondition(SystemUserDefinition.Columns.Id, ConditionOperator.Equal, userRef.Id);
return(AdminOrganizationService.RetrieveMultiple(query).Entities
.Select(r =>
r.Contains(RoleDefinition.Columns.RoleTemplateId) ?
r.GetAttributeValue <Microsoft.Xrm.Sdk.EntityReference>(RoleDefinition.Columns.RoleTemplateId).Id :
r.GetAttributeValue <Microsoft.Xrm.Sdk.EntityReference>(RoleDefinition.Columns.ParentRootRoleId).Id
).ToList());
}
/// <summary>
/// Creates a new account with a given name and then creates a follow-up task linked to the account
/// </summary>
/// <param name="accountName">account name</param>
/// <param name="service">organization service</param>
public static void CreateCrmAccount2(string accountName, IOrganizationService service)
{
//create the account
Entity account = new Entity("account");
account["name"] = accountName;
Guid newId = service.Create(account);
//get the account number
account = service.Retrieve("account", newId, new Microsoft.Xrm.Sdk.Query.ColumnSet(new string[] { "name", "accountid", "accountnumber" }));
string accountNumber = account["accountnumber"].ToString();
//create the task
Entity task = new Entity("task");
task["subject"] = "Finish account set up for " + accountName + " - " + accountNumber;
task["regardingobjectid"] = new Microsoft.Xrm.Sdk.EntityReference("account", newId);
service.Create(task);
}
public Entity Retrieve(Microsoft.Xrm.Sdk.EntityReference objectRef, params string[] columns)
{
#region Parameters check
if (objectRef == null)
{
throw new ArgumentNullException(nameof(objectRef));
}
if (columns == null)
{
throw new ArgumentNullException(nameof(columns));
}
if (columns.Length == 0)
{
throw new ArgumentNullException("columns.Length");
}
#endregion
return(RetrieveInternal(objectRef, new ColumnSet(columns)));
}
public static EntityCollection RetrieveManyToManyRelationship(string currentEntityLogicalName
, string otherEntityPrimaryIdAttribute
, Microsoft.Xrm.Sdk.EntityReference otherEntityReference
, string relationshipSchemaName
, IOrganizationService organizationService
)
{
EntityCollection entityCollection = null;
Microsoft.Xrm.Sdk.Relationship relationship = new Microsoft.Xrm.Sdk.Relationship(relationshipSchemaName);
QueryExpression query = new QueryExpression();
query.EntityName = currentEntityLogicalName;
query.ColumnSet = new ColumnSet(true);
RelationshipQueryCollection relatedEntity = new RelationshipQueryCollection();
relatedEntity.Add(relationship, query);
RetrieveRequest request = new RetrieveRequest();
request.RelatedEntitiesQuery = relatedEntity;
request.ColumnSet = new ColumnSet(otherEntityPrimaryIdAttribute);
request.Target = otherEntityReference;
RetrieveResponse response = (RetrieveResponse)organizationService.Execute(request);
if (((DataCollection <Microsoft.Xrm.Sdk.Relationship, Microsoft.Xrm.Sdk.EntityCollection>)(((RelatedEntityCollection)(response.Entity.RelatedEntities)))).Contains(new Microsoft.Xrm.Sdk.Relationship(relationshipSchemaName)) &&
((DataCollection <Microsoft.Xrm.Sdk.Relationship, Microsoft.Xrm.Sdk.EntityCollection>)(((RelatedEntityCollection)(response.Entity.RelatedEntities))))[new Microsoft.Xrm.Sdk.Relationship(relationshipSchemaName)].Entities.Any())
{
DataCollection <Microsoft.Xrm.Sdk.Entity> results = ((DataCollection <Microsoft.Xrm.Sdk.Relationship, Microsoft.Xrm.Sdk.EntityCollection>)(((RelatedEntityCollection)(response.Entity.RelatedEntities))))[new Microsoft.Xrm.Sdk.Relationship(relationshipSchemaName)].Entities;
if (results != null && results.Any())
{
entityCollection = new EntityCollection();
entityCollection.Entities.AddRange(results);
}
}
return(entityCollection);
}
public void UnShare(Microsoft.Xrm.Sdk.EntityReference objectRef, Microsoft.Xrm.Sdk.EntityReference revokeeRef, Microsoft.Xrm.Sdk.EntityReference callerRef = null)
{
#region Parameters check
if (objectRef == null)
{
throw new ArgumentNullException(nameof(objectRef));
}
if (revokeeRef == null)
{
throw new ArgumentNullException(nameof(revokeeRef));
}
#endregion
var service = GetService(callerRef?.Id ?? Guid.Empty);
service.Execute(new RevokeAccessRequest
{
Target = objectRef,
Revokee = revokeeRef
});
}
public void Share(Microsoft.Xrm.Sdk.EntityReference objectRef, Microsoft.Xrm.Sdk.EntityReference assigneeRef, AccessRights accessRights)
{
#region Parameters check
if (objectRef == null)
{
throw new ArgumentNullException(nameof(objectRef));
}
if (assigneeRef == null)
{
throw new ArgumentNullException(nameof(assigneeRef));
}
#endregion
AdminOrganizationService.Execute(new GrantAccessRequest
{
Target = objectRef,
PrincipalAccess = new PrincipalAccess
{
AccessMask = accessRights,
Principal = assigneeRef
}
});
}
/// <summary>
/// List all SupportIssues
/// </summary>
private static void listSupportIssues(XrmServiceContext xrm)
{
var supportIssues = xrm.po_supportissueSet;
int i = 0;
String heading = "Date Created;Subject;Regarding;Issues Resolution;Priority;;" +
"StateCode;StatusCode;po_IssueStatus;Description;activity;processed";
String format = "{0};{1};{2};{3};{4};;{5};{6};{7};{8};{9};{10}";
Console.WriteLine(heading);
//Write the example contacts.
foreach (var supportIssue in supportIssues)
{
String priority = supportIssue.FormattedValues["prioritycode"].ToString();
String activity = supportIssue.FormattedValues["activitytypecode"].ToString();
String processed = "";
String att = "po_issuestatus";
var n = supportIssue.po_IssueStatus;
String issueStatus = supportIssue.FormattedValues[att].ToString();
var n2 = supportIssue.OwningUser;
var n3 = supportIssue.CreatedOn;
//displayAttributes(supportIssue);
EntityReference er;
er = (EntityReference)supportIssue.Attributes["regardingobjectid"];
String accountName = er.Name;
Console.WriteLine(String.Format(format,
supportIssue.CreatedOn, supportIssue.Subject, accountName, supportIssue.po_IssueResolution, priority,
supportIssue.StateCode, supportIssue.StatusCode, supportIssue.po_IssueStatus,
supportIssue.Description, activity, processed));
if ("Support01".Equals(supportIssue.Subject))
{
//Helper.showFields(supportIssue);
}
i++;
}
}
private void btnMigrateRecordBPF_Click(object sender, EventArgs evt)
{
if (!AllowMigrateButton())
{
return;
}
string bpfSelectedEntityTarget = bpfSelected.Attributes["uniquename"].ToString();
var stageId = stageList.FirstOrDefault(w => w.Attributes["stagename"] == cbTargetBPFStages.SelectedItem);
List <string> traversedpath = new List <string>();
string targetStage = cbTargetBPFStages.SelectedItem.ToString();
var totalRecordMigrated = 0;
var totalRecordInstanced = 0;
var totalRecordUpdated = 0;
var totalSkipped = 0;
totalRecordToMigrate = userList.Count * recordToMigrateList.Count;
migrationErrors = new List <MigrationError>();
manageEnablingOfControls(false);
DisplayStatsMiddle();
// Init progressBar
SendMessageToStatusBar(this, new StatusBarMessageEventArgs(0, "Starting migration ..."));
WorkAsync(new WorkAsyncInfo
{
Message = $"Migrating the Business Process flows for each users and records {Environment.NewLine}May take a moment ...",
IsCancelable = true,
Work = (bw, e) =>
{
List <Entity> retrieveExistingBPFInstances = null;
try
{
retrieveExistingBPFInstances = dm.GetExistingBPFInstances(bpfSelected.GetAttributeValue <string>("uniquename"),
recordToMigrateList.FirstOrDefault().LogicalName, recordToMigrateList.Select(x => x.Id).ToArray());
}
catch (Exception exception)
{
if (!continueOnPermissionError)
{
var result = MessageBox.Show(exception.Message, "Error during migration !",
MessageBoxButtons.YesNo, MessageBoxIcon.Error);
if (result == DialogResult.No)
{
return;
}
else if (result == DialogResult.Yes)
{
continueOnPermissionError = true;
}
}
}
var userProceed = 1;
int progress = ((((totalRecordUpdated + totalRecordInstanced) / 2) * 100) / totalRecordToMigrate);
foreach (var user in userList)
{
if (bw.CancellationPending)
{
e.Cancel = true;
break;
}
var numberOfRecordsToProceed = recordToMigrateList.Count;
var recordInstanced = 0;
var recordUpdated = 0;
var executeMultipleRequestSetBPF = new ExecuteMultipleRequest()
{
Settings = new ExecuteMultipleSettings()
{
ContinueOnError = false,
ReturnResponses = true
},
Requests = new OrganizationRequestCollection()
};
// Instancing the BPF first
foreach (var record in recordToMigrateList)
{
if (bw.CancellationPending)
{
e.Cancel = true;
break;
}
// Create the instance of the BPF on the record
SetProcessRequest setProcReq = new SetProcessRequest
{
Target = record.ToEntityReference(),
NewProcess = new EntityReference(bpfSelected.LogicalName, bpfSelected.Id),
};
var existingBPFInstance = retrieveExistingBPFInstances.FirstOrDefault(x => x.GetAttributeValue <EntityReference>("bpf_" + record.LogicalName + "id")?.Id == record.Id || x.GetAttributeValue <EntityReference>(record.LogicalName + "id")?.Id == record.Id);
if (existingBPFInstance != null)
{
setProcReq.NewProcessInstance = new EntityReference("workflow", existingBPFInstance.Id);
setProcReq.NewProcess = null;
}
executeMultipleRequestSetBPF.Requests.Add(setProcReq);
recordInstanced++;
totalRecordInstanced++;
if (recordInstanced % this.settings.NumberOfRecordPerRound == 0 || numberOfRecordsToProceed == recordInstanced)
{
ExecuteMultipleRequestBPF(user.Id, ref executeMultipleRequestSetBPF, bw,
recordInstanced, userProceed, "instanced");
progress = ((((totalRecordUpdated + totalRecordInstanced) / 2) * 100) / totalRecordToMigrate);
SendMessageToStatusBar(this, new StatusBarMessageEventArgs(progress, $"Migration in progress {progress}% ..."));
}
}
var executeMultipleRequestUpdateBPF = new ExecuteMultipleRequest
{
Settings = new ExecuteMultipleSettings
{
ContinueOnError = true,
ReturnResponses = true
},
Requests = new OrganizationRequestCollection()
};
List <Entity> resultQueryProperBPF = null;
//Updating the BPF stage + traversedpath
foreach (var record in recordToMigrateList)
{
if (bw.CancellationPending)
{
e.Cancel = true;
break;
}
var attrForCondition = bpfSelectedEntityTarget.Contains("_") ? $"bpf_{record.LogicalName}id" : $"{record.LogicalName}id";
// So we do it only once
if (resultQueryProperBPF == null)
{
try
{
resultQueryProperBPF = this.dm.GetProperBPFList(bpfSelectedEntityTarget,
recordToMigrateList, attrForCondition);
}
catch (Exception exception)
{
if (!continueOnPermissionError)
{
var result = MessageBox.Show(exception.Message, "Error during migration !",
MessageBoxButtons.YesNo, MessageBoxIcon.Error);
if (result == DialogResult.No)
{
return;
}
else if (result == DialogResult.Yes)
{
continueOnPermissionError = true;
continue;
}
}
else
{
continue;
}
}
}
var wantedBPFInstanceREcord = resultQueryProperBPF.FirstOrDefault(x => ((EntityReference)x.Attributes[attrForCondition]).Id == record.Id);
if (wantedBPFInstanceREcord == null)
{
//migrationErrors.Add(record);
continue;
}
// Preparing the traversedpath so we do it only once as it's the same path for all records
if (traversedpath.Count == 0)
{
var activePathRequest = new RetrieveActivePathRequest
{
ProcessInstanceId = wantedBPFInstanceREcord.Id
};
var activePathResponse =
(RetrieveActivePathResponse)this.dm.service.Execute(activePathRequest);
var stageDefinitions =
((EntityCollection)activePathResponse.Results.Values.FirstOrDefault())?.Entities;
foreach (var path in stageDefinitions)
{
traversedpath.Add(path.Id.ToString());
if (path.Attributes["stagename"].ToString() == targetStage)
{
break;
}
}
}
var bpfInstance = new Entity()
{
LogicalName = wantedBPFInstanceREcord.LogicalName,
Id = wantedBPFInstanceREcord.Id
};
bpfInstance["activestageid"] = new EntityReference(stageId.LogicalName, stageId.Id);
bpfInstance["traversedpath"] = String.Join(",", traversedpath);
UpdateRequest ur = new UpdateRequest()
{
Target = bpfInstance,
ConcurrencyBehavior = ConcurrencyBehavior.AlwaysOverwrite
};
executeMultipleRequestUpdateBPF.Requests.Add(ur);
recordUpdated++;
totalRecordMigrated++;
totalRecordUpdated++;
if (totalRecordUpdated % this.settings.NumberOfRecordPerRound == 0 || numberOfRecordsToProceed == recordUpdated)
{
ExecuteMultipleRequestBPF(user.Id, ref executeMultipleRequestUpdateBPF, bw,
recordUpdated, userProceed, "updated", false);
progress = ((((totalRecordUpdated + totalRecordInstanced) / 2) * 100) / totalRecordToMigrate);
SendMessageToStatusBar(this, new StatusBarMessageEventArgs(progress, $"Migration in progress {progress}% ..."));
}
Invoke(new Action(() =>
{
labelRecordsRemaining.Text = $@"{totalRecordToMigrate - totalRecordMigrated}";
}));
}
userProceed++;
bw?.ReportProgress(0, $"Processing user {userProceed}/{userList.Count} ...{Environment.NewLine}Total records migrated : {totalRecordMigrated}");
SendMessageToStatusBar(this, new StatusBarMessageEventArgs(progress, $"Migration in progress {progress}% ..."));
}
e.Result = totalRecordMigrated;
},
PostWorkCallBack = e =>
{
if (e.Error != null)
{
MessageBox.Show(this, e.Error.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
this.log.LogData(EventType.Exception, LogAction.RecordsMigrated, e.Error);
return;
}
else if (e.Cancelled)
{
this.log.LogData(EventType.Event, LogAction.MigrationCancelled);
MessageBox.Show(
$"The migration was successfully cancelled. {Environment.NewLine}{totalRecordMigrated} records were migrated.",
"Cancel", MessageBoxButtons.OK, MessageBoxIcon.Warning);
labelNumberOfRecordsToMigrate.Text = "The migration will handle : X records.";
labelRecordsRemaining.Text = "X";
labelTimeEstimation.Text = "This can take up to X time.";
SendMessageToStatusBar(this, new StatusBarMessageEventArgs(0, "Cancelled ..."));
}
else
{
MessageBox.Show($"You migrated {totalRecordMigrated} records !", "Migration done.", MessageBoxButtons.OK, MessageBoxIcon.Information);
SendMessageToStatusBar(this, new StatusBarMessageEventArgs("done!."));
this.log.LogData(EventType.Event, LogAction.RecordsMigrated);
}
manageEnablingOfControls(true);
},
ProgressChanged = e => { SetWorkingMessage(e.UserState.ToString()); }
});
}
/// <summary>
/// Get entity
/// </summary>
/// <param name="organizationService">Organization Service</param>
/// <param name="entityReference">Entity Reference</param>
/// <remarks>
/// Get entity record
/// </remarks>
protected static Entity RetrieveEntity(Microsoft.Xrm.Sdk.EntityReference entityReference, IOrganizationService organizationService)
{
return(RetrieveEntity(entityReference, null, organizationService));
}
private static object ParseAttributeToObject(object attribute, Entity entity, string attributeLogicalName)
{
object result;
if (attribute is EntityReference)
{
EntityReference entityReference = (EntityReference)attribute;
result = new TextValue
{
Value = entityReference.Id.ToString().ToUpper(),
Text = entityReference.Name
};
}
else if (attribute is OptionSetValue)
{
var optionSetValue = (OptionSetValue)attribute;
var value = optionSetValue.Value;
var text = string.Empty;
if (entity.FormattedValues.ContainsKey(attributeLogicalName))
{
text = entity.FormattedValues[attributeLogicalName];
}
result = new TextValue
{
Text = text,
Value = value == 99999 ? string.Empty : value.ToString()
};
}
else if (attribute is OptionSetValueCollection)
{
var optionSetValueCollection = (OptionSetValueCollection)attribute;
var list = new List <TextValue>();
int i = 0;
foreach (var optionSetValue in optionSetValueCollection)
{
var value = optionSetValue.Value;
var text = string.Empty;
if (entity.FormattedValues.ContainsKey(attributeLogicalName))
{
text = entity.FormattedValues[attributeLogicalName].Split(";".ToCharArray())[i].Trim();
i++;
}
list.Add(new TextValue {
Text = text, Value = value.ToString()
});
}
result = list;
}
else if (attribute is DateTime)
{
var dateTime = (DateTime)attribute;
result = dateTime.AddHours(7);
}
else if (attribute is Money)
{
var money = (Money)attribute;
result = money.Value;
}
else if (attribute is int)
{
var @int = (int)attribute;
result = @int;
}
else if (attribute is double)
{
var @double = (double)attribute;
result = @double;
}
else if (attribute is Guid)
{
var guid = (Guid)attribute;
result = guid.ToString().ToUpper();
}
else if (attribute is AliasedValue)
{
var aliasedValue = (AliasedValue)attribute;
return(ParseAttributeToObject(aliasedValue.Value, entity, attributeLogicalName));
}
else if (attribute is EntityCollection)
{
var entityCollection = (EntityCollection)attribute;
result = ToDebug(entityCollection.Entities);
}
else if (attribute is bool)
{
var boolean = (bool)attribute;
var text = string.Empty;
if (entity.FormattedValues.ContainsKey(attributeLogicalName))
{
text = entity.FormattedValues[attributeLogicalName];
}
result = new TextValue
{
Text = text,
Value = boolean.ToString()
};
}
else if (attribute is long)
{
var @long = (long)attribute;
result = @long;
}
else if (attribute is decimal)
{
var @decimal = (decimal)attribute;
result = @decimal;
}
else if (attribute is byte[])
{
var bytes = (byte[])attribute;
result = bytes;
}
else if (attribute is BooleanManagedProperty)
{
var @bool = (BooleanManagedProperty)attribute;
result = @bool.Value;
}
else if (attribute is string)
{
var @string = (string)attribute;
result = @string;
}
else
{
result = attribute.ToString();
}
return(result);
}
/// <summary>
/// Associate method override. Takes EntityReference as primary entity input parameter and list of EntityReferences as related entities parameter
/// </summary>
public static void Disassociate(this IOrganizationService service, EntityReference primaryEntity, String relationshipName, IList <EntityReference> relatedEntities)
{
service.Disassociate(primaryEntity, relationshipName, new EntityReferenceCollection(relatedEntities));
}
/// <summary>
/// Associate method override. Takes EntityReference as primary entity input parameter
/// </summary>
public static void Disassociate(this IOrganizationService service, EntityReference primaryEntity, String relationshipName, EntityReferenceCollection relatedEntities)
{
service.Disassociate(primaryEntity.LogicalName, primaryEntity.Id, new Relationship(relationshipName), relatedEntities);
}
public void Detach(Microsoft.Xrm.Sdk.EntityReference eref)
{
this.Detach(eref.LogicalName, eref.Id);
}
public T GetById <T>(Microsoft.Xrm.Sdk.EntityReference entityReference) where T : IBindingModel, new()
{
return(AdminOrganizationService.GetById <T>(entityReference));
}
private static void WriteAttributes(StreamWriter sw, AttributeCollection attributes)
{
foreach (System.Collections.Generic.KeyValuePair<string, object> a in attributes)
{
if (a.Value is Microsoft.Xrm.Sdk.EntityReference)
{
er = (Microsoft.Xrm.Sdk.EntityReference)a.Value;
sw.WriteLine(a.Key + " = " + er.Name);
}
else if (a.Value is Microsoft.Xrm.Sdk.OptionSetValue)
{
osv = (Microsoft.Xrm.Sdk.OptionSetValue)a.Value;
sw.WriteLine(a.Key + " = " + osv.Value);
}
else
sw.WriteLine(a.Key + " = " + a.Value);
}
}
