public static OperationType GetOperationType(this ExecuteMultipleResponseItem response)
{
response.ThrowArgumentNullExceptionIfNull(nameof(response));
if (response.Fault != null)
{
return(OperationType.Failed);
}
switch (response.Response.GetType().Name)
{
case nameof(AssignResponse):
return(OperationType.Assign);
case nameof(AssociateResponse):
return(OperationType.Associate);
case nameof(CreateResponse):
return(OperationType.Create);
case nameof(UpdateResponse):
return(OperationType.Update);
case nameof(UpsertResponse):
var responseTyped = response.Response as UpsertResponse;
return(responseTyped.RecordCreated ? OperationType.Create : OperationType.Update);
default:
throw new ArgumentOutOfRangeException($"Type {response.Response.GetType().Name} is not supported");
}
}
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 string GetFaultedMessage(ExecuteMultipleResponseItem responseItem)
{
string message = string.Empty;
if (responseItem.Fault == null)
{
return(message);
}
if (responseItem.Fault.Timestamp != null)
{
message = responseItem.Fault.Timestamp.ToString() + " ";
}
if (responseItem.Fault.Message != null)
{
message = message + responseItem.Fault.Message;
}
if (responseItem.Fault.InnerFault != null && responseItem.Fault.InnerFault.Message != null)
{
message = message + " Inner Fault : " + responseItem.Fault.InnerFault.Message;
}
return(message);
}
public void GetOperationTypeNullExecuteMultipleResponseItem()
{
ExecuteMultipleResponseItem response = null;
OperationType actual = OperationType.Update;
FluentActions.Invoking(() => actual = response.GetOperationType())
.Should()
.Throw <ArgumentNullException>();
}
internal void SetUpdateResponse(ExecuteMultipleResponseItem response)
{
UpdateResponse = response;
if (response.Fault != null && response.Fault.InnerFault != null)
{
ErrorMessage = response.Fault.ErrorCode + " : " + response.Fault.Message.ToString( ).Replace('\n', ' ');
IsOk = false;
}
}
public void GetOperationTypeWithExecuteMultipleResponseItemHavingNullResponse()
{
var response = new ExecuteMultipleResponseItem();
OperationType actual = OperationType.Update;
FluentActions.Invoking(() => actual = response.GetOperationType())
.Should()
.Throw <NullReferenceException>();
}
public void GetOperationMessageNullExecuteMultipleResponseItem()
{
Entity entity = new Entity("contact", Guid.NewGuid());
ExecuteMultipleResponseItem responseItem = null;
string actual = null;
FluentActions.Invoking(() => actual = responseItem.GetOperationMessage(entity))
.Should()
.Throw <ArgumentNullException>();
}
public void GetOperationMessageNullEntity()
{
var responseItem = new ExecuteMultipleResponseItem
{
};
string actual = null;
FluentActions.Invoking(() => actual = responseItem.GetOperationMessage(null))
.Should()
.Throw <ArgumentNullException>();
}
public void GetOperationMessageWithExecuteMultipleResponseItemHavingNoresponse()
{
Entity entity = new Entity("contact", Guid.NewGuid());
var responseItem = new ExecuteMultipleResponseItem
{
};
string actual = null;
FluentActions.Invoking(() => actual = responseItem.GetOperationMessage(entity))
.Should()
.Throw <NullReferenceException>();
}
public void GetOperationTypeWithExecuteMultipleResponseItemHavingOrganizationResponse()
{
var response = new ExecuteMultipleResponseItem
{
Response = new OrganizationResponse()
};
OperationType actual = OperationType.Update;
FluentActions.Invoking(() => actual = response.GetOperationType())
.Should()
.Throw <ArgumentOutOfRangeException>();
}
private ExecuteMultipleResponseItem GetDeleteResponseItem(int requestIndex)
{
var deleteResponse = new DeleteResponse
{
Results = new ParameterCollection()
};
var retrieveResponseItem = new ExecuteMultipleResponseItem();
retrieveResponseItem.RequestIndex = requestIndex;
retrieveResponseItem.Response = deleteResponse;
return(retrieveResponseItem);
}
private ExecuteMultipleResponseItem GetUpdateResponseItem(int requestIndex)
{
var updateResponse = new UpdateResponse
{
Results = new ParameterCollection()
};
var updateResponseItem = new ExecuteMultipleResponseItem();
updateResponseItem.RequestIndex = requestIndex;
updateResponseItem.Response = updateResponse;
return(updateResponseItem);
}
public void GetOperationTypeWithExecuteMultipleResponseItemHavingAssociateResponse()
{
var response = new ExecuteMultipleResponseItem
{
Response = new AssociateResponse()
};
OperationType actual = OperationType.Update;
FluentActions.Invoking(() => actual = response.GetOperationType())
.Should()
.NotThrow();
actual.Should().Be(OperationType.Associate);
}
public void GetOperationTypeWithFault()
{
var response = new ExecuteMultipleResponseItem
{
Fault = new OrganizationServiceFault()
};
OperationType actual = OperationType.Update;
FluentActions.Invoking(() => actual = response.GetOperationType())
.Should()
.NotThrow();
actual.Should().Be(OperationType.Failed);
}
public void GetOperationMessageWithExecuteMultipleResponseItemHavingFault()
{
Entity entity = new Entity("contact", Guid.NewGuid());
var responseItem = new ExecuteMultipleResponseItem
{
Fault = new OrganizationServiceFault()
};
string actual = null;
FluentActions.Invoking(() => actual = responseItem.GetOperationMessage(entity))
.Should()
.NotThrow();
actual.Should().Contain("Error:");
}
private ExecuteMultipleResponseItemCollection GetFakeOrgServiceResponse(Guid id, DateTime modifiedOnDate, ICrmMetaDataProvider crmMetaDataProvider)
{
// This is a fake ExecuteMultipleResponse that will be returned to our sut at test time.
var responses = new ExecuteMultipleResponseItemCollection();
// fake response for insert.
ExecuteMultipleResponseItem createResponse = GetCreateResponseItem(0, id);
responses.Add(createResponse);
// fake response for second insert.
ExecuteMultipleResponseItem createResponseWithOutput = GetCreateResponseItem(1, null);
responses.Add(createResponseWithOutput);
// fake response for update.
ExecuteMultipleResponseItem updateResponseItem = GetUpdateResponseItem(2);
responses.Add(updateResponseItem);
ExecuteMultipleResponseItem updateResponseItemWithOutput = GetUpdateResponseItem(3);
responses.Add(updateResponseItemWithOutput);
// This is a fake RetrieveResponse that will be returned to our sut at test time.
var updatedContactEntity = new Entity("contact");
updatedContactEntity.Id = id;
updatedContactEntity["contactid"] = id;
updatedContactEntity["modifiedon"] = modifiedOnDate;
ExecuteMultipleResponseItem retrieveResponseItemForUpdateOutput = GetRetrieveResponseItem(4, updatedContactEntity);
responses.Add(retrieveResponseItemForUpdateOutput);
ExecuteMultipleResponseItem deleteResponseItem = GetDeleteResponseItem(5);
responses.Add(deleteResponseItem);
var entityDataGenerator = new EntityDataGenerator(crmMetaDataProvider);
var entities = entityDataGenerator.GenerateFakeEntities("contact", 10);
EntityCollection fakeEntityResults = new EntityCollection(entities);
ExecuteMultipleResponseItem retrieveMultipleResponseItem = GetRetrieveMultipleResponseItem(6, fakeEntityResults);
responses.Add(retrieveMultipleResponseItem);
return(responses);
}
private ExecuteMultipleResponseItem GetRetrieveMultipleResponseItem(int requestIndex, EntityCollection resultEntities)
{
var retrieveMultipleResponse = new RetrieveMultipleResponse
{
Results = new ParameterCollection
{
{ "EntityCollection", resultEntities }
}
};
var retrieveResponseItem = new ExecuteMultipleResponseItem();
retrieveResponseItem.RequestIndex = requestIndex;
retrieveResponseItem.Response = retrieveMultipleResponse;
return(retrieveResponseItem);
}
private ExecuteMultipleResponseItem GetRetrieveResponseItem(int requestIndex, Entity updatedContactEntity)
{
var retrieveResponse = new RetrieveResponse
{
Results = new ParameterCollection
{
{ "Entity", updatedContactEntity }
}
};
var retrieveResponseItem = new ExecuteMultipleResponseItem();
retrieveResponseItem.RequestIndex = requestIndex;
retrieveResponseItem.Response = retrieveResponse;
return(retrieveResponseItem);
}
public void GetOperationMessageCreateResponse()
{
var entityName = "contact";
var id = Guid.Empty;
Entity entity = new Entity(entityName, id);
var responseItem = new ExecuteMultipleResponseItem
{
Response = new CreateResponse()
};
var expected = $"Entity {entityName}:{id} {responseItem.Response.ResponseName}";
string actual = null;
FluentActions.Invoking(() => actual = responseItem.GetOperationMessage(entity))
.Should()
.NotThrow();
actual.Should().Be(expected);
}
private ExecuteMultipleResponseItem GetCreateResponseItem(int requestIndex, Guid?specifiedId = null)
{
if (specifiedId == null)
{
specifiedId = Guid.NewGuid();
}
var createResponse = new CreateResponse
{
Results = new ParameterCollection
{
{ "id", specifiedId }
}
};
var createResponseItem = new ExecuteMultipleResponseItem();
createResponseItem.RequestIndex = requestIndex;
createResponseItem.Response = createResponse;
return(createResponseItem);
}
public void GetOperationMessageWithExecuteMultipleResponseItemHavingInnerFault()
{
var testMessage = "Random Test message!";
Entity entity = new Entity("contact", Guid.NewGuid());
var responseItem = new ExecuteMultipleResponseItem
{
Fault = new OrganizationServiceFault()
{
InnerFault = new OrganizationServiceFault()
{
Message = testMessage
}
}
};
string actual = null;
FluentActions.Invoking(() => actual = responseItem.GetOperationMessage(entity))
.Should()
.NotThrow();
actual.Should().Contain(testMessage);
}
public static string GetOperationMessage(this ExecuteMultipleResponseItem response, Entity entity)
{
entity.ThrowArgumentNullExceptionIfNull(nameof(entity));
response.ThrowArgumentNullExceptionIfNull(nameof(response));
if (response.Fault != null)
{
return(GetOperationResultError(response.Fault));
}
switch (response.Response.GetType().Name)
{
case nameof(CreateResponse):
var createResponse = response.Response as CreateResponse;
return($"Entity {entity.LogicalName}:{createResponse.id} {response.Response.ResponseName}");
case nameof(UpsertResponse):
var upsertResponse = response.Response as UpsertResponse;
return($"Entity {entity.LogicalName}:{upsertResponse.Target.Id} {response.Response.ResponseName}");
default:
return($"Entity {entity.LogicalName}:{entity.Id} {response.Response.ResponseName}");
}
}
public void Should_Be_Able_To_Execute_An_Update_With_Output_Clause_And_Get_Back_Values()
{
// Arrange
using (var sandbox = ConnectionTestsSandbox.Create())
{
var dbConnection = sandbox.Container.Resolve <CrmDbConnection>();
var command = new CrmDbCommand(dbConnection);
command.CommandText = "UPDATE contact SET firstname = 'JO', lastname = 'SCHMO' OUTPUT INSERTED.modifiedon, INSERTED.contactid WHERE contactid = '9bf20a16-6034-48e2-80b4-8349bb80c3e2'";
command.CommandType = System.Data.CommandType.Text;
var provider = new SqlGenerationCrmOperationProvider(new DynamicsAttributeTypeProvider());
var orgCommand = provider.GetOperation(command, System.Data.CommandBehavior.Default);
// This is a fake CreateResponse that will be returned to our sut at test time.
Guid expectedId = Guid.Parse("9bf20a16-6034-48e2-80b4-8349bb80c3e2");
var createResponse = new UpdateResponse
{
Results = new ParameterCollection()
};
// This is a fake RetrieveResponse that will be returned to our sut at test time.
var resultEntity = new Entity("contact");
resultEntity.Id = expectedId;
resultEntity["contactid"] = expectedId;
var modifiedOnDate = DateTime.UtcNow;
resultEntity["modifiedon"] = modifiedOnDate;
var retrieveResponse = new RetrieveResponse
{
Results = new ParameterCollection
{
{ "Entity", resultEntity }
}
};
// This is a fake ExecuteMultipleResponse that will be returned to our sut at test time.
var responses = new ExecuteMultipleResponseItemCollection();
var updateResponseItem = new ExecuteMultipleResponseItem();
updateResponseItem.RequestIndex = 0;
updateResponseItem.Response = createResponse;
responses.Add(updateResponseItem);
var retrieveResponseItem = new ExecuteMultipleResponseItem();
retrieveResponseItem.RequestIndex = 1;
retrieveResponseItem.Response = retrieveResponse;
responses.Add(retrieveResponseItem);
var executeMultipleResponse = new ExecuteMultipleResponse
{
Results = new ParameterCollection
{
{ "Responses", responses },
{ "IsFaulted", false }
}
};
// Setup fake org service to return fake response.
sandbox.FakeOrgService.Stub(f => f.Execute(Arg <OrganizationRequest> .Matches(new OrganizationRequestMessageConstraint <ExecuteMultipleRequest>())))
.WhenCalled(x =>
{
var request = ((ExecuteMultipleRequest)x.Arguments[0]);
}).Return(executeMultipleResponse);
// Act
var sut = CrmOperationExecutor.Instance;
dbConnection.Open();
var commandResult = sut.ExecuteOperation(orgCommand);
var results = commandResult.ResultSet;
//var results = sut.ExecuteCommand(orgCommand, System.Data.CommandBehavior.Default);
// Assert
// Should have 1 result, with the 2 output fields - createdon, and contactid
Assert.That(results.ResultCount() == 1);
Assert.That(results.HasColumnMetadata());
var reader = commandResult.GetReader();
Assert.That(reader.HasRows);
Assert.That(reader.FieldCount == 2);
while (reader.Read())
{
Assert.That(reader.GetDateTime(0), NUnit.Framework.Is.EqualTo(modifiedOnDate));
Assert.That(reader.GetGuid(1), NUnit.Framework.Is.EqualTo(expectedId));
}
}
}
public ExecuteMultipleResponse InsertBulkDataOnebyOne(int counter)
{
EntityCollection toInsert = new EntityCollection();
for (int i = 1; i <= counter; i++)
{
Entity Task = new Entity("task");
Task.Attributes["subject"] = "Task : " + i.ToString();
toInsert.Entities.Add(Task);
}
IOrganizationService orgServiceProxy = CRMHelper.ConnectToMSCRM();
ExecuteMultipleResponse responseList = null;
DateTime StartTime = DateTime.Now;
Console.WriteLine("Start One by One Process at : " + StartTime);
int count = 0;
foreach (var entity in toInsert.Entities)
{
// Create an ExecuteMultipleRequest object.
ExecuteMultipleRequest requestWithResults = new ExecuteMultipleRequest()
{
// Assign settings that define execution behavior: continue on error, return responses.
Settings = new ExecuteMultipleSettings()
{
ContinueOnError = true,
ReturnResponses = true
},
// Create an empty organization request collection.
Requests = new OrganizationRequestCollection()
};
if (count == 0)
{
CreateRequest createRequest = new CreateRequest {
Target = entity
};
requestWithResults.Requests.Add(createRequest);
}
count++;
if (responseList == null)
{
ExecuteMultipleResponse responseWithResults = (ExecuteMultipleResponse)orgServiceProxy.Execute(requestWithResults);
responseList = responseWithResults;
}
else
{
ExecuteMultipleResponseItem item = new ExecuteMultipleResponseItem();
try
{
Guid recordId = orgServiceProxy.Create(entity);
item.Fault = null;
item.Response = new OrganizationResponse();
item.Response.Results = new ParameterCollection();
item.Response.Results.Add("id", recordId);
}
catch (Exception ex)
{
item.Fault.Message = ex.Message;
continue;
}
responseList.Responses.Add(item);
}
}
DateTime endTime = DateTime.Now;
Console.WriteLine("Completed One by One Process at : " + endTime);
var diffInSeconds = (endTime - StartTime).TotalSeconds;
Console.WriteLine("Total Time in Second : " + diffInSeconds);
return(responseList);
}
public void BatchTest()
{
Mock <IOrganizationService> orgSvc = null;
Mock <MoqHttpMessagehander> fakHttpMethodHander = null;
ServiceClient cli = null;
testSupport.SetupMockAndSupport(out orgSvc, out fakHttpMethodHander, out cli);
CreateResponse createResponse = new CreateResponse();
createResponse.Results = new ParameterCollection();
createResponse.Results.Add("annotationid", testSupport._DefaultId);
ExecuteMultipleResponseItem responseItem = new ExecuteMultipleResponseItem();
responseItem.Response = createResponse;
responseItem.RequestIndex = 0;
ExecuteMultipleResponseItemCollection responseItems = new ExecuteMultipleResponseItemCollection();
responseItems.Add(responseItem);
ExecuteMultipleResponse executeMultipleResponse = new ExecuteMultipleResponse();
executeMultipleResponse.Results = new ParameterCollection();
executeMultipleResponse.Results.Add("Responses", responseItems);
orgSvc.Setup(req1 => req1.Execute(It.IsAny <ExecuteMultipleRequest>())).Returns(executeMultipleResponse);
// Setup a batch
string BatchRequestName = "TestBatch";
Guid batchid = cli.CreateBatchOperationRequest(BatchRequestName);
// use create operation to setup request
Dictionary <string, DataverseDataTypeWrapper> newFields = new Dictionary <string, DataverseDataTypeWrapper>();
newFields.Add("name", new DataverseDataTypeWrapper("CrudTestAccount", DataverseFieldType.String));
newFields.Add("accountnumber", new DataverseDataTypeWrapper("12345", DataverseFieldType.String));
newFields.Add("telephone1", new DataverseDataTypeWrapper("555-555-5555", DataverseFieldType.String));
newFields.Add("donotpostalmail", new DataverseDataTypeWrapper(true, DataverseFieldType.Boolean));
// issue request as a batch:
Guid result = cli.CreateAnnotation("account", testSupport._DefaultId, newFields, batchid);
Assert.Equal <Guid>(Guid.Empty, result);
OrganizationRequest req = cli.GetBatchRequestAtPosition(batchid, 0);
// Executes the batch request.
cli.ExecuteBatch(batchid);
// Request Batch by name
Guid OperationId = cli.GetBatchOperationIdRequestByName(BatchRequestName);
// Request batch back
RequestBatch reqBatch = cli.GetBatchById(batchid);
Assert.NotNull(reqBatch);
Assert.Equal(BatchRequestName, reqBatch.BatchName);
Assert.True(reqBatch.BatchItems.Count == 1);
// Release batch request
cli.ReleaseBatchInfoById(batchid);
}
