public void LocalCrmDatabaseOrganizationServiceExecuteTests_ExecuteErrorTransactionRequest()
{
var account = new Id <Account>("576E11B7-193A-4B80-A39A-1BF6ECD22A51");
var request = new ExecuteTransactionRequest
{
Requests = new OrganizationRequestCollection
{
new CreateRequest {
Target = account
},
new CreateRequest {
Target = account
}
},
ReturnResponses = true
};
var service = GetService();
try
{
service.Execute(request);
}
catch (FaultException <OrganizationServiceFault> ex)
{
Assert.AreEqual("Cannot insert duplicate key", ex.Message);
Assert.AreEqual("Cannot insert duplicate key", ex.Detail.Message);
Assert.AreEqual(1, ((ExecuteTransactionFault)ex.Detail).FaultedRequestIndex);
}
}
public void LocalCrmDatabaseOrganizationServiceExecuteTests_ExecuteTransactionRequest()
{
var account = new Id <Account>("576E11B7-193A-4B80-A39A-1BF6ECD27A51");
var contact = new Id <Contact>("A40249BF-637A-4AB9-A944-3C2506D12F18");
var request = new ExecuteTransactionRequest
{
Requests = new OrganizationRequestCollection
{
new CreateRequest {
Target = account
},
new CreateRequest {
Target = contact
}
},
ReturnResponses = true
};
var service = GetService();
var response = (ExecuteTransactionResponse)service.Execute(request);
AssertCrm.Exists(service, account);
AssertCrm.Exists(service, contact);
Assert.AreEqual(response.Responses.Count, 2);
service.Delete(account.Entity);
service.Delete(contact.Entity);
request.ReturnResponses = false;
response = (ExecuteTransactionResponse)service.Execute(request);
Assert.AreEqual(response.Responses.Count, 0);
}
/// <summary>
/// Update a collection of records
/// </summary>
/// <param name="colecao"></param>
public void UpdateCollection(EntityCollection colecao)
{
//If quantity up to batchSize limmit do one by one, else use one transaction request
if (colecao.Entities.Count > 1000)
{
foreach (Entity registro in colecao.Entities)
{
Repositorio.RepositorioEntity.Instancia.Atualizar(registro, Guid.Empty);
}
}
else
{
var requestGroup = new ExecuteTransactionRequest()
{
Requests = new OrganizationRequestCollection(), ReturnResponses = false
};
foreach (Entity registro in colecao.Entities)
{
var updateRequest = new UpdateRequest()
{
Target = registro
};
requestGroup.Requests.Add(updateRequest);
}
Repositorio.RepositorioEntity.Instancia.Execute(requestGroup);
}
}
private void UpdateContacts(EntityCollection contacts, Entity contact)
{
if (contacts == null)
{
return;
}
if (contact == null)
{
return;
}
ExecuteTransactionRequest multipleRequest = new ExecuteTransactionRequest {
Requests = new OrganizationRequestCollection(),
ReturnResponses = true
};
foreach (Entity existingContact in contacts.Entities)
{
contact[Attributes.Contact.ContactId] = existingContact.Id;
var updateRequest = new UpdateRequest {
Target = contact
};
multipleRequest.Requests.Add(updateRequest);
if (multipleRequest.Requests.Count == 500)
{
payloadCustomer.Response = CommonXrm.BulkUpdate(multipleRequest, crmService);
multipleRequest.Requests.Clear();
}
}
if (multipleRequest.Requests.Count > 0)
{
payloadCustomer.Response = CommonXrm.BulkUpdate(multipleRequest, crmService);
}
}
/// <summary>
/// Method to update multiple record.
/// </summary>
/// <param name="records"></param>
public void UpdateMultiple(EntityCollection records)
{
var requestToUpdateRecords = new ExecuteTransactionRequest()
{
// Create an empty organization request collection.
Requests = new OrganizationRequestCollection(),
ReturnResponses = false
};
if (records != null && records.Entities != null)
{
int requests = 0;
foreach (var entity in records.Entities)
{
UpdateRequest updateRequest = new UpdateRequest {
Target = entity
};
requestToUpdateRecords.Requests.Add(updateRequest);
requests++;
// Maximum batch size of execute multiple = 1000.
if (requests >= 1000)
{
this._service.Execute(requestToUpdateRecords);
requestToUpdateRecords.Requests.Clear();
requests = 0;
}
}
if (requests > 0)
{
this._service.Execute(requestToUpdateRecords);
}
}
}
public void When_execute_is_called_all_requests_are_executed_with_responses()
{
var context = new XrmFakedContext();
var executor = new ExecuteTransactionExecutor();
var req = new ExecuteTransactionRequest()
{
ReturnResponses = true,
Requests = new OrganizationRequestCollection()
{
new CreateRequest()
{
Target = new Entity("contact")
},
new CreateRequest()
{
Target = new Entity("contact")
},
new CreateRequest()
{
Target = new Entity("contact")
}
}
};
var response = executor.Execute(req, context) as ExecuteTransactionResponse;
var contacts = context.CreateQuery("contact").ToList();
Assert.Equal(3, response.Responses.Count);
Assert.Equal(3, contacts.Count);
}
private static void CreateAccountsExecuteTransaction(CrmServiceClient crmSvc)
{
// https://msdn.microsoft.com/en-us/library/mt634414.aspx
ExecuteTransactionRequest executeTransactionRequest = new ExecuteTransactionRequest()
{
Requests = new OrganizationRequestCollection(),
ReturnResponses = true
};
EntityCollection preparedRecords = PrepareRecordsToCreate();
foreach (var entity in preparedRecords.Entities)
{
CreateRequest createRequest = new CreateRequest {
Target = entity
};
executeTransactionRequest.Requests.Add(createRequest);
}
Stopwatch sw = new Stopwatch();
sw.Start();
crmSvc.Execute(executeTransactionRequest);
sw.Stop();
Console.WriteLine("Creating {0} Accounts took {1}ms", recordsPerBatch, sw.ElapsedMilliseconds);
}
public void Commit()
{
var requests = new OrganizationRequestCollection();
var transactionRequest = new ExecuteTransactionRequest
{
Requests = new OrganizationRequestCollection()
};
Added.ForEach(requests.Add);
Modified.ForEach(requests.Add);
Deleted.ForEach(requests.Add);
Added.Clear();
Modified.Clear();
Deleted.Clear();
try
{
for (int i = 0; i < requests.Count; i++)
{
if ((i + 1) % _batchSize != 0)
{
transactionRequest.Requests.Add(requests[i]);
}
else
{
transactionRequest.Requests.Add(requests[i]);
var response = _service.Execute(transactionRequest);
transactionRequest = new ExecuteTransactionRequest
{
Requests = new OrganizationRequestCollection()
};
}
if ((i == requests.Count - 1) && transactionRequest.Requests.Count > 0)
{
var response = _service.Execute(transactionRequest);
}
}
}
catch (FaultException<OrganizationServiceFault> fault)
{
if (fault.Detail.ErrorDetails.Contains("MaxBatchSize"))
{
int maxBatchSize = Convert.ToInt32(fault.Detail.ErrorDetails["MaxBatchSize"]);
if (maxBatchSize < transactionRequest.Requests.Count)
{
var errMsg =
string.Format(
"The input request collection contains {0} requests, which exceeds the maximum allowed {1}",
transactionRequest.Requests.Count, maxBatchSize);
throw new InvalidOperationException(errMsg, fault);
}
}
throw;
}
}
public async Task <ExecuteTransactionResponse> Handle(ExecuteTransactionRequest request, CancellationToken cancellationToken)
{
try
{
Log.Information("Transaction execution started. Request: {Request}", JsonConvert.SerializeObject(request));
var transaction = await _transactionRepository.GetAsync(request.TransactionId);
if (!CanProcessTransaction(transaction))
{
Log.Warning("The transaction is not available for processing. Request: {Request}", JsonConvert.SerializeObject(request));
return(new ExecuteTransactionResponse()
{
Message = "The transaction is not available for processing", Success = false
});
}
UpdateTransaction(transaction, eStatus.Processing);
try
{
if (!CheckBalance(transaction.AccountOrigin, transaction.Value))
{
var message = "Source account does not have sufficient balance";
UpdateTransaction(transaction, eStatus.Error, message);
Log.Warning(message + " Request: {Request}", JsonConvert.SerializeObject(request));
return(new ExecuteTransactionResponse()
{
Message = message, Success = false
});
}
ExecuteTransaction(transaction);
UpdateTransaction(transaction, eStatus.Confirmed);
}
catch (Exception ex)
{
UpdateTransaction(transaction, eStatus.Error, "An unexpected error occurred while executing transaction");
throw ex;
}
Log.Information("Transaction execution terminated.Request: {Request}", JsonConvert.SerializeObject(request));
return(new ExecuteTransactionResponse()
{
Message = "Transaction successful", Success = true
});;
}
catch (Exception ex)
{
Log.Error(ex, "An unexpected error occurred while executing transaction. Request: {Request}", JsonConvert.SerializeObject(request));
throw ex;
}
}
public void Commit()
{
var transactionRequest = new ExecuteTransactionRequest
{
Requests = new OrganizationRequestCollection()
};
foreach (var entity in Added.Keys)
{
Added[entity].PersistAdded(entity);
}
foreach (var entity in Modified.Keys)
{
Modified[entity].PersistUpdated(entity);
}
foreach (var entity in Removed.Keys)
{
Removed[entity].PersistRemoved(entity);
}
Added.Clear();
Modified.Clear();
Removed.Clear();
try
{
for (int i = 0; i < Requests.Count; i += _batchSize)
{
var requestBatch = Requests.Skip(i).Take(_batchSize);
transactionRequest.Requests.AddRange(requestBatch);
_service.Execute(transactionRequest);
transactionRequest = new ExecuteTransactionRequest
{
Requests = new OrganizationRequestCollection()
};
}
}
catch (FaultException <OrganizationServiceFault> fault)
{
if (fault.Detail.ErrorDetails.Contains("MaxBatchSize"))
{
int maxBatchSize = Convert.ToInt32(fault.Detail.ErrorDetails["MaxBatchSize"]);
if (maxBatchSize < transactionRequest.Requests.Count)
{
var errMsg =
string.Format(
"The input request collection contains {0} requests, which exceeds the maximum allowed {1}",
transactionRequest.Requests.Count, maxBatchSize);
throw new InvalidOperationException(errMsg, fault);
}
}
throw;
}
}
private void InitTransactionRequest()
{
_orgProxy.EnableProxyTypes();
_transactionRequest = new ExecuteTransactionRequest()
{
Requests = new OrganizationRequestCollection(),
ReturnResponses = true
};
}
public ExecuteTransactionResponse ExecuteTransactionRequests(OrganizationRequestCollection collectionRequests, bool returnResponses = true)
{
var request = new ExecuteTransactionRequest
{
Requests = collectionRequests,
ReturnResponses = returnResponses
};
return((ExecuteTransactionResponse)OrganizationService.Execute(request));
}
private ExecuteTransactionResponse ExecuteInternal(ExecuteTransactionRequest request)
{
var response = new ExecuteTransactionResponse
{
Results =
{
["Responses"] = new OrganizationResponseCollection()
}
};
for (int i = 0; i < request.Requests.Count; i++)
{
var childRequest = request.Requests[i];
OrganizationResponse childResponse = null;
try
{
if (childRequest.RequestName == "ExecuteMultiple")
{
throw new Exception("ExecuteMultipleRequest cannot contain an ExecuteMultipleRequest");
}
childResponse = ExecuteInternal((dynamic)childRequest);
if (request.ReturnResponses != true)
{
childResponse = null;
}
}
catch (NotImplementedException)
{
throw;
}
catch (Exception ex)
{
throw new FaultException <OrganizationServiceFault>(new ExecuteTransactionFault
{
FaultedRequestIndex = i,
Message = ex.Message,
Timestamp = DateTime.UtcNow,
ErrorDetails =
{
["CallStack"] = ex.StackTrace
}
}, new FaultReason(ex.Message));
}
finally
{
if (childResponse != null)
{
response.Responses.Add(childResponse);
}
}
}
return(response);
}
public void Execute()
{
this.OnExecutionStarted();
if (this.requestsToExecute.Count > 0)
{
var transactionRequest = new ExecuteTransactionRequest();
transactionRequest.Requests = this.requestsToExecute;
service.Execute(transactionRequest);
}
this.OnExecutionFinished();
}
public void Commit()
{
var transactionRequest = new ExecuteTransactionRequest
{
Requests = new OrganizationRequestCollection()
};
foreach (var entity in Added.Keys)
Added[entity].PersistAdded(entity);
foreach (var entity in Modified.Keys)
Modified[entity].PersistUpdated(entity);
foreach (var entity in Removed.Keys)
Removed[entity].PersistRemoved(entity);
Added.Clear();
Modified.Clear();
Removed.Clear();
try
{
for (int i = 0; i < Requests.Count; i += _batchSize)
{
var requestBatch = Requests.Skip(i).Take(_batchSize);
transactionRequest.Requests.AddRange(requestBatch);
_service.Execute(transactionRequest);
transactionRequest = new ExecuteTransactionRequest
{
Requests = new OrganizationRequestCollection()
};
}
}
catch (FaultException<OrganizationServiceFault> fault)
{
if (fault.Detail.ErrorDetails.Contains("MaxBatchSize"))
{
int maxBatchSize = Convert.ToInt32(fault.Detail.ErrorDetails["MaxBatchSize"]);
if (maxBatchSize < transactionRequest.Requests.Count)
{
var errMsg =
string.Format(
"The input request collection contains {0} requests, which exceeds the maximum allowed {1}",
transactionRequest.Requests.Count, maxBatchSize);
throw new InvalidOperationException(errMsg, fault);
}
}
throw;
}
}
public void CreateTransaction()
{
try
{
executeTransactionRequest = new ExecuteTransactionRequest();
executeTransactionRequest.Requests = new OrganizationRequestCollection();
executeTransactionRequest.ReturnResponses = true;
}
catch (Exception ex)
{
throw ex;
}
}
public List <DtoMultipleReponse> Execute(List <ExecuteTransactionRequest> resultList, bool isOnlyErrRes = true)
{
List <DtoMultipleReponse> errorResponseList = new List <DtoMultipleReponse>();
try
{
for (int i = 0; i < resultList.Count; i++)
{
ExecuteTransactionRequest request = resultList[i] as ExecuteTransactionRequest;
ExecuteTransactionResponse responseResult = (ExecuteTransactionResponse)_orgProxy.Execute(request);
if (!isOnlyErrRes)
{
foreach (var responseItem in responseResult.Responses)
{
if (responseItem.Results.Count > 0)
{
DtoMultipleReponse dto = new DtoMultipleReponse()
{
IsSuccess = true,
RequestName = responseItem.ResponseName
};
if ("Create".Equals(responseItem.ResponseName)) //Create만 Return Id가 존재하는 듯함
{
//dto.RequestId = responseItem.Results["id"].ToString();
}
errorResponseList.Add(dto);
}
}
}
}
return(errorResponseList);
}
catch (FaultException <OrganizationServiceFault> ex)
{
DtoMultipleReponse dto = new DtoMultipleReponse()
{
IsSuccess = false,
RequestFaultMessage = ex.Detail.Message
};
errorResponseList.Add(dto);
return(errorResponseList);
}
catch (Exception e)
{
throw e;
}
}
public static XrmUpdateResponse BulkUpdate(ExecuteTransactionRequest multipleRequest, IOrganizationService service)
{
if (multipleRequest == null && multipleRequest.Requests == null && multipleRequest.Requests.Count == 0)
{
return(null);
}
if (service == null)
{
return(null);
}
ExecuteTransactionResponse multipleResponses = (ExecuteTransactionResponse)service.Execute(multipleRequest);
return(new XrmUpdateResponse {
Updated = true, Existing = true
});
}
static void Main()
{
var connectionString = "AuthType=Office365;[email protected]; Password=;Url=https://.crm6.dynamics.com";
var crmSvc = new CrmServiceClient(connectionString);
using (var serviceProxy = crmSvc.OrganizationServiceProxy)
{
//Create request collection
var request = new OrganizationRequestCollection()
{
new CreateRequest
{
Target = new Entity("account")
{
["name"] = "Packt Account"
}
},
new CreateRequest
{
Target = new Entity("contact")
{
["firstname"] = "Packt",
["lastname"] = "Contact"
}
}
};
//Create Transaction and pass previously created request collection
var requestToCreateRecords = new ExecuteTransactionRequest()
{
// Create an empty organization request collection.
Requests = request,
ReturnResponses = true
};
//Execute requests within the transaction
var responseForCreateRecords = (ExecuteTransactionResponse)serviceProxy.Execute(requestToCreateRecords);
// Display the results of each response.
foreach (var responseItem in responseForCreateRecords.Responses)
{
Console.WriteLine("Created record with GUID {0}", responseItem.Results["id"].ToString());
}
}
}
public void ApplyRulesToUser(EntityReferenceCollection ec, Guid userId, bool isOutlookFilter)
{
var tempUserId = ((CrmServiceClient)service).CallerId;
((CrmServiceClient)service).CallerId = userId;
try
{
// TODO ICI
var existingQueries = service.RetrieveMultiple(new QueryExpression("userquery")
{
Criteria = new FilterExpression
{
Conditions =
{
new ConditionExpression("parentqueryid", ConditionOperator.In, ec.Select(e => e.Id).ToArray())
}
}
}).Entities;
var transac = new ExecuteTransactionRequest
{
Requests = new OrganizationRequestCollection(),
ReturnResponses = false
};
foreach (var query in existingQueries)
{
transac.Requests.Add(new DeleteRequest {
Target = query.ToEntityReference()
});
}
transac.Requests.Add(new InstantiateFiltersRequest
{
UserId = userId,
TemplateCollection = ec
});
service.Execute(transac);
}
finally
{
((CrmServiceClient)service).CallerId = tempUserId;
}
}
public void Commit()
{
if (requests.Count == 0)
{
return;
}
var executeTransactionRequest = new ExecuteTransactionRequest
{
Requests = new OrganizationRequestCollection(),
ReturnResponses = false
};
executeTransactionRequest.Requests.AddRange(requests);
orgService.Execute(executeTransactionRequest);
}
public ExecuteTransactionResponse ExecuteTransaction(Dictionary <Entity, RequestType> entityList)
{
try
{
executeTransactionRequest = new ExecuteTransactionRequest();
executeTransactionRequest.Requests = new OrganizationRequestCollection();
executeTransactionRequest.ReturnResponses = true;
foreach (KeyValuePair <Entity, RequestType> entity in entityList)
{
if (entity.Value == RequestType.Create)
{
CreateRequest request = new CreateRequest
{
Target = entity.Key
};
executeTransactionRequest.Requests.Add(request);
}
else if (entity.Value == RequestType.Update)
{
UpdateRequest request = new UpdateRequest
{
Target = entity.Key
};
executeTransactionRequest.Requests.Add(request);
}
else if (entity.Value == RequestType.Delete)
{
DeleteRequest request = new DeleteRequest
{
Target = new EntityReference(entity.Key.LogicalName, entity.Key.Id)
};
executeTransactionRequest.Requests.Add(request);
}
}
return((ExecuteTransactionResponse)_service.Execute(executeTransactionRequest));
}
catch (Exception ex)
{
throw ex;
}
}
public void When_execute_is_called_all_requests_are_executed()
{
var context = new XrmFakedContext();
var executor = new ExecuteTransactionExecutor();
var req = new ExecuteTransactionRequest()
{
Requests = new OrganizationRequestCollection()
{
new CreateRequest() { Target = new Entity("contact") },
new CreateRequest() { Target = new Entity("contact") },
new CreateRequest() { Target = new Entity("contact") }
}
};
var response = executor.Execute(req, context) as ExecuteTransactionResponse;
var contacts = context.CreateQuery("contact").ToList();
Assert.Equal(0, response.Responses.Count);
Assert.Equal(3, contacts.Count);
}
public async Task <IActionResult> ExecuteTransaction(ExecuteTransactionRequest request)
{
try
{
var response = _mediator.Send(request);
var result = response.Result;
if (!result.Success)
{
return(BadRequest(result.Message));
}
return(Ok(result));
}
catch (ValidationException ex)
{
return(BadRequest(ReturnValidations(ex)));
}
}
public List <DtoTransactionResponseGuid> Execute(List <ExecuteTransactionRequest> resultList)
{
List <DtoTransactionResponse> errorResponseList = new List <DtoTransactionResponse>();
List <DtoTransactionResponseGuid> responseResultList = new List <DtoTransactionResponseGuid>();
try
{
for (int i = 0; i < resultList.Count; i++)
{
ExecuteTransactionRequest request = resultList[i] as ExecuteTransactionRequest;
ExecuteTransactionResponse responseResult = (ExecuteTransactionResponse)_orgProxy.Execute(request);
foreach (var resultResponse in responseResult.Responses)
{
if (resultResponse.ResponseName != "Delete")
{
responseResultList.Add(new DtoTransactionResponseGuid
{
Id = resultResponse.Results.Select(a => a.Value.ToString()).SingleOrDefault()
});
}
}
}
return(responseResultList);
}
catch (FaultException <OrganizationServiceFault> ex)
{
DtoTransactionResponse dto = new DtoTransactionResponse()
{
ErrorDetails = ex.Detail.ErrorDetails,
Message = ex.Detail.Message,
ErrorCode = ex.Detail.ErrorCode
};
throw;
}
catch (Exception e)
{
throw e;
}
}
private void RunMultipleRequestsInternalBatchTransaction(CTCRunMultipleState state)
{
CTCRunMultipleTaskState taskState = new CTCRunMultipleTaskState();
taskState.Service = _Service;
taskState.ReturnResponses = state.ReturnResponses;
taskState.ContinueOnError = state.ContinueOnError;
taskState.Requests = state.Requests.Skip(state.RequestIndex).Take(state.BatchSize);
state.RequestIndex += state.BatchSize;
taskState.Responses = new List <CTCRunMultipleResponseItem>();
ExecuteTransactionRequest req = new ExecuteTransactionRequest()
{
Requests = new OrganizationRequestCollection()
};
req.Requests.AddRange(taskState.Requests);
try
{
var response = _Service.Execute(req) as ExecuteTransactionResponse;
int reqIndex = 0;
foreach (var item in response.Responses)
{
CTCRunMultipleResponseItem resultItem = new CTCRunMultipleResponseItem();
resultItem.Request = req.Requests[reqIndex];
reqIndex++;
resultItem.Response = item;
taskState.Responses.Add(resultItem);
}
}
catch (FaultException <OrganizationServiceFault> fault)
{
RunMultipleRequestsHandleFault(state, fault);
}
state.Results.ResultItems.AddRange(taskState.Responses);
}
public void ExecuteUpdateSteps(ICrmService crmService)
{
var requestsQueue = new Queue <OrganizationRequest>(updateStageSteps);
do
{
var requestsChunk = ToOrganizationRequestCollection(DequeueChunk(requestsQueue, 1000));
if (requestsChunk.Count == 0)
{
break;
}
var transactionalRequest = new ExecuteTransactionRequest
{
ReturnResponses = true,
Requests = requestsChunk
};
var res = crmService.ExecuteRequest(transactionalRequest);
} while (true);
}
public void Update(Entity entity)
{
var transaction = new ExecuteTransactionRequest();
foreach (var attribute in entity.Attributes.ToList())
{
var attributes = _crmCache.GetValueUpdateCache <EntityAttribute>($"EntityDefinitions(LogicalName='{entity.LogicalName}')/Attributes(LogicalName='{attribute.Key}')", "Get", DateTimeOffset.Now.AddDays(1));
if (attributes.AttributeTypeName.Value == "LookupType" && attribute.Value == null)
{
var diasociateReq = new DisassociateRequest(entity.ToEntityReference(), attribute.Key);
transaction.AddRequest(diasociateReq);
entity.Attributes.Remove(attribute.Key);
}
}
var updReq = new UpdateRequest();
updReq.Target = entity;
transaction.AddRequest(updReq);
var response = _webProxy.GetTransactionResponse(transaction);
}
[STAThread] // Required to support the interactive login experience
static void Main(string[] args)
{
CrmServiceClient service = null;
try
{
service = SampleHelpers.Connect("Connect");
if (service.IsReady)
{
// Create any entity records that the demonstration code requires
SetUpSample(service);
#region Demonstrate
// Create an ExecuteTransactionRequest object.
var requestToCreateRecords = new ExecuteTransactionRequest()
{
// Create an empty organization request collection.
Requests = new OrganizationRequestCollection(),
ReturnResponses = true
};
// Create several (local, in memory) entities in a collection.
EntityCollection input = GetCollectionOfEntitiesToCreate();
// Add a CreateRequest for each entity to the request collection.
foreach (var entity in input.Entities)
{
CreateRequest createRequest = new CreateRequest {
Target = entity
};
requestToCreateRecords.Requests.Add(createRequest);
}
var responseForCreateRecords =
(ExecuteTransactionResponse)service.Execute(requestToCreateRecords);
int i = 0;
// Display the results returned in the responses.
foreach (var responseItem in responseForCreateRecords.Responses)
{
if (responseItem != null)
{
DisplayResponse(requestToCreateRecords.Requests[i], responseItem);
}
i++;
}
Console.WriteLine("Create request failed for the account{0} and the reason being: {1}");
var requestForUpdates = new ExecuteTransactionRequest()
{
Requests = new OrganizationRequestCollection()
};
// Update the entities that were previously created.
EntityCollection update = GetCollectionOfEntitiesToUpdate();
foreach (var entity in update.Entities)
{
UpdateRequest updateRequest = new UpdateRequest {
Target = entity
};
requestForUpdates.Requests.Add(updateRequest);
}
ExecuteTransactionResponse responseForUpdates =
(ExecuteTransactionResponse)service.Execute(requestForUpdates);
Console.WriteLine("Entity records are updated.");
Console.WriteLine("Update request failed for the account{0} and the reason being: {1}");
#endregion Demonstrate
#region Clean up
CleanUpSample(service);
#endregion Clean up
}
else
{
const string UNABLE_TO_LOGIN_ERROR = "Unable to Login to Common Data Service";
if (service.LastCrmError.Equals(UNABLE_TO_LOGIN_ERROR))
{
Console.WriteLine("Check the connection string values in cds/App.config.");
throw new Exception(service.LastCrmError);
}
else
{
throw service.LastCrmException;
}
}
}
catch (Exception ex)
{
SampleHelpers.HandleException(ex);
}
finally
{
if (service != null)
{
service.Dispose();
}
Console.WriteLine("Press <Enter> to exit.");
Console.ReadLine();
}
}
/// <summary>
/// This sample demonstrates how to execute a collection of message requests in a single database transaction,
/// by using a single web service call and optionally return the results.
/// </summary>
/// <seealso cref="https://msdn.microsoft.com/en-us/library/gg328075.aspx#bkmk_transaction"/>
/// <param name="serverConfig">Contains server connection information.</param>
/// <param name="promptforDelete">When True, the user will be prompted to delete all
/// created entities.</param>
public void Run(ServerConnection.Configuration serverConfig, bool promptforDelete)
{
ExecuteTransactionRequest requestToCreateRecords = null;
try
{
// Get a reference to the organization service.
using (_serviceProxy = new OrganizationServiceProxy(serverConfig.OrganizationUri, serverConfig.HomeRealmUri, serverConfig.Credentials, serverConfig.DeviceCredentials))
{
// Enable early-bound type support to add/update entity records required for this sample.
_serviceProxy.EnableProxyTypes();
#region Execute Transaction to create records
// Create an ExecuteTransactionRequest object.
requestToCreateRecords = new ExecuteTransactionRequest()
{
// Create an empty organization request collection.
Requests = new OrganizationRequestCollection(),
ReturnResponses = true
};
// Create several (local, in memory) entities in a collection.
EntityCollection input = GetCollectionOfEntitiesToCreate();
// Add a CreateRequest for each entity to the request collection.
foreach (var entity in input.Entities)
{
CreateRequest createRequest = new CreateRequest {
Target = entity
};
requestToCreateRecords.Requests.Add(createRequest);
}
// Execute all the requests in the request collection using a single web method call.
try
{
var responseForCreateRecords =
(ExecuteTransactionResponse)_serviceProxy.Execute(requestToCreateRecords);
int i = 0;
// Display the results returned in the responses.
foreach (var responseItem in responseForCreateRecords.Responses)
{
if (responseItem != null)
{
DisplayResponse(requestToCreateRecords.Requests[i], responseItem);
}
i++;
}
}
catch (FaultException <OrganizationServiceFault> ex)
{
Console.WriteLine("Create request failed for the account{0} and the reason being: {1}",
((ExecuteTransactionFault)(ex.Detail)).FaultedRequestIndex + 1, ex.Detail.Message);
throw;
}
#endregion Execute Transaction to create records
#region Execute Transaction to update records
ExecuteTransactionRequest requestForUpdates = new ExecuteTransactionRequest()
{
Requests = new OrganizationRequestCollection()
};
// Update the entities that were previously created.
EntityCollection update = GetCollectionOfEntitiesToUpdate();
foreach (var entity in update.Entities)
{
UpdateRequest updateRequest = new UpdateRequest {
Target = entity
};
requestForUpdates.Requests.Add(updateRequest);
}
try
{
ExecuteTransactionResponse responseForUpdates =
(ExecuteTransactionResponse)_serviceProxy.Execute(requestForUpdates);
Console.WriteLine("Entity records are updated.");
}
catch (FaultException <OrganizationServiceFault> ex)
{
Console.WriteLine("Update request failed for the account{0} and the reason being: {1}",
((ExecuteTransactionFault)(ex.Detail)).FaultedRequestIndex + 1, ex.Detail.Message);
}
#endregion Execute Transaction for update records
DeleteRequiredRecords(promptforDelete);
}
}
catch (FaultException <OrganizationServiceFault> fault)
{
// Check if the maximum batch size has been exceeded. The maximum batch size is only included in the fault if it
// the input request collection count exceeds the maximum batch size.
if (fault.Detail.ErrorDetails.Contains("MaxBatchSize"))
{
int maxBatchSize = Convert.ToInt32(fault.Detail.ErrorDetails["MaxBatchSize"]);
if (maxBatchSize < requestToCreateRecords.Requests.Count)
{
// Here you could reduce the size of your request collection and re-submit the ExecuteTransaction request.
// For this sample, that only issues a few requests per batch, we will just print out some info. However,
// this code will never be executed because the default max batch size is 1000.
Console.WriteLine("The input request collection contains %0 requests, which exceeds the maximum allowed (%1)",
requestToCreateRecords.Requests.Count, maxBatchSize);
}
}
// Re-throw so Main() can process the fault.
throw;
}
}
public ExecuteTransactionResponse GetTransactionResponse(ExecuteTransactionRequest request)
{
var requestDictionary = new Dictionary <int, string>();
var batchid = "batch_" + Guid.NewGuid().ToString();
var batchContent = new MultipartContent("mixed", batchid);
var changesetID = "changeset_" + Guid.NewGuid().ToString();
var changeSetContent = new MultipartContent("mixed", changesetID);
for (int contentId = 1; contentId <= request.Requests.Count; contentId++)
{
HttpMessageContent content = new HttpMessageContent(GetRequestMessage((OrganizationRequest)request.Requests[contentId - 1]));
content.Headers.Remove("Content-Type");
content.Headers.TryAddWithoutValidation("Content-Type", "application/http");
content.Headers.TryAddWithoutValidation("Content-Transfer-Encoding", "binary");
content.Headers.TryAddWithoutValidation("Content-ID", contentId.ToString());
changeSetContent.Add(content);
requestDictionary.Add(contentId, ((OrganizationRequest)request.Requests[contentId - 1]).RequestName);
}
batchContent.Add(changeSetContent);
var batchRequest = new HttpRequestMessage(HttpMethod.Post, _endpoint + "$batch")
{
Content = batchContent
};
var batchstring = batchRequest.Content.ReadAsStringAsync();
var httpClient = new HttpClient(new HttpClientHandler {
Credentials = _credential ?? CredentialCache.DefaultNetworkCredentials
});
var response = httpClient.SendAsync(batchRequest)?.Result;
if (response == null)
{
throw new Exception("Сервер вернул пустой ответ");
}
if (!response.IsSuccessStatusCode)
{
var exception = JsonSerializer.Deserialize <CrmException>(response.Content.ReadAsStringAsync().Result);
throw new CrmException(exception.Error.Message, exception);
}
var responseString = response.Content.ReadAsStringAsync();
MultipartMemoryStreamProvider batchStream = response.Content.ReadAsMultipartAsync().Result;
var batchStreamContent = batchStream.Contents.FirstOrDefault();
MultipartMemoryStreamProvider changesetStream = batchStreamContent.ReadAsMultipartAsync().Result;
var transactionResponse = new ExecuteTransactionResponse();
foreach (var changesetContent in changesetStream.Contents)
{
changesetContent.Headers.Remove("Content-Type");
changesetContent.Headers.Add("Content-Type", "application/http; msgtype=response");
var indivdualResponse = changesetContent.ReadAsHttpResponseMessageAsync().Result;
if (!indivdualResponse.IsSuccessStatusCode)
{
var exception = JsonSerializer.Deserialize <CrmException>(response.Content.ReadAsStringAsync().Result);
throw new CrmException(exception.Error.Message, exception);
}
var operationName = requestDictionary.FirstOrDefault(dic => dic.Key == int.Parse(changesetContent.Headers.GetValues("Content-ID").FirstOrDefault())).Value;
if (operationName == Constants.CREATE)
{
var idString = indivdualResponse.Headers.GetValues("OData-EntityId").FirstOrDefault();
idString = idString.Replace(_endpoint, "").Replace("(", "").Replace(")", "");
idString = idString.Substring(idString.Length - 36);
var createResponse = new CreateResponse {
Id = Guid.Parse(idString), ResponseName = operationName
};
transactionResponse.Responses.Add(createResponse);
}
if (operationName == Constants.UPDATE)
{
var updateResponse = new UpdateResponse {
ResponseName = operationName
};
transactionResponse.Responses.Add(updateResponse);
}
if (operationName == Constants.DELETE)
{
var deleteResponse = new DeleteResponse {
ResponseName = operationName
};
transactionResponse.Responses.Add(deleteResponse);
}
if (operationName == Constants.DISASSOCIATE)
{
var deleteResponse = new DissacociateResponse {
ResponseName = operationName
};
transactionResponse.Responses.Add(deleteResponse);
}
if (operationName == Constants.ASSOCIATE)
{
var deleteResponse = new AssociateResponse {
ResponseName = operationName
};
transactionResponse.Responses.Add(deleteResponse);
}
}
return(transactionResponse);
}
Task <ExecuteTransactionResponse> IAmazonDynamoDB.ExecuteTransactionAsync(ExecuteTransactionRequest request, CancellationToken cancellationToken)
{
throw new NotSupportedException();
}
public static void method()
{// Create an ExecuteTransactionRequest object.
crmService obj = new crmService();
CrmServiceClient conn = obj.CrmConnector();
_orgService = (IOrganizationService)conn.OrganizationWebProxyClient != null ? (IOrganizationService)conn.OrganizationWebProxyClient : (IOrganizationService)conn.OrganizationServiceProxy;
var requestToCreateRecords = new ExecuteTransactionRequest()
{
// Create an empty organization request collection.
Requests = new OrganizationRequestCollection(),
ReturnResponses = true
};
// Create several (local, in memory) entities in a collection.
Entity o1 = new Entity("salesorder");
o1.Attributes["name"] = "test1 order";
Entity opp1 = new Entity("opportunity");
opp1.Attributes["name"] = "test1 opp";
EntityCollection collection = new EntityCollection();
collection.Entities.Add(opp1);
collection.Entities.Add(o1);
// Add a CreateRequest for each entity to the request collection.
foreach (var entity in collection.Entities)
{
CreateRequest createRequest = new CreateRequest {
Target = entity
};
requestToCreateRecords.Requests.Add(createRequest);
}
// Execute all the requests in the request collection using a single web method call.
try
{
crmService service = new crmService();
var responseForCreateRecords =
(ExecuteTransactionResponse)_orgService.Execute(requestToCreateRecords);
int i = 0;
// Display the results returned in the responses.
foreach (var responseItem in responseForCreateRecords.Responses)
{
if (responseItem != null)
{
Console.WriteLine("Created " + ((EntityReference)requestToCreateRecords.Requests[i].Parameters["Target"]).Name
+ " with record id as " + responseItem.Results["id"].ToString());
}
i++;
}
}
catch (FaultException <OrganizationServiceFault> ex)
{
Console.WriteLine("Create request failed for the account{0} and the reason being: {1}",
((ExecuteTransactionFault)(ex.Detail)).FaultedRequestIndex + 1, ex.Detail.Message);
throw;
}
}
