public override void ExecuteExtention(BulkUpdateRequest request, BulkUpdateResponse response,
ServiceRequestController controller)
{
var countToUpdate = request.RecordCount;
var countUpdated = 0;
controller.UpdateProgress(0, countToUpdate, "Executing Updates");
var estimator = new TaskEstimator(countToUpdate);
foreach (var record in request.GetRecordsToUpdate())
{
try
{
var newRecord = RecordService.NewRecord(request.RecordType.Key);
newRecord.Id = record.Id;
if (request.ClearValue)
{
newRecord.SetField(request.FieldToSet.Key, null, RecordService);
}
else
{
newRecord.SetField(request.FieldToSet.Key, request.ValueToSet, RecordService);
}
RecordService.Update(newRecord, new[] { request.FieldToSet.Key });
}
catch (Exception ex)
{
response.AddResponseItem(new BulkUpdateResponseItem(record.Id, record.GetStringField(RecordService.GetPrimaryField(record.Type)), ex));
}
countUpdated++;
controller.UpdateProgress(countUpdated, countToUpdate, estimator.GetProgressString(countUpdated, taskName: "Executing Updates"));
}
}
public override void ExecuteExtention(BulkDeleteRequest request, BulkDeleteResponse response,
ServiceRequestController controller)
{
var countToUpdate = request.RecordCount;
var countUpdated = 0;
controller.UpdateProgress(0, countToUpdate, "Executing Deletions");
var estimator = new TaskEstimator(countToUpdate);
foreach (var record in request.GetRecordsToUpdate())
{
try
{
var newRecord = RecordService.NewRecord(request.RecordType.Key);
newRecord.Id = record.Id;
RecordService.Delete(newRecord);
}
catch (Exception ex)
{
response.AddResponseItem(new BulkDeleteResponseItem(record.Id, record.GetStringField(RecordService.GetPrimaryField(record.Type)), ex));
}
countUpdated++;
controller.UpdateProgress(countUpdated, countToUpdate, estimator.GetProgressString(countUpdated, taskName: "Executing Deletions"));
}
}
public override void ExecuteExtention(BulkReplaceRequest request, BulkReplaceResponse response,
LogController controller)
{
var countToUpdate = request.RecordCount;
var countUpdated = 0;
controller.UpdateProgress(0, countToUpdate, "Executing Replacements");
var estimator = new TaskEstimator(countToUpdate);
foreach (var record in request.GetRecordsToUpdate())
{
try
{
var newRecord = RecordService.NewRecord(request.RecordType.Key);
newRecord.Id = record.Id;
var previousValue = record.GetStringField(request.FieldToReplaceIn.Key);
var newValue = previousValue == null ? null : previousValue.Replace(request.OldValue, request.NewValue);
if (previousValue != newValue)
{
newRecord.SetField(request.FieldToReplaceIn.Key, newValue, RecordService);
RecordService.Update(newRecord, new[] { request.FieldToReplaceIn.Key });
}
}
catch (Exception ex)
{
response.AddResponseItem(new BulkReplaceResponseItem(record.Id, record.GetStringField(RecordService.GetPrimaryField(record.Type)), ex));
}
countUpdated++;
controller.UpdateProgress(countUpdated, countToUpdate, estimator.GetProgressString(countUpdated, taskName: "Executing Replacements"));
}
}
public override void ExecuteExtention(BulkCopyFieldValueRequest request, BulkCopyFieldValueResponse response,
ServiceRequestController controller)
{
var countToUpdate = request.RecordCount;
var countUpdated = 0;
controller.UpdateProgress(0, countToUpdate, "Executing Updates");
var estimator = new TaskEstimator(countToUpdate);
foreach (var record in request.GetRecordsToUpdate())
{
try
{
var reloadRecord = RecordService.Get(record.Type, record.Id, new[] { request.SourceField.Key, request.TargetField.Key });
if ((request.CopyIfNull || reloadRecord.GetField(request.SourceField.Key) != null) &&
(request.OverwriteIfPopulated || reloadRecord.GetField(request.TargetField.Key) == null))
{
reloadRecord.SetField(request.TargetField.Key, reloadRecord.GetField(request.SourceField.Key), RecordService);
RecordService.Update(reloadRecord, new[] { request.TargetField.Key });
}
}
catch (Exception ex)
{
response.AddResponseItem(new BulkCopyFieldValueResponseItem(record.Id, record.GetStringField(RecordService.GetPrimaryField(record.Type)), ex));
}
countUpdated++;
controller.UpdateProgress(countUpdated, countToUpdate, estimator.GetProgressString(countUpdated, taskName: "Executing Updates"));
}
response.Message = "Copies Completed";
}
public void TaskEstimatorTestsTest()
{
var iterations = 2;
var taskEstimator = new TaskEstimator(iterations);
for (var i = 0; i < iterations; i++)
{
Thread.Sleep(1000);
Debug.WriteLine($"Remaining {taskEstimator.GetProgressString(i + 1, taskName: "Executing Test")}");
}
}
public override void ExecuteExtention(BulkUpdateRequest request, BulkUpdateResponse response,
ServiceRequestController controller)
{
var countToUpdate = request.RecordCount;
var countUpdated = 0;
controller.UpdateProgress(0, countToUpdate, "Executing Updates");
var estimator = new TaskEstimator(countToUpdate);
var recordsRemaining = request.GetRecordsToUpdate().ToList();
while (recordsRemaining.Any())
{
controller.UpdateProgress(countUpdated, countToUpdate, estimator.GetProgressString(countUpdated, taskName: "Executing Updates"));
var thisSetOfRecords = recordsRemaining
.Take(request.ExecuteMultipleSetSize ?? 50)
.ToList();
recordsRemaining.RemoveRange(0, thisSetOfRecords.Count);
var thisSetOfRecordsNew = thisSetOfRecords
.Select(r =>
{
var newRecord = RecordService.NewRecord(request.RecordType.Key);
newRecord.Id = r.Id;
if (request.ClearValue)
{
newRecord.SetField(request.FieldToSet.Key, null, RecordService);
}
else
{
newRecord.SetField(request.FieldToSet.Key, request.ValueToSet, RecordService);
}
if (request.AddUpdateField2)
{
if (request.ClearValue2)
{
newRecord.SetField(request.FieldToSet2.Key, null, RecordService);
}
else
{
newRecord.SetField(request.FieldToSet2.Key, request.ValueToSet2, RecordService);
}
}
if (request.AddUpdateField3)
{
if (request.ClearValue3)
{
newRecord.SetField(request.FieldToSet3.Key, null, RecordService);
}
else
{
newRecord.SetField(request.FieldToSet3.Key, request.ValueToSet3, RecordService);
}
}
if (request.AddUpdateField4)
{
if (request.ClearValue4)
{
newRecord.SetField(request.FieldToSet4.Key, null, RecordService);
}
else
{
newRecord.SetField(request.FieldToSet4.Key, request.ValueToSet4, RecordService);
}
}
if (request.AddUpdateField5)
{
if (request.ClearValue5)
{
newRecord.SetField(request.FieldToSet5.Key, null, RecordService);
}
else
{
newRecord.SetField(request.FieldToSet5.Key, request.ValueToSet5, RecordService);
}
}
return(newRecord);
})
.ToArray();
var errorsThisIteration = 0;
//old versions dont have execute multiple so if 1 then do each request
if (thisSetOfRecordsNew.Count() == 1)
{
var record = thisSetOfRecordsNew.First();
try
{
RecordService.Update(record);
}
catch (Exception ex)
{
response.AddResponseItem(new BulkUpdateResponseItem(record.Id, record.GetStringField(RecordService.GetPrimaryField(record.Type)), ex));
errorsThisIteration++;
}
}
else
{
var multipleResponse = RecordService.UpdateMultiple(thisSetOfRecordsNew);
foreach (var item in multipleResponse)
{
var originalRecord = thisSetOfRecords[item.Key];
response.AddResponseItem(new BulkUpdateResponseItem(originalRecord.Id, originalRecord.GetStringField(RecordService.GetPrimaryField(originalRecord.Type)), item.Value));
}
errorsThisIteration += multipleResponse.Count;
}
countUpdated += thisSetOfRecords.Count();
response.NumberOfErrors += errorsThisIteration;
response.TotalRecordsProcessed = countUpdated;
}
controller.UpdateProgress(1, 1, "Updates Completed");
response.Message = "Updates Completed";
}
public override void ExecuteExtention(BulkReplaceRequest request, BulkReplaceResponse response,
ServiceRequestController controller)
{
var countToUpdate = request.RecordCount;
var countUpdated = 0;
controller.UpdateProgress(0, countToUpdate, "Executing Replacements");
var estimator = new TaskEstimator(countToUpdate);
var recordsRemaining = request.GetRecordsToUpdate().ToList();
while (recordsRemaining.Any())
{
controller.UpdateProgress(countUpdated, countToUpdate, estimator.GetProgressString(countUpdated, taskName: "Executing Replacements"));
var thisSetOfRecords = recordsRemaining
.Take(request.ExecuteMultipleSetSize ?? 50)
.ToList();
recordsRemaining.RemoveRange(0, thisSetOfRecords.Count);
var thisSetOfRecordsNew = RecordService.GetMultiple(thisSetOfRecords.First().Type,
thisSetOfRecords.Select(r => r.Id),
request.FieldsToReplace.Select(f => f.RecordField.Key).ToArray())
.ToArray();
var errorsThisIteration = 0;
var recordsToUpdate = new List <IRecord>();
foreach (var record in thisSetOfRecordsNew)
{
try
{
var newRecord = RecordService.NewRecord(record.Type);
newRecord.Id = record.Id;
var isUpdate = false;
foreach (var field in request.FieldsToReplace)
{
var previousValue = record.GetStringField(field.RecordField.Key);
var newValue = previousValue;
foreach (var replacement in request.ReplacementTexts)
{
newValue = newValue == null ? null : newValue.Replace(replacement.OldText, replacement.NewText);
}
if (previousValue != newValue)
{
newRecord.SetField(field.RecordField.Key, newValue, RecordService);
isUpdate = true;
}
}
if (isUpdate)
{
recordsToUpdate.Add(newRecord);
}
}
catch (Exception ex)
{
errorsThisIteration++;
response.AddResponseItem(new BulkReplaceResponseItem(record.Id, record.GetStringField(RecordService.GetPrimaryField(record.Type)), ex));
}
}
//old versions dont have execute multiple so if 1 then do each request
if (recordsToUpdate.Count() == 1)
{
var record = recordsToUpdate.First();
try
{
RecordService.Update(record);
}
catch (Exception ex)
{
errorsThisIteration++;
response.AddResponseItem(new BulkReplaceResponseItem(record.Id, null, ex));
}
}
else
{
var multipleResponse = RecordService.UpdateMultiple(recordsToUpdate);
foreach (var item in multipleResponse)
{
var originalRecord = recordsToUpdate[item.Key];
response.AddResponseItem(new BulkReplaceResponseItem(originalRecord.Id, null, item.Value));
}
errorsThisIteration += multipleResponse.Count;
}
countUpdated += thisSetOfRecords.Count();
response.TotalRecordsProcessed = countUpdated;
response.TotalRecordsUpdated += recordsToUpdate.Count();
response.NumberOfErrors += errorsThisIteration;
}
controller.UpdateProgress(1, 1, "Replaces Completed");
response.Message = "Replaces Completed";
}
public IEnumerable <DataImportResponseItem> DoImport(IEnumerable <Entity> entities, LogController controller, bool maskEmails)
{
controller.LogLiteral("Preparing Import");
var response = new List <DataImportResponseItem>();
var fieldsToRetry = new Dictionary <Entity, List <string> >();
var typesToImport = entities.Select(e => e.LogicalName).Distinct();
var allNNRelationships = XrmService.GetAllNnRelationshipEntityNames();
var associationTypes = typesToImport.Where(allNNRelationships.Contains).ToArray();
typesToImport = typesToImport.Where(t => !associationTypes.Contains(t)).ToArray();
var orderedTypes = new List <string>();
var idSwitches = new Dictionary <string, Dictionary <Guid, Guid> >();
foreach (var item in typesToImport)
{
idSwitches.Add(item, new Dictionary <Guid, Guid>());
}
#region tryordertypes
//lets put team first because some other records
//may reference the queue which only gets created
//when the team does
typesToImport = typesToImport.OrderBy(s => s == Entities.team ? 0 : 1).ToArray();
foreach (var type in typesToImport)
{
//iterate through the types and if any of them have a lookup which references this type
//then insert this one before it for import first
//otherwise just append to the end
foreach (var type2 in orderedTypes)
{
var thatType = type2;
var thatTypeEntities = entities.Where(e => e.LogicalName == thatType).ToList();
var fields = GetFieldsToImport(thatTypeEntities, thatType)
.Where(f => XrmService.FieldExists(f, thatType) && XrmService.IsLookup(f, thatType));
foreach (var field in fields)
{
if (thatTypeEntities.Any(e => e.GetLookupType(field) == type))
{
orderedTypes.Insert(orderedTypes.IndexOf(type2), type);
break;
}
}
if (orderedTypes.Contains(type))
{
break;
}
}
if (!orderedTypes.Contains(type))
{
orderedTypes.Add(type);
}
}
#endregion tryordertypes
var estimator = new TaskEstimator(1);
var countToImport = orderedTypes.Count;
var countImported = 0;
foreach (var recordType in orderedTypes)
{
try
{
var thisRecordType = recordType;
var displayPrefix = $"Importing {recordType} Records ({countImported + 1}/{countToImport})";
controller.UpdateProgress(countImported++, countToImport, string.Format("Importing {0} Records", recordType));
controller.UpdateLevel2Progress(0, 1, "Loading");
var primaryField = XrmService.GetPrimaryNameField(recordType);
var thisTypeEntities = entities.Where(e => e.LogicalName == recordType).ToList();
var orConditions = thisTypeEntities
.Select(
e =>
new ConditionExpression(XrmService.GetPrimaryKeyField(e.LogicalName),
ConditionOperator.Equal, e.Id))
.ToArray();
var existingEntities = XrmService.RetrieveAllOrClauses(recordType, orConditions);
var orderedEntities = new List <Entity>();
#region tryorderentities
var importFieldsForEntity = GetFieldsToImport(thisTypeEntities, recordType).ToArray();
var fieldsDontExist = GetFieldsInEntities(thisTypeEntities)
.Where(f => !XrmService.FieldExists(f, thisRecordType))
.Where(f => !HardcodedIgnoreFields.Contains(f))
.Distinct()
.ToArray();
foreach (var field in fieldsDontExist)
{
response.Add(
new DataImportResponseItem(recordType, field, null,
string.Format("Field {0} On Entity {1} Doesn't Exist In Target Instance And Will Be Ignored", field, recordType),
new NullReferenceException(string.Format("Field {0} On Entity {1} Doesn't Exist In Target Instance And Will Be Ignored", field, recordType))));
}
var selfReferenceFields = importFieldsForEntity.Where(
f =>
XrmService.IsLookup(f, recordType) &&
XrmService.GetLookupTargetEntity(f, recordType) == recordType).ToArray();
foreach (var entity in thisTypeEntities)
{
foreach (var entity2 in orderedEntities)
{
if (selfReferenceFields.Any(f => entity2.GetLookupGuid(f) == entity.Id || (entity2.GetLookupGuid(f) == Guid.Empty && entity2.GetLookupName(f) == entity.GetStringField(primaryField))))
{
orderedEntities.Insert(orderedEntities.IndexOf(entity2), entity);
break;
}
}
if (!orderedEntities.Contains(entity))
{
orderedEntities.Add(entity);
}
}
#endregion tryorderentities
var countRecordsToImport = orderedEntities.Count;
var countRecordsImported = 0;
estimator = new TaskEstimator(countRecordsToImport);
foreach (var entity in orderedEntities)
{
var thisEntity = entity;
try
{
var existingMatchingIds = GetMatchForExistingRecord(existingEntities, thisEntity);
if (existingMatchingIds.Any())
{
var matchRecord = existingMatchingIds.First();
idSwitches[recordType].Add(thisEntity.Id, matchRecord.Id);
thisEntity.Id = matchRecord.Id;
thisEntity.SetField(XrmService.GetPrimaryKeyField(thisEntity.LogicalName), thisEntity.Id);
}
var isUpdate = existingMatchingIds.Any();
foreach (var field in thisEntity.GetFieldsInEntity().ToArray())
{
if (importFieldsForEntity.Contains(field) &&
XrmService.IsLookup(field, thisEntity.LogicalName) &&
thisEntity.GetField(field) != null)
{
var idNullable = thisEntity.GetLookupGuid(field);
if (idNullable.HasValue)
{
var targetTypesToTry = GetTargetTypesToTry(thisEntity, field);
var name = thisEntity.GetLookupName(field);
var fieldResolved = false;
foreach (var lookupEntity in targetTypesToTry)
{
var targetPrimaryKey = XrmRecordService.GetPrimaryKey(lookupEntity);
var targetPrimaryField = XrmRecordService.GetPrimaryField(lookupEntity);
var matchRecord = XrmService.GetFirst(lookupEntity, targetPrimaryKey,
idNullable.Value);
if (matchRecord != null)
{
thisEntity.SetLookupField(field, matchRecord);
fieldResolved = true;
}
else
{
var matchRecords = name.IsNullOrWhiteSpace() ?
new Entity[0] :
GetMatchingEntities(lookupEntity,
targetPrimaryField,
name);
if (matchRecords.Count() == 1)
{
thisEntity.SetLookupField(field, matchRecords.First());
fieldResolved = true;
}
}
if (!fieldResolved)
{
if (!fieldsToRetry.ContainsKey(thisEntity))
{
fieldsToRetry.Add(thisEntity, new List <string>());
}
fieldsToRetry[thisEntity].Add(field);
}
}
}
}
}
var fieldsToSet = new List <string>();
fieldsToSet.AddRange(thisEntity.GetFieldsInEntity()
.Where(importFieldsForEntity.Contains));
if (fieldsToRetry.ContainsKey(thisEntity))
{
fieldsToSet.RemoveAll(f => fieldsToRetry[thisEntity].Contains(f));
}
if (maskEmails)
{
var emailFields = new[] { "emailaddress1", "emailaddress2", "emailaddress3" };
foreach (var field in emailFields)
{
var theEmail = thisEntity.GetStringField(field);
if (!string.IsNullOrWhiteSpace(theEmail))
{
thisEntity.SetField(field, theEmail.Replace("@", "_AT_") + "*****@*****.**");
}
}
}
if (isUpdate)
{
var existingRecord = existingMatchingIds.First();
XrmService.Update(thisEntity, fieldsToSet.Where(f => !XrmEntity.FieldsEqual(existingRecord.GetField(f), thisEntity.GetField(f))));
}
else
{
PopulateRequiredCreateFields(fieldsToRetry, thisEntity, fieldsToSet);
CheckThrowValidForCreate(thisEntity, fieldsToSet);
thisEntity.Id = XrmService.Create(thisEntity, fieldsToSet);
}
if (!isUpdate && thisEntity.GetOptionSetValue("statecode") > 0)
{
XrmService.SetState(thisEntity, thisEntity.GetOptionSetValue("statecode"), thisEntity.GetOptionSetValue("statuscode"));
}
else if (isUpdate && existingMatchingIds.Any())
{
var matchRecord = existingMatchingIds.First();
var thisState = thisEntity.GetOptionSetValue("statecode");
var thisStatus = thisEntity.GetOptionSetValue("statuscode");
var matchState = matchRecord.GetOptionSetValue("statecode");
var matchStatus = matchRecord.GetOptionSetValue("statuscode");
if ((thisState != -1 && thisState != matchState) ||
(thisStatus != -1 && thisState != matchStatus))
{
XrmService.SetState(thisEntity, thisEntity.GetOptionSetValue("statecode"), thisEntity.GetOptionSetValue("statuscode"));
}
}
}
catch (Exception ex)
{
if (fieldsToRetry.ContainsKey(thisEntity))
{
fieldsToRetry.Remove(thisEntity);
}
response.Add(
new DataImportResponseItem(recordType, null, entity.GetStringField(primaryField),
string.Format("Error Importing Record Id={0}", entity.Id),
ex));
}
countRecordsImported++;
controller.UpdateLevel2Progress(countRecordsImported, countRecordsToImport, estimator.GetProgressString(countRecordsImported));
}
}
catch (Exception ex)
{
response.Add(
new DataImportResponseItem(recordType, null, null, string.Format("Error Importing Type {0}", recordType), ex));
}
}
controller.TurnOffLevel2();
countToImport = fieldsToRetry.Count;
countImported = 0;
controller.UpdateProgress(countImported, countToImport, "Retrying Unresolved Fields");
estimator = new TaskEstimator(countToImport);
foreach (var item in fieldsToRetry)
{
var thisEntity = item.Key;
controller.UpdateProgress(countImported++, countToImport, string.Format("Retrying Unresolved Fields {0}", thisEntity.LogicalName));
var thisPrimaryField = XrmService.GetPrimaryNameField(thisEntity.LogicalName);
try
{
foreach (var field in item.Value)
{
if (XrmService.IsLookup(field, thisEntity.LogicalName) && thisEntity.GetField(field) != null)
{
try
{
var targetTypesToTry = GetTargetTypesToTry(thisEntity, field);
var name = thisEntity.GetLookupName(field);
var idNullable = thisEntity.GetLookupGuid(field);
var fieldResolved = false;
foreach (var lookupEntity in targetTypesToTry)
{
var targetPrimaryKey = XrmRecordService.GetPrimaryKey(lookupEntity);
var targetPrimaryField = XrmRecordService.GetPrimaryField(lookupEntity);
var matchRecord = idNullable.HasValue ? XrmService.GetFirst(lookupEntity, targetPrimaryKey,
idNullable.Value) : null;
if (matchRecord != null)
{
thisEntity.SetLookupField(field, matchRecord);
fieldResolved = true;
}
else
{
var matchRecords = name.IsNullOrWhiteSpace() ?
new Entity[0] :
GetMatchingEntities(lookupEntity,
targetPrimaryField,
name);
if (matchRecords.Count() == 1)
{
thisEntity.SetLookupField(field, matchRecords.First());
fieldResolved = true;
}
}
if (!fieldResolved)
{
throw new Exception(string.Format("Could not find matching record for field {0}.{1} {2}", thisEntity.LogicalName, field, name));
}
}
}
catch (Exception ex)
{
if (thisEntity.Contains(field))
{
thisEntity.Attributes.Remove(field);
}
response.Add(
new DataImportResponseItem(thisEntity.LogicalName, field, thisEntity.GetStringField(thisPrimaryField),
string.Format("Error Setting Lookup Field Id={0}", thisEntity.Id), ex));
}
}
}
XrmService.Update(thisEntity, item.Value);
}
catch (Exception ex)
{
response.Add(
new DataImportResponseItem(thisEntity.LogicalName, null, thisEntity.GetStringField(thisPrimaryField),
string.Format("Error Importing Record Id={0}", thisEntity.Id),
ex));
}
countImported++;
controller.UpdateProgress(countImported, countToImport, estimator.GetProgressString(countImported, taskName: $"Retrying Unresolved Fields {thisEntity.LogicalName}"));
}
countToImport = associationTypes.Count();
countImported = 0;
foreach (var relationshipEntityName in associationTypes)
{
var thisEntityName = relationshipEntityName;
controller.UpdateProgress(countImported++, countToImport, $"Associating {thisEntityName} Records");
controller.UpdateLevel2Progress(0, 1, "Loading");
var thisTypeEntities = entities.Where(e => e.LogicalName == thisEntityName).ToList();
var countRecordsToImport = thisTypeEntities.Count;
var countRecordsImported = 0;
estimator = new TaskEstimator(countRecordsToImport);
foreach (var thisEntity in thisTypeEntities)
{
try
{
var relationship = XrmService.GetRelationshipMetadataForEntityName(thisEntityName);
var type1 = relationship.Entity1LogicalName;
var field1 = relationship.Entity1IntersectAttribute;
var type2 = relationship.Entity2LogicalName;
var field2 = relationship.Entity2IntersectAttribute;
//bit of hack
//when importing from csv just set the fields to the string name of the referenced record
//so either string when csv or guid when xml import/export
var value1 = thisEntity.GetField(relationship.Entity1IntersectAttribute);
var id1 = value1 is string
?GetUniqueMatchingEntity(type1, XrmRecordService.GetPrimaryField(type1), (string)value1).Id
: thisEntity.GetGuidField(relationship.Entity1IntersectAttribute);
var value2 = thisEntity.GetField(relationship.Entity2IntersectAttribute);
var id2 = value2 is string
?GetUniqueMatchingEntity(type2, XrmRecordService.GetPrimaryField(type2), (string)value2).Id
: thisEntity.GetGuidField(relationship.Entity2IntersectAttribute);
//add a where field lookup reference then look it up
if (idSwitches.ContainsKey(type1) && idSwitches[type1].ContainsKey(id1))
{
id1 = idSwitches[type1][id1];
}
if (idSwitches.ContainsKey(type2) && idSwitches[type2].ContainsKey(id2))
{
id2 = idSwitches[type2][id2];
}
XrmService.AssociateSafe(relationship.SchemaName, type1, field1, id1, type2, field2, new[] { id2 });
}
catch (Exception ex)
{
response.Add(
new DataImportResponseItem(
string.Format("Error Associating Record Of Type {0} Id {1}", thisEntity.LogicalName,
thisEntity.Id),
ex));
}
countRecordsImported++;
controller.UpdateLevel2Progress(countRecordsImported, countRecordsToImport, estimator.GetProgressString(countRecordsImported));
}
}
return(response);
}
public override void ExecuteExtention(BulkWorkflowRequest request, BulkWorkflowResponse response,
ServiceRequestController controller)
{
var countToUpdate = request.RecordCount;
var countUpdated = 0;
controller.UpdateProgress(0, countToUpdate, "Executing Workflows");
var estimator = new TaskEstimator(countToUpdate);
var recordsRemaining = request.GetRecordsToUpdate().ToList();
while (recordsRemaining.Any())
{
controller.UpdateProgress(countUpdated, countToUpdate, estimator.GetProgressString(countUpdated, taskName: "Executing Updates"));
var thisSetOfRecords = recordsRemaining
.Take(request.ExecuteMultipleSetSize ?? 50)
.ToList();
recordsRemaining.RemoveRange(0, thisSetOfRecords.Count);
var errorsThisIteration = 0;
//old versions dont have execute multiple so if 1 then do each request
if (thisSetOfRecords.Count() == 1)
{
var record = thisSetOfRecords.First();
try
{
RecordService.XrmService.Execute(new ExecuteWorkflowRequest
{
EntityId = new Guid(record.Id),
WorkflowId = new Guid(request.Workflow.Id)
});
}
catch (Exception ex)
{
response.AddResponseItem(new BulkWorkflowResponseItem(record.Id, record.GetStringField(RecordService.GetPrimaryField(record.Type)), ex));
errorsThisIteration++;
}
}
else
{
var requests = thisSetOfRecords.Select(r => new ExecuteWorkflowRequest
{
EntityId = new Guid(r.Id),
WorkflowId = new Guid(request.Workflow.Id)
});
var multipleResponse = RecordService.XrmService.ExecuteMultiple(requests);
var key = 0;
foreach (var item in multipleResponse)
{
var originalRecord = thisSetOfRecords[key];
if (item.Fault != null)
{
response.AddResponseItem(new BulkWorkflowResponseItem(originalRecord.Id, originalRecord.GetStringField(RecordService.GetPrimaryField(originalRecord.Type)), new FaultException <OrganizationServiceFault>(item.Fault, item.Fault.Message)));
errorsThisIteration++;
}
key++;
}
}
countUpdated += thisSetOfRecords.Count();
response.NumberOfErrors += errorsThisIteration;
response.TotalRecordsProcessed = countUpdated;
Thread.Sleep(request.WaitPerMessage * 1000);
}
controller.UpdateProgress(1, 1, "All Workflows Requests Have Completed");
response.Message = "Workflows Requests Completed";
}
public override void ExecuteExtention(BulkCopyFieldValueRequest request, BulkCopyFieldValueResponse response,
ServiceRequestController controller)
{
var countToUpdate = request.RecordCount;
var countUpdated = 0;
controller.UpdateProgress(0, countToUpdate, "Executing Updates");
var estimator = new TaskEstimator(countToUpdate);
var recordsRemaining = request.GetRecordsToUpdate().ToList();
while (recordsRemaining.Any())
{
controller.UpdateProgress(countUpdated, countToUpdate, estimator.GetProgressString(countUpdated, taskName: "Executing Updates"));
var thisSetOfRecords = recordsRemaining
.Take(request.ExecuteMultipleSetSize ?? 50)
.ToList();
recordsRemaining.RemoveRange(0, thisSetOfRecords.Count);
var thisSetOfRecordsNew = RecordService.GetMultiple(thisSetOfRecords.First().Type,
thisSetOfRecords.Select(r => r.Id),
new[] { request.SourceField.Key, request.TargetField.Key })
.ToArray();
var recordsToUpdate = new List <IRecord>();
foreach (var record in thisSetOfRecordsNew)
{
try
{
var sourceValue = record.GetField(request.SourceField.Key);
var targetValue = record.GetField(request.TargetField.Key);
var parseSourceintoTarget = RecordService.ParseField(request.SourceField.Key, record.Type, sourceValue);
if (!record.FieldsEqual(request.TargetField.Key, parseSourceintoTarget))
{
if ((request.CopyIfNull || sourceValue != null) &&
(request.OverwriteIfPopulated || targetValue == null))
{
record.SetField(request.TargetField.Key, parseSourceintoTarget, RecordService);
recordsToUpdate.Add(record);
}
}
}
catch (Exception ex)
{
response.AddResponseItem(new BulkCopyFieldValueResponseItem(record.Id, record.GetStringField(RecordService.GetPrimaryField(record.Type)), ex));
}
}
var errorsThisIteration = 0;
//old versions dont have execute multiple so if 1 then do each request
if (recordsToUpdate.Count() == 1)
{
var record = recordsToUpdate.First();
try
{
RecordService.Update(record, new[] { request.TargetField.Key });
}
catch (Exception ex)
{
response.AddResponseItem(new BulkCopyFieldValueResponseItem(record.Id, record.GetStringField(RecordService.GetPrimaryField(record.Type)), ex));
}
}
else
{
var multipleResponse = RecordService.UpdateMultiple(recordsToUpdate, new[] { request.TargetField.Key });
foreach (var item in multipleResponse)
{
var originalRecord = recordsToUpdate[item.Key];
response.AddResponseItem(new BulkCopyFieldValueResponseItem(originalRecord.Id, originalRecord.GetStringField(RecordService.GetPrimaryField(originalRecord.Type)), item.Value));
}
errorsThisIteration += multipleResponse.Count;
}
countUpdated += thisSetOfRecords.Count();
response.TotalRecordsProcessed = countUpdated;
response.TotalRecordsUpdated += recordsToUpdate.Count();
response.NumberOfErrors += errorsThisIteration;
}
controller.UpdateProgress(1, 1, "Copies Completed");
response.Message = "Copies Completed";
}