/// <summary>
/// Execute Multiple and return fail count.
/// </summary>
/// <param name="requestCollection">Request Collection</param>
/// <param name="service">Organization Service</param>
/// <param name="continueOnError">Continue on Error</param>
/// <returns>Failed Record Count</returns>
private static int ProcessExecuteMultipleAndReturnFailCount(OrganizationRequestCollection requestCollection, IOrganizationService service, bool continueOnError)
{
if (service != null)
{
int failCount = 0;
var requestWithResults = new ExecuteMultipleRequest()
{
Settings = new ExecuteMultipleSettings()
{
ContinueOnError = continueOnError,
ReturnResponses = true
},
Requests = new OrganizationRequestCollection()
};
requestWithResults.Requests.AddRange(requestCollection);
ExecuteMultipleResponse responseWithResults =
(ExecuteMultipleResponse)service.Execute(requestWithResults);
// Display the results returned in the responses.
foreach (var responseItem in responseWithResults.Responses)
{
// An error has occurred.
if (responseItem.Fault != null)
{
failCount++;
}
}
return(failCount);
}
return(-1);
}
public static void BulkCreate(IOrganizationService service, EntityCollection collection)
{
try
{
////create the request
var bulkCreate = new ExecuteMultipleRequest()
{
Settings = new ExecuteMultipleSettings()
{
////want to see the errors but don't need the response
ContinueOnError = false,
ReturnResponses = false
},
Requests = new OrganizationRequestCollection()
};
////loop through the collection
foreach (var entity in collection.Entities)
{
CreateRequest singleRequest = new CreateRequest {
Target = entity
};
bulkCreate.Requests.Add(singleRequest);
}
////trace.Trace("before execute multiple response");
//// send all at once
ExecuteMultipleResponse multipleResponse = (ExecuteMultipleResponse)service.Execute(bulkCreate);
////trace.Trace("before execute multiple response");
}
catch (Exception ex)
{
throw new CustomServiceManagementPortalException("Failed in Bulk Creation :", ex.InnerException);
}
}
public void Setup()
{
InitializeProperties();
var contact = new Entity(entityName);
contact.Attributes.Add("contactid", Guid.NewGuid());
var account = new Entity("account");
account.Attributes.Add("accountid", Guid.NewGuid());
entities = new List <EntityWrapper>
{
new EntityWrapper(contact),
new EntityWrapper(account)
};
requestResult = new ExecuteMultipleResponse();
testOrgService = new TestOrganizationalService();
testOrgService.EntityCollection.Entities.AddRange(new Entity[] { contact, account });
MockEntityMetadataCache = new Mock <IEntityMetadataCache>();
systemUnderTest = new EntityRepository(testOrgService, MockRetryExecutor.Object, MockEntityMetadataCache.Object);
}
/// <summary>
/// Execute the entire batch
/// </summary>
/// <param name="service"></param>
public void Execute(IOrganizationService service)
{
ExecuteMultipleRequest batch = new ExecuteMultipleRequest()
{
Settings = new ExecuteMultipleSettings()
{
ReturnResponses = true,
ContinueOnError = false,
},
Requests = new OrganizationRequestCollection(),
};
int numberOfBatches = 0;
for (var i = 0; i < Requests.Count; i++)
{
batch.Requests.Add(Requests[i].Request);
// If the batch size has been met or this is the last request execute the batch
if ((i + 1) % batchSize == 0 || i == Requests.Count - 1)
{
ExecuteMultipleResponse response = (ExecuteMultipleResponse)service.Execute(batch);
for (var ii = 0; ii < response.Responses.Count; ii++)
{
if (Requests[numberOfBatches * this.batchSize + ii].CallBack != null)
{
Requests[numberOfBatches * this.batchSize + ii].CallBack(response.Responses[ii].Response);
}
}
batch.Requests.Clear();
numberOfBatches++;
}
}
}
/// <summary>
/// Logs the errors from a <see cref="ExecuteMultipleResponse"/>.
/// </summary>
/// <param name="logger">The logger.</param>
/// <param name="executeMultipleResponse">The response to log errors from.</param>
public static void LogExecuteMultipleErrors(this ILogger logger, ExecuteMultipleResponse executeMultipleResponse)
{
foreach (var response in executeMultipleResponse.Responses.Where(r => r.Fault != null).Select(r => r.Fault))
{
logger.LogError(response.Message);
}
}
public void MultiUpdate(List <T> entityList)
{
ExecuteMultipleRequest request = new ExecuteMultipleRequest()
{
Requests = new OrganizationRequestCollection(),
Settings = new ExecuteMultipleSettings()
{
ContinueOnError = true,
ReturnResponses = true
}
};
foreach (var entity in entityList)
{
UpdateRequest updateRequest = new UpdateRequest {
Target = entity.ToEntity <Entity>()
};
request.Requests.Add(updateRequest);
}
try
{
ExecuteMultipleResponse response = (ExecuteMultipleResponse)_service.Execute(request);
}
catch (Exception ex)
{ }
}
private void RunEMR(OrganizationRequest or, BackgroundWorker w)
{
//string message = "";
requestWithResults.Requests.Add(or);
emrCount++;
if (requestWithResults.Requests.Count >= emrBatchSize)
{
DateTime start = DateTime.Now;
//w.ReportProgress(0, string.Format("Starting Workflows: {0} of {1}{2}Est. Time Remaining: {3}", emrCount.ToString("#,#", CultureInfo.InvariantCulture)
//, ExecutionRecordSet.Entities.Count.ToString("#,#", CultureInfo.InvariantCulture), Environment.NewLine, estTS.ToString("hh\\:mm\\:ss")));
//message = string.Format("Deleting Records: {0} of {1}{2}Est. Time Remaining: {3}", emrCount.ToString("#,#", CultureInfo.InvariantCulture)
// , ExecutionRecordSet.Entities.Count.ToString("#,#", CultureInfo.InvariantCulture), Environment.NewLine, estTS.ToString("hh\\:mm\\:ss"));
ExecuteMultipleResponse emrsp = (ExecuteMultipleResponse)Service.Execute(requestWithResults);
HandleErrors(emrsp);
requestWithResults.Requests.Clear();
DateTime end = DateTime.Now;
TimeSpan ts = end - start;
_listTS.Add(ts);
double doubleAverageTicks = _listTS.Average(timeSpan => timeSpan.Ticks);
long longAverageTicks = Convert.ToInt64(doubleAverageTicks);
avgTS = new TimeSpan(longAverageTicks);
estTS = new TimeSpan(((ExecutionRecordSet.Entities.Count - emrCount) / emrBatchSize) * avgTS.Ticks);
w.ReportProgress(0, GetDeleteStatusMessage(ExecutionRecordSet.Entities[0].LogicalName, emrCount, ExecutionRecordSet.Entities.Count, estTS));
double progValue = (((double)emrCount / (double)ExecutionRecordSet.Entities.Count) * 100);
//SendMessageToStatusBar?.Invoke(this, new StatusBarMessageEventArgs(Convert.ToInt32(Math.Round(progValue)), $"{emrCount.ToString("#,#", CultureInfo.InvariantCulture)} / {ExecutionRecordSet.Entities.Count.ToString("#,#", CultureInfo.InvariantCulture)}"));
SendMessageToStatusBar?.Invoke(this, new StatusBarMessageEventArgs(Convert.ToInt32(Math.Round(progValue)), null));
}
//return message;
}
public BulkResponse Write(IOrganizationService service, Dictionary <string, OrganizationRequest> requestsToBeProcessed)
{
BulkResponse bulkWriteResponse = new BulkResponse();
bulkWriteResponse.Responses = new List <BulkResponseItem>();
int batchNumber = 0;
int recordsToProcessCount = requestsToBeProcessed.Count;
while (recordsToProcessCount > _batchSize || recordsToProcessCount > 0)
{
Dictionary <string, OrganizationRequest> currentBatchOfRequests = requestsToBeProcessed.Skip(batchNumber * _batchSize).Take(_batchSize).ToDictionary(x => x.Key, x => x.Value);
OrganizationRequestCollection orgReqs = new OrganizationRequestCollection();
orgReqs.AddRange(currentBatchOfRequests.Values.ToList());
ExecuteMultipleResponse response = ExecuteMultiple(service, orgReqs);
List <BulkResponseItem> bulkResponses = ReadExecuteMultipleResponse(response, currentBatchOfRequests);
bulkWriteResponse.Responses.AddRange(bulkResponses);
bulkWriteResponse.HasErrors = response.IsFaulted;
recordsToProcessCount = recordsToProcessCount - currentBatchOfRequests.Count;
batchNumber++;
}
return(bulkWriteResponse);
}
public virtual OrganizationResponse UseExecuteMultipleRequest(ExecuteMultipleRequest executeMultipleRequest)
{
var collection = new ExecuteMultipleResponseItemCollection();
var i = 0;
foreach (var requestItem in executeMultipleRequest.Requests)
{
if (requestItem is CreateRequest createRequest)
{
var sb = new StringBuilder();
sb.AppendLine("Create entity");
createRequest.Target.Id = Guid.Empty;
sb.AppendLine(createRequest.Target.ToPlainText());
System.Diagnostics.Trace.Write(sb.ToString());
var createResponse = new CreateResponse {
["Id"] = Guid.Empty
};
collection.Add(new ExecuteMultipleResponseItem
{
RequestIndex = i++,
Response = createResponse,
Fault = null
});
continue;
}
throw new NotImplementedException(requestItem.GetType().ToString());
}
var response = new ExecuteMultipleResponse {
Results = { ["Responses"] = collection }
};
return(response);
}
private void HandleCreateWithRetreiveResponse(ExecuteMultipleResponse executeMultipleResponse, EntityResultSet resultSet)
{
if (executeMultipleResponse != null)
{
// for execute reader and execute scalar purposes, we provide a result that has the newly created id of the entity.
// var execMultipleRequest = (ExecuteMultipleRequest)executeMultipleRequest;
int createOperationBatchPosition = 0;
if (executeMultipleResponse.IsFaulted)
{
var fault = executeMultipleResponse.Responses.Where(r => r.Fault != null).FirstOrDefault();
// var errorText = from f in faults select f.Fault.InnerFault.Message;
FaultReason reason = new FaultReason(fault.Fault.Message);
throw new FaultException <OrganizationServiceFault>(fault.Fault, reason);
}
var batchRequest = BatchRequest;
if (batchRequest == null)
{
throw new InvalidOperationException("BatchRequest should not be null when executing a request with an output clause.");
}
var request = (CreateRequest)batchRequest.Requests[createOperationBatchPosition];
int retrieveOperationBatchPosition = createOperationBatchPosition + 1;
var retrieveResponse = (RetrieveResponse)executeMultipleResponse.Responses[retrieveOperationBatchPosition].Response;
var result = retrieveResponse.Entity;
resultSet.Results = new EntityCollection(new List <Entity>(new Entity[] { result }));
}
}
public static void executeMultipleSetSate(EntityCollection entities, IOrganizationService service)
{
ExecuteMultipleRequest multipleRequest = new ExecuteMultipleRequest()
{
Settings = new ExecuteMultipleSettings()
{
ContinueOnError = true,
ReturnResponses = true
},
Requests = new OrganizationRequestCollection()
};
foreach (Entity e in entities.Entities)
{
SetStateRequest setStateReq = new SetStateRequest();
setStateReq.EntityMoniker = new EntityReference(e.LogicalName, e.Id);
setStateReq.State = (OptionSetValue)e["statecode"];
setStateReq.Status = (OptionSetValue)e["statuscode"];
multipleRequest.Requests.Add(setStateReq);
}
//This is how to get responses
ExecuteMultipleResponse executeResponse = (ExecuteMultipleResponse)service.Execute(multipleRequest);
if (executeResponse.Results != null)
{
//Loop through responses
foreach (ExecuteMultipleResponseItem responseItem in executeResponse.Responses)
{
if (responseItem.Response != null)
{
//Awesome, command completed as expected
//success++;
}
else if (responseItem.Fault != null)
{
OrganizationRequest req = multipleRequest.Requests[responseItem.RequestIndex];
if (req.Parameters.Contains("Target"))
{
Entity entity = (Entity)req.Parameters["Target"];
GeneralHelper.WriteToText(entity.Id + ";SETSATE-" + responseItem.Fault.Message, @"C:\sahibinden\migration_" + entity.LogicalName + "_" + DateTime.Now.ToShortDateString() + ".txt");
}
else
{
GeneralHelper.WriteToText(Guid.Empty + ";SETSATE-" + responseItem.Fault.Message, @"C:\sahibinden\migration_" + "noentity" + "_" + DateTime.Now.ToShortDateString() + ".txt");
}
//Uh oh, error
//error++;
}
else
{
//Error reporting error;
}
}
}
}
public static ExecuteMultipleResponse SaveMultipleRecords(CdsServiceClient service, List <Entity> records)
{
ExecuteMultipleRequest executeMultipleRequest = new ExecuteMultipleRequest()
{
Settings = new ExecuteMultipleSettings()
{
ContinueOnError = true,
ReturnResponses = true
},
Requests = new OrganizationRequestCollection()
};
foreach (Entity record in records)
{
CreateRequest createRequest = new CreateRequest {
Target = record
};
executeMultipleRequest.Requests.Add(createRequest);
}
ExecuteMultipleResponse responseWithResults =
(ExecuteMultipleResponse)service.Execute(executeMultipleRequest);
return(responseWithResults);
}
/// <summary>
/// Bulk update entity records
/// </summary>
/// <param name="updatedPayments"></param>
/// <returns></returns>
public static ExecuteMultipleResponse BatchUpdateRecords(IOrganizationService service, List <Entity> entityList)
{
// Create an ExecuteMultipleRequest object.
ExecuteMultipleRequest requestWithResults = new ExecuteMultipleRequest()
{
// Assign settings that define execution behavior: continue on error, return responses.
Settings = new ExecuteMultipleSettings()
{
ContinueOnError = false,
ReturnResponses = true
},
// Create an empty organization request collection.
Requests = new OrganizationRequestCollection()
};
// Create several (local, in memory) entities in a collection.
EntityCollection input = new EntityCollection(entityList);
// Add a CreateRequest for each entity to the request collection.
foreach (var entity in input.Entities)
{
UpdateRequest updateRequest = new UpdateRequest {
Target = entity
};
requestWithResults.Requests.Add(updateRequest);
}
// Execute all the requests in the request collection using a single web method call.
ExecuteMultipleResponse responseWithResults = (ExecuteMultipleResponse)service.Execute(requestWithResults);
return(responseWithResults);
}
private void RunEMR(OrganizationRequest or, BackgroundWorker sender)
{
requestWithResults.Requests.Add(or);
emrCount++;
if (requestWithResults.Requests.Count >= emrBatchSize)
{
//emrCount += requestWithResults.Requests.Count;
//writeit("Executing Multiple Workflows: " + requestWithResults.Requests.Count);
((BackgroundWorker)sender).ReportProgress(0, string.Format("Executing Workflows.. {0} of {1}", emrCount, ExecutionRecordSet.Entities.Count));
this.Invoke((MethodInvoker) delegate()
{
progressBar1.Maximum = ExecutionRecordSet.Entities.Count;
progressBar1.Value = emrCount;
});
ExecuteMultipleResponse emrsp = (ExecuteMultipleResponse)service.Execute(requestWithResults);
HandleErrors(emrsp);
//writeit("Total Workflows Started: " + (emrCount - errorCount) + " / " + ExecutionRecordSet.Entities.Count);
requestWithResults.Requests.Clear();
if (txtDelay.Text != "0")
{
System.Threading.Thread.Sleep(Convert.ToInt16(txtDelay.Text) * 1000);
}
}
}
private void FlushEMR(BackgroundWorker w)
{
if (emrCount > 0)
{
//w.ReportProgress(0, string.Format("Deleting Records: {0} / {1}{2}Est. Time Remaining: {3}", emrCount.ToString("#,#", CultureInfo.InvariantCulture)
//, ExecutionRecordSet.Entities.Count.ToString("#,#", CultureInfo.InvariantCulture), Environment.NewLine, estTS.ToString("hh\\:mm\\:ss")));
w.ReportProgress(0, GetDeleteStatusMessage(ExecutionRecordSet.Entities[0].LogicalName, emrCount, ExecutionRecordSet.Entities.Count, estTS));
double progValue = (((double)emrCount / (double)ExecutionRecordSet.Entities.Count) * 100);
//SetWorkingMessage(string.Format("Starting Workflows: {0} of {1}{2}Est. Time Remaining: {3}", emrCount.ToString("#,#", CultureInfo.InvariantCulture)
// , ExecutionRecordSet.Entities.Count.ToString("#,#", CultureInfo.InvariantCulture), Environment.NewLine, estTS.ToString("hh\\:mm\\:ss")));
ExecuteMultipleResponse emrsp = (ExecuteMultipleResponse)Service.Execute(requestWithResults);
HandleErrors(emrsp);
requestWithResults.Requests.Clear();
//tsbCancel.Enabled = false;
//MessageBox.Show("Finished @ " + DateTime.Now.ToShortTimeString() + Environment.NewLine + Environment.NewLine
// + string.Format("Records Deleted: {0} of {1}", emrCount.ToString("#,#", CultureInfo.InvariantCulture), ExecutionRecordSet.Entities.Count.ToString("#,#", CultureInfo.InvariantCulture))
// + Environment.NewLine + "Errors: " + errorCount
// , "Bulk Delete Tool");
return;
}
else
{
//MessageBox.Show("No records found in this view to process", "Bulk Workflow Execution");
return;
}
}
internal override OrganizationResponse Execute(OrganizationRequest orgRequest, EntityReference userRef)
{
var request = MakeRequest <ExecuteMultipleRequest>(orgRequest);
var toReturn = new ExecuteMultipleResponse();
var responses = new ExecuteMultipleResponseItemCollection();
for (var i = 0; i < request.Requests.Count; i++)
{
var resp = new ExecuteMultipleResponseItem {
RequestIndex = i
};
var r = request.Requests[i];
try {
var orgResp = core.Execute(r, userRef);
if (request.Settings.ReturnResponses)
{
resp.Response = orgResp;
responses.Add(resp);
}
} catch (Exception e) {
resp.Fault = new OrganizationServiceFault {
Message = e.Message,
Timestamp = DateTime.Now
};
responses.Add(resp);
if (!request.Settings.ContinueOnError)
{
toReturn.Results["Responses"] = responses;
return(toReturn);
}
}
}
toReturn.Results["Responses"] = responses;
return(toReturn);
}
private void deleteQuoteProducts(IOrganizationService service, Guid quoteId)
{
// Get All Quote Products
QueryExpression query = new QueryExpression(CONSTANT.QUOTE_PRODUCT_ENTITY);
query.Criteria.AddCondition(CONSTANT.QUOTE_ID_FIELD, ConditionOperator.Equal, quoteId);
EntityCollection quoteProductList = service.RetrieveMultiple(query);
if (quoteProductList.Entities.Count > 0)
{
// Create Execute Multiple Request
var multipleRequest = new ExecuteMultipleRequest()
{
// Assign settings that define execution behavior: continue on error, return responses.
Settings = new ExecuteMultipleSettings()
{
ContinueOnError = false,
ReturnResponses = true
},
// Create an empty organization request collection.
Requests = new OrganizationRequestCollection()
};
foreach (Entity item in quoteProductList.Entities)
{
DeleteRequest deleteRequest = new DeleteRequest {
Target = item.ToEntityReference()
};
multipleRequest.Requests.Add(deleteRequest);
}
ExecuteMultipleResponse multipleResponse = (ExecuteMultipleResponse)service.Execute(multipleRequest);
}
}
public void cleanupContacts()
{
DateTime DateFilter = DateTime.Now.AddDays(-1);
QueryExpression query = new QueryExpression("account");
IOrganizationService service = CRMHelper.ConnectToMSCRM1();
Console.WriteLine("IOrganization Service Object Created");
EntityCollection EntityList = CRMHelper.RetrieveMultiple(query, service);
ExecuteMultipleRequest mulitRequest = null;
int offset = 1;
Console.WriteLine("Total Record to be Deleted are : " + EntityList.Entities.Count);
mulitRequest = getNewObject();
for (int count = 0; count < EntityList.Entities.Count; count++)
{
if (offset % 200 == 0)
{
// Execute all the requests in the request collection using a single web method call.
ExecuteMultipleResponse multipleResponse = (ExecuteMultipleResponse)service.Execute(mulitRequest);
Console.WriteLine("Bunch of 200 Record Deleted & Total record Proceed are : " + count);
mulitRequest = getNewObject();
}
Entity Item = EntityList.Entities[count];
DeleteRequest deleteRequest = new DeleteRequest {
Target = Item.ToEntityReference()
};
mulitRequest.Requests.Add(deleteRequest);
offset = count + 1;
}
}
public void ConnectConnectionReferences_WithErrorUpdating_Continues()
{
var connectionMap = new Dictionary <string, string>
{
{ "pdt_sharedapprovals_d7dcb", "12038109da0wud01" },
};
this.MockConnectionReferencesForConnectionMap(connectionMap);
var response = new ExecuteMultipleResponse
{
Results =
{
{
"IsFaulted",
true
},
{
"Responses",
new ExecuteMultipleResponseItemCollection()
{
new ExecuteMultipleResponseItem
{
Fault = new OrganizationServiceFault(),
},
}
},
},
};
this.MockUpdateConnectionReferencesResponse(response);
this.connectionReferenceSvc.ConnectConnectionReferences(connectionMap);
this.loggerMock.VerifyLog(l => l.LogError(It.IsAny <string>()));
}
/// <summary>
/// Call this method for bulk delete
/// </summary>
/// <param name="service">Org Service</param>
/// <param name="entityReferences">Collection of EntityReferences to Delete</param>
public static void BulkDelete(IOrganizationService service, DataCollection <EntityReference> entityReferences)
{
// Create an ExecuteMultipleRequest object.
var multipleRequest = new ExecuteMultipleRequest()
{
// Assign settings that define execution behavior: continue on error, return responses.
Settings = new ExecuteMultipleSettings()
{
ContinueOnError = false,
ReturnResponses = true
},
// Create an empty organization request collection.
Requests = new OrganizationRequestCollection()
};
// Add a DeleteRequest for each entity to the request collection.
foreach (var entityRef in entityReferences)
{
DeleteRequest deleteRequest = new DeleteRequest {
Target = entityRef
};
multipleRequest.Requests.Add(deleteRequest);
}
// Execute all the requests in the request collection using a single web method call.
ExecuteMultipleResponse multipleResponse = (ExecuteMultipleResponse)service.Execute(multipleRequest);
}
private void FlushEMR(BackgroundWorker sender)
{
if (emrCount > 0)
{
//emrCount += requestWithResults.Requests.Count;
//writeit("Executing Multiple Workflows: " + requestWithResults.Requests.Count);
ExecuteMultipleResponse emrsp = (ExecuteMultipleResponse)service.Execute(requestWithResults);
HandleErrors(emrsp);
requestWithResults.Requests.Clear();
//if (errorCount > 0)
//{
// writeit("Total Errors: " + errorCount);
//}
this.Invoke((MethodInvoker) delegate()
{
progressBar1.Maximum = ExecutionRecordSet.Entities.Count;
progressBar1.Value = emrCount;
});
((BackgroundWorker)sender).ReportProgress(0, string.Format("Executing Workflows.. {0] / {1}", emrCount, ExecutionRecordSet.Entities.Count));
//writeit("Total Errors: " + errorCount);
return;
}
else
{
MessageBox.Show("No records found in this view to process");
return;
}
}
protected static void AtualizaCrmOrigem(EntityCollection colecaoEntidades)
{
ExecuteMultipleRequest request = new ExecuteMultipleRequest()
{
Requests = new OrganizationRequestCollection(),
Settings = new ExecuteMultipleSettings
{
ContinueOnError = false, ReturnResponses = true
}
};
foreach (var entidade in colecaoEntidades.Entities)
{
UpdateRequest updateRequest = new UpdateRequest {
Target = entidade
};
request.Requests.Add(updateRequest);
}
ExecuteMultipleResponse resposta = (ExecuteMultipleResponse)serviceProxyOrigem.Execute(request);
int cont = 0;
foreach (var item in resposta.Responses)
{
if (item.Fault != null)
{
Console.WriteLine($"ERRO na entidade nº: {cont}!\n{item.Fault}");
}
cont++;
}
Console.WriteLine($"{cont} entidades atualizadas na origem!");
}
public static bool UpdateAndPublishMultiple(CrmServiceClient client, List <Entity> webResources)
{
//CRM 2011 UR12+
try
{
ExecuteMultipleRequest emRequest = new ExecuteMultipleRequest
{
Requests = new OrganizationRequestCollection(),
Settings = new ExecuteMultipleSettings
{
ContinueOnError = false,
ReturnResponses = true
}
};
emRequest.Requests = CreateUpdateRequests(webResources);
string publishXml = CreatePublishXml(webResources);
emRequest.Requests.Add(CreatePublishRequest(publishXml));
bool wasError = false;
ExecuteMultipleResponse emResponse = (ExecuteMultipleResponse)client.Execute(emRequest);
foreach (var responseItem in emResponse.Responses)
{
if (responseItem.Fault == null)
{
continue;
}
OutputLogger.WriteToOutputWindow(
"Error Updating And Publishing Web Resource(s) To CRM: " + responseItem.Fault.Message +
Environment.NewLine + responseItem.Fault.TraceText, MessageType.Error);
wasError = true;
}
if (wasError)
{
return(false);
}
OutputLogger.WriteToOutputWindow("Updated And Published Web Resource(s)", MessageType.Info);
return(true);
}
catch (FaultException <OrganizationServiceFault> crmEx)
{
OutputLogger.WriteToOutputWindow("Error Updating And Publishing Web Resource(s) To CRM: " +
crmEx.Message + Environment.NewLine + crmEx.StackTrace, MessageType.Error);
return(false);
}
catch (Exception ex)
{
OutputLogger.WriteToOutputWindow("Error Updating And Publishing Web Resource(s) To CRM: " +
ex.Message + Environment.NewLine + ex.StackTrace, MessageType.Error);
return(false);
}
}
/// <summary>
/// Deletes any entity records that were created for this sample.
/// <param name="prompt">Indicates whether to prompt the user
/// to delete the records created in this sample.</param>
/// </summary>
public void DeleteRequiredRecords(bool prompt)
{
bool deleteRecords = true;
if (prompt)
{
Console.WriteLine("\nDo you want to delete the account record? (y/n) [y]: ");
String answer = Console.ReadLine();
deleteRecords = (answer.StartsWith("y") || answer.StartsWith("Y") || answer == String.Empty);
}
if (!deleteRecords)
{
return;
}
ExecuteMultipleRequest requestWithNoResults = new ExecuteMultipleRequest()
{
// Set the execution behavior to continue and to not return responses.
Settings = new ExecuteMultipleSettings()
{
ContinueOnError = true,
ReturnResponses = false
},
Requests = new OrganizationRequestCollection()
};
// Get all the entities into a collection to delete
EntityCollection delete = GetCollectionOfEntitiesToDelete();
foreach (var entity in delete.Entities)
{
DeleteRequest deleteRequest = new DeleteRequest {
Target = entity.ToEntityReference()
};
requestWithNoResults.Requests.Add(deleteRequest);
}
ExecuteMultipleResponse responseWithNoResults =
(ExecuteMultipleResponse)_serviceProxy.Execute(requestWithNoResults);
// There should be no responses unless there was an error.
if (responseWithNoResults.Responses.Count > 0)
{
foreach (var responseItem in responseWithNoResults.Responses)
{
if (responseItem.Fault != null)
{
DisplayFault(requestWithNoResults.Requests[responseItem.RequestIndex],
responseItem.RequestIndex, responseItem.Fault);
}
}
}
else
{
Console.WriteLine("All account records have been deleted successfully.");
}
}
private void ThrowExecuteMultipleFirstError(ExecuteMultipleResponse responses)
{
if (responses.Responses.Any(x => x.Fault != null))
{
var firstError = responses.Responses.Where(x => x.Fault != null).FirstOrDefault().Fault.Message;
throw new InvalidPluginExecutionException(firstError);
}
}
/// <summary>
/// Updates connection references to used the provided connection names.
/// </summary>
/// <param name="connectionMap">Connection name by connection reference ID.</param>
/// <param name="connectionOwner">The username of the connection owner. If not provided, the authenticated user must be the owner of the connections.</param>
public void ConnectConnectionReferences(IDictionary <string, string> connectionMap, string connectionOwner = null)
{
if (connectionMap is null || !connectionMap.Any())
{
this.logger.LogInformation("No connections have been configured.");
return;
}
var updateRequests = this
.GetConnectionReferences(connectionMap.Keys.ToArray())
.Select(e => new UpdateRequest
{
Target = new Entity(Constants.ConnectionReference.LogicalName)
{
Id = e.Id,
Attributes =
{
{
Constants.ConnectionReference.Fields.ConnectionReferenceId,
e.Id
},
{
Constants.ConnectionReference.Fields.ConnectionId,
connectionMap[e.GetAttributeValue <string>(Constants.ConnectionReference.Fields.ConnectionReferenceLogicalName).ToLower()]
},
},
},
}).ToList();
var executeMultipleRequest = new ExecuteMultipleRequest()
{
Requests = new OrganizationRequestCollection(),
Settings = new ExecuteMultipleSettings {
ContinueOnError = true, ReturnResponses = true
},
};
executeMultipleRequest.Requests.AddRange(updateRequests);
ExecuteMultipleResponse response = null;
if (!string.IsNullOrEmpty(connectionOwner))
{
this.logger.LogInformation($"Impersonating {connectionOwner} as owner of connections.");
response = this.crmSvc.Execute <ExecuteMultipleResponse>(executeMultipleRequest, connectionOwner, fallbackToExistingUser: true);
}
else
{
response = (ExecuteMultipleResponse)this.crmSvc.Execute(executeMultipleRequest);
}
if (response.IsFaulted)
{
this.logger.LogExecuteMultipleErrors(response);
}
}
public static List <Guid> DeletePluginTracesFromCrm(CrmServiceClient client, Guid[] pluginTraceLogIds)
{
List <Guid> deletedPluginTraceLogIds = new List <Guid>();
try
{
ExecuteMultipleRequest executeMultipleRequest = new ExecuteMultipleRequest
{
Requests = new OrganizationRequestCollection(),
Settings = new ExecuteMultipleSettings
{
ContinueOnError = true,
ReturnResponses = true
}
};
foreach (Guid pluginTraceLogId in pluginTraceLogIds)
{
DeleteRequest request = new DeleteRequest
{
Target = new EntityReference("plugintracelog", pluginTraceLogId)
};
executeMultipleRequest.Requests.Add(request);
}
ExecuteMultipleResponse executeMultipleResponse =
(ExecuteMultipleResponse)client.Execute(executeMultipleRequest);
foreach (var responseItem in executeMultipleResponse.Responses)
{
if (responseItem.Response != null)
{
deletedPluginTraceLogIds.Add(pluginTraceLogIds[responseItem.RequestIndex]);
continue;
}
if (responseItem.Fault != null)
{
OutputLogger.WriteToOutputWindow(
"Error Deleting Plug-in Trace Log From CRM: " + responseItem.Fault, MessageType.Error);
}
}
}
catch (FaultException <OrganizationServiceFault> crmEx)
{
OutputLogger.WriteToOutputWindow(
"Error Deleting Plug-in Trace Log(s) From CRM: " + crmEx.Message + Environment.NewLine + crmEx.StackTrace, MessageType.Error);
}
catch (Exception ex)
{
OutputLogger.WriteToOutputWindow(
"Error Deleting Plug-in Trace Log(s) From CRM: " + ex.Message + Environment.NewLine + ex.StackTrace, MessageType.Error);
}
return(deletedPluginTraceLogIds);
}
public void TestExecuteMultipleWithStopOnErrorAndReturn()
{
using (var context = new Xrm(orgAdminUIService))
{
ExecuteMultipleRequest requestWithStopOnErrorAndReturns = new ExecuteMultipleRequest()
{
// Set the execution behavior to continue on an error and not return responses.
Settings = new ExecuteMultipleSettings()
{
ContinueOnError = false,
ReturnResponses = true
},
Requests = new OrganizationRequestCollection()
};
EntityCollection updateWithErrors = new EntityCollection()
{
EntityName = Account.EntityLogicalName,
Entities =
{
new Account {
Name = "Updated Account 1", Id = account1.Id
},
new Account {
Name = "Updated Account 2", Id = new Guid()
},
new Account {
Name = "Updated Account 3", Id = account3.Id
},
new Account {
Name = "Updated Account 4", Id = new Guid()
},
new Account {
Name = "Updated Account 5", Id = account5.Id
},
}
};
foreach (var entity in updateWithErrors.Entities)
{
UpdateRequest updateRequest = new UpdateRequest {
Target = entity
};
requestWithStopOnErrorAndReturns.Requests.Add(updateRequest);
}
ExecuteMultipleResponse responseWithStopOnErrorAndReturns =
(ExecuteMultipleResponse)orgAdminUIService.Execute(requestWithStopOnErrorAndReturns);
Assert.Equal(2, responseWithStopOnErrorAndReturns.Responses.Count);
Assert.Equal(1, responseWithStopOnErrorAndReturns.Responses.Count(
x => x.Response == null && x.Fault != null && x.Fault.Message != null));
Assert.Equal(1, responseWithStopOnErrorAndReturns.Responses.Count(
x => x.Response != null && x.Fault == null));
Assert.True(responseWithStopOnErrorAndReturns.IsFaulted);
}
}
public void UpdateRecordwithBunchRequest(EntityCollection UpdateEntityList, IOrganizationService service, string nameToPrint, int bunchLimit)
{
try
{
List <UpdateRequest> UpdateList = new List <UpdateRequest>();
ExecuteMultipleRequest MultiRequest = null;
List <ExecuteMultipleRequest> MultirequestList = new List <ExecuteMultipleRequest>();
for (int count = 0; count < UpdateEntityList.Entities.Count; count++)
{
Entity Item = UpdateEntityList.Entities[count];
if (MultiRequest == null)
{
MultiRequest = getNewObject();
}
UpdateRequest updateRequest = new UpdateRequest {
Target = Item
};
MultiRequest.Requests.Add(updateRequest);
if ((count + 1) % bunchLimit == 0)
{
MultirequestList.Add(MultiRequest);
MultiRequest = getNewObject();
}
if ((count == UpdateEntityList.Entities.Count - 1) && ((count + 1) % bunchLimit != 0))
{
MultirequestList.Add(MultiRequest);
}
}
Console.WriteLine("Prepare List of " + bunchLimit + " Records Bunch for : " + nameToPrint + " With List Count :" + MultirequestList.Count);
ExecuteMultipleResponse Response = null;
DateTime startTime = DateTime.Now;
Console.WriteLine("Starting Bulk Update Request for " + nameToPrint + " at : " + startTime.ToString());
for (int index = 0; index < MultirequestList.Count; index++)
{
ExecuteMultipleResponse multipleResponse = (ExecuteMultipleResponse)service.Execute(MultirequestList[index]);
if (Response == null)
{
Response = new ExecuteMultipleResponse();
Response = multipleResponse;
}
else
{
Response.Responses.AddRange(multipleResponse.Responses);
}
}
DateTime endTime = DateTime.Now;
double timeDiff = (endTime - startTime).TotalSeconds;
Console.WriteLine("Completed Bulk Update Request for " + nameToPrint + " at : " + endTime.ToString());
Console.WriteLine("Bulk Operation Took Total Seconds : " + timeDiff.ToString());
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Log entry
/// </summary>
/// <param name="logEntry"></param>
/// <param name="type"></param>
/// <param name="service"></param>
/// <returns></returns>
public static string Log(
Log logEntry,
LogType type,
IOrganizationService service)
{
string result = string.Empty;
try
{
OrganizationRequest logRequest = new OrganizationRequest("dyn_Log")
{
Parameters = AssembleLogParams(logEntry, type)
};
//set ExecuteMultipleRequest request to wrap log Exception Request
//this is required to escape the Plugin transaction which if rolled back,
//will delete the log entry record
ExecuteMultipleRequest executeMultipleRequest = new ExecuteMultipleRequest()
{
Requests = new OrganizationRequestCollection(),
Settings = new ExecuteMultipleSettings()
{
ContinueOnError = true,
ReturnResponses = true
}
};
//add request to multiple requests collection
executeMultipleRequest.Requests.Add(logRequest);
//execute ExecuteMultipleRequest
ExecuteMultipleResponse resp = (ExecuteMultipleResponse)service.Execute(executeMultipleRequest);
//parse ExecuteMultipleRequest response
foreach (var responseItem in resp.Responses)
{
//valid response returned
if (responseItem.Response != null)
{
OrganizationResponse response = (OrganizationResponse)responseItem.Response;
result = (string)response["referenceToken"];
}
//error occurred
else if (responseItem.Fault != null)
{
result = responseItem.Fault.Message;
}
}
}
catch (FaultException <OrganizationServiceFault> fault)
{
result = fault.Message;
}
return(result);
}
private void HandleUpdateWithRetreiveResponse(ExecuteMultipleResponse executeMultipleResponse, EntityResultSet resultSet)
{
if (executeMultipleResponse != null)
{
// for execute reader and execute scalar purposes, we provide a result that has the newly created id of the entity.
// var execMultipleRequest = (ExecuteMultipleRequest)executeMultipleRequest;
int updateOperationBatchPosition = 0; // BatchRequestIndex;
var batchRequest = BatchRequest;
if (batchRequest == null)
{
throw new InvalidOperationException("BatchRequest should not be null when executing a request with an output clause.");
}
var request = (UpdateRequest)batchRequest.Requests[updateOperationBatchPosition];
int retrieveOperationBatchPosition = updateOperationBatchPosition + 1;
var retrieveResponse = (RetrieveResponse)executeMultipleResponse.Responses[retrieveOperationBatchPosition].Response;
var result = retrieveResponse.Entity;
resultSet.Results = new EntityCollection(new List<Entity>(new Entity[] { result }));
}
}
private void HandleCreateWithRetreiveResponse(ExecuteMultipleResponse executeMultipleResponse, EntityResultSet resultSet)
{
if (executeMultipleResponse != null)
{
// for execute reader and execute scalar purposes, we provide a result that has the newly created id of the entity.
// var execMultipleRequest = (ExecuteMultipleRequest)executeMultipleRequest;
int createOperationBatchPosition = 0;
if (executeMultipleResponse.IsFaulted)
{
var fault = executeMultipleResponse.Responses.Where(r => r.Fault != null).FirstOrDefault();
// var errorText = from f in faults select f.Fault.InnerFault.Message;
FaultReason reason = new FaultReason(fault.Fault.Message);
throw new FaultException<OrganizationServiceFault>(fault.Fault, reason);
}
var batchRequest = BatchRequest;
if (batchRequest == null)
{
throw new InvalidOperationException("BatchRequest should not be null when executing a request with an output clause.");
}
var request = (CreateRequest)batchRequest.Requests[createOperationBatchPosition];
int retrieveOperationBatchPosition = createOperationBatchPosition + 1;
var retrieveResponse = (RetrieveResponse)executeMultipleResponse.Responses[retrieveOperationBatchPosition].Response;
var result = retrieveResponse.Entity;
resultSet.Results = new EntityCollection(new List<Entity>(new Entity[] { result }));
}
}
public OrganizationResponse Execute(OrganizationRequest request, XrmFakedContext ctx)
{
var executeMultipleRequest = (ExecuteMultipleRequest)request;
if (executeMultipleRequest.Settings == null)
{
throw new FaultException<OrganizationServiceFault>(new OrganizationServiceFault(), "You need to pass a value for 'Settings' in execute multiple request");
}
if (executeMultipleRequest.Requests == null)
{
throw new FaultException<OrganizationServiceFault>(new OrganizationServiceFault(), "You need to pass a value for 'Requests' in execute multiple request");
}
var service = ctx.GetFakedOrganizationService();
var response = new ExecuteMultipleResponse();
response.Results["Responses"] = new ExecuteMultipleResponseItemCollection();
for (var i = 0; i < executeMultipleRequest.Requests.Count; i++)
{
var executeRequest = executeMultipleRequest.Requests[i];
try
{
service.Execute(executeRequest);
if (executeMultipleRequest.Settings.ReturnResponses)
{
response.Responses.Add(new ExecuteMultipleResponseItem
{
RequestIndex = i
});
}
}
catch (Exception ex)
{
if (!response.IsFaulted)
{
response.Results["IsFaulted"] = true;
}
response.Responses.Add(new ExecuteMultipleResponseItem
{
Fault = new OrganizationServiceFault { Message = ex.Message },
RequestIndex = i
});
if (!executeMultipleRequest.Settings.ContinueOnError)
{
break;
}
}
}
// Implement response behaviour as in https://msdn.microsoft.com/en-us/library/jj863631.aspx
if (executeMultipleRequest.Settings.ReturnResponses)
{
response.Results["response.Responses"] = response.Responses;
}
else if (response.Responses.Any(resp => resp.Fault != null))
{
var failures = new ExecuteMultipleResponseItemCollection();
failures.AddRange(response.Responses.Where(resp => resp.Fault != null));
response.Results["response.Responses"] = failures;
}
return response;
}
private void HandleErrors(ExecuteMultipleResponse emrsp)
{
bool beep = true;
foreach (var response in emrsp.Responses)
{
if (response.Fault != null)
{
if (beep)
{
//Console.Beep();
beep = false;
}
errorCount++;
//writeit("(" + (emrCount - emrBatchSize) + response.RequestIndex + ")EMR Error: " + response.RequestIndex + ": " + response.Fault.Message);
}
}
}
private ExecuteMultipleResponse ExecuteInternal(ExecuteMultipleRequest request)
{
var settings = request.Settings;
var response = new ExecuteMultipleResponse();
response.Results["Responses"] = new ExecuteMultipleResponseItemCollection();
for(int i=0; i<request.Requests.Count; i++)
{
var childRequest = request.Requests[i];
OrganizationServiceFault fault = null;
OrganizationResponse childResponse = null;
try
{
if (childRequest.RequestName == "ExecuteMultiple")
{
throw new Exception("ExecuteMultipleRequest cannot contain an ExecuteMultipleRequest");
}
childResponse = ExecuteInternal((dynamic) childRequest);
if (!settings.ReturnResponses)
{
childResponse = null;
}
}
catch (NotImplementedException)
{
throw;
}
catch (FaultException<OrganizationServiceFault> ex)
{
response["IsFaulted"] = true;
fault = ex.Detail;
fault.ErrorDetails["CallStack"] = ex.StackTrace;
if (!settings.ContinueOnError)
{
break;
}
}
catch (Exception ex)
{
response["IsFaulted"] = true;
fault = new OrganizationServiceFault {Message = ex.Message, Timestamp = DateTime.UtcNow};
fault.ErrorDetails["CallStack"] = ex.StackTrace;
if (!settings.ContinueOnError)
{
break;
}
}
finally
{
if (childResponse != null || fault != null)
{
response.Responses.Add(new ExecuteMultipleResponseItem
{
Fault = fault,
RequestIndex = i,
Response = childResponse
});
}
}
}
return response;
}
public BatchCrmOperationResult(ExecuteMultipleResponse response, IList<ICrmOperation> operationResults)
{
_ExecuteMultipleResponse = response;
CurrentResultIndex = -1;
OperationResults = operationResults;
}
protected virtual OrganizationResponse ExecuteOrganisationRequest()
{
var dbCommand = DbCommand;
var orgService = dbCommand.CrmDbConnection.OrganizationService;
// Execute the request and obtain the result.
OrganizationResponse response = null;
// If this operation is part of a batch of operations, then the request,
// is executed allready at the batch level.
if (this.BatchOperation == null)
{
// otherwise, execute the individual request for this operation.
response = orgService.Execute(Request);
}
else
{
// grab the response for this operation from the batch responses.
var multiPart = this as IMultipartOperation;
if (multiPart != null && multiPart.HasMultipleRequests)
{
// rebuild an ExecuteMultipleResponse to contain just the responses for this multipart operation.
var responses = new ExecuteMultipleResponseItemCollection();
ExecuteMultipleResponse multipleResponse = new ExecuteMultipleResponse
{
Results = new ParameterCollection
{
{ "Responses", responses },
{ "IsFaulted", this.BatchOperation.BatchResponse.IsFaulted}
}
};
for (int i = 0; i < multiPart.RequestCount; i++)
{
int reqIndex = this.BatchRequestIndex + i;
var resp = this.BatchOperation.BatchResponse.Responses[reqIndex];
responses.Add(resp);
}
return multipleResponse;
}
return this.BatchOperation.BatchResponse.Responses[this.BatchRequestIndex].Response;
}
// Allow poeople to get access to the response directly via an output paramater.
AssignResponseParameter(dbCommand, response);
return response;
}
private void ThrowExceptionForFaults(ExecuteMultipleResponse response, OrganizationRequestCollection requests)
{
if (!response.IsFaulted) { return; }
var exceptions = new List<Exception>();
foreach (var fault in response.Responses.Select(r => new { r.Fault, r.RequestIndex }))
{
var localFault = fault.Fault;
var target = ((DeleteRequest)requests[fault.RequestIndex]).Target;
if (localFault.ErrorCode == CrmErrorCodes.EntityToDeleteDoesNotExist)
{
Debug.WriteLine("Attempted to Delete Entity that doesn't exist {0} ({1}) - {2}", target.LogicalName, target.Id, localFault.Message);
continue;
}
while (localFault.InnerFault != null)
{
localFault = localFault.InnerFault;
}
var errorDetails = String.Empty;
if (localFault.ErrorDetails.ContainsKey("CallStack"))
{
errorDetails = Environment.NewLine + localFault.ErrorDetails["CallStack"];
}
exceptions.Add(new Exception(localFault.Message + errorDetails));
Debug.WriteLine("Error Deleting {0} ({1}) - {2}{3}", target.LogicalName, target.Id, localFault.Message, errorDetails);
}
if (exceptions.Any())
{
throw new AggregateException("One or more faults occured", exceptions);
}
}
