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