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