private IEnumerable <string> GetUpdateFields(string type, ImportXmlService importService)
{
var updateFields = XrmService.GetFields(type).Where(f => DataImportContainer.IsIncludeField(f, type, importService.XrmRecordService, false));
return(updateFields);
}
public void DeploymentImportXmlTypesTest()
{
var query = new QueryExpression();
PrepareTests();
var types = new[] { Entities.jmcg_testentitytwo, Entities.jmcg_testentitythree, Entities.jmcg_testentity };
var workFolder = ClearFilesAndData(types);
var importService = new ImportXmlService(XrmRecordService);
var t1_1 = CreateTestRecord(Entities.jmcg_testentity, importService);
var t1_2 = CreateTestRecord(Entities.jmcg_testentity, importService);
var t1_3 = CreateTestRecord(Entities.jmcg_testentity, importService);
var t2_1 = CreateTestRecord(Entities.jmcg_testentitytwo, importService);
var t2_2 = CreateTestRecord(Entities.jmcg_testentitytwo, importService);
var t2_3 = CreateTestRecord(Entities.jmcg_testentitytwo, importService);
var t3_1 = CreateTestRecord(Entities.jmcg_testentitythree, importService);
var t3_2 = CreateTestRecord(Entities.jmcg_testentitythree, importService);
var t3_3 = CreateTestRecord(Entities.jmcg_testentitythree, importService);
var t1RequestAll = new ExportRecordType()
{
Type = ExportType.AllRecords,
RecordType = new RecordType(Entities.jmcg_testentity, Entities.jmcg_testentity)
};
var t2RequestFetch = new ExportRecordType()
{
Type = ExportType.FetchXml,
RecordType = new RecordType(Entities.jmcg_testentitytwo, Entities.jmcg_testentitytwo),
FetchXml = @"<fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='false' count='2' >
<entity name='" + Entities.jmcg_testentitytwo + @"'>
</entity>
</fetch>"
};
var t3RequestSpecific = new ExportRecordType()
{
Type = ExportType.SpecificRecords,
RecordType = new RecordType(Entities.jmcg_testentitythree, Entities.jmcg_testentitythree),
SpecificRecordsToExport = new[]
{
new LookupSetting()
{
Record = new Lookup(Entities.jmcg_testentitythree, t3_1.Id.ToString(), "t3_1")
},
new LookupSetting()
{
Record = new Lookup(Entities.jmcg_testentitythree, t3_2.Id.ToString(), "t3_2")
},
}
};
var exportRequest = new ExportXmlRequest
{
Folder = new Folder(workFolder),
RecordTypesToExport = new[] { t1RequestAll, t2RequestFetch, t3RequestSpecific }
};
var exportService = new ExportXmlService(XrmRecordService);
var exportResponse = exportService.Execute(exportRequest, Controller);
Assert.IsFalse(exportResponse.HasError);
var entities = importService.LoadEntitiesFromXmlFiles(workFolder);
Assert.AreEqual(7, entities.Count());
var importRequest = new ImportXmlRequest
{
Folder = new Folder(workFolder)
};
var importResponse = importService.Execute(importRequest, Controller);
Assert.IsFalse(importResponse.HasError);
}
public void DeploymentImportXmlSimpleTest()
{
var type = TestEntityType;
PrepareTests();
var workFolder = ClearFilesAndData(type);
var importService = new ImportXmlService(XrmRecordService);
var fields = GetFields(type, importService);
var updateFields = GetUpdateFields(type, importService);
var record = CreateTestRecord(type, importService);
var createdEntity = XrmService.Retrieve(record.LogicalName, record.Id);
var exportService = new ExportXmlService(XrmRecordService);
var exportRequest = new ExportXmlRequest
{
Folder = new Folder(workFolder),
RecordTypesToExport = new[] { new ExportRecordType()
{
RecordType = new RecordType(TestEntityType, TestEntityType)
} }
};
var exportResponse = exportService.Execute(exportRequest, new ServiceRequestController(Controller));
Assert.IsTrue(exportResponse.Success);
XrmService.Delete(record);
var application = CreateAndLoadTestApplication <ImportXmlModule>();
var importRequest = new ImportXmlRequest
{
Folder = new Folder(workFolder)
};
var response = application.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest);
Assert.IsFalse(response.HasError);
var createdRecord = XrmService.Retrieve(type, createdEntity.Id);
foreach (var updateField in updateFields)
{
Assert.IsTrue(XrmEntity.FieldsEqual(createdEntity.GetField(updateField),
createdRecord.GetField(updateField)));
}
foreach (var field in fields)
{
record.SetField(field, CreateNewEntityFieldValue(field, type, record));
}
XrmService.Update(record);
record = XrmService.Retrieve(record.LogicalName, record.Id);
importRequest = new ImportXmlRequest
{
Folder = new Folder(workFolder)
};
application = CreateAndLoadTestApplication <ImportXmlModule>();
response = application.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest);
Assert.IsFalse(response.HasError);
var updatedRecord = XrmService.Retrieve(type, record.Id);
foreach (var updateField in updateFields)
{
Assert.IsTrue(XrmEntity.FieldsEqual(createdEntity.GetField(updateField),
updatedRecord.GetField(updateField)));
}
}
public void DeploymentImportXmlAssociationsAndNotesTest()
{
PrepareTests();
var types = new[] { Entities.jmcg_testentity };
var workFolder = ClearFilesAndData(types);
var importService = new ImportXmlService(XrmRecordService);
var createRecords = new List <Entity>();
foreach (var type in types)
{
for (var i = 0; i < 2; i++)
{
createRecords.Add(CreateTestRecord(type, importService));
}
}
//if throws error ensure the test entity allows notes
XrmService.Associate(Relationships.jmcg_testentity_.jmcg_testentity_jmcg_testentity.Name, Entities.jmcg_testentity, createRecords[0].Id, true, Entities.jmcg_testentity, createRecords[1].Id);
var aNote = CreateTestRecord(Entities.annotation, new Dictionary <string, object>
{
{ Fields.annotation_.objectid, createRecords[0].ToEntityReference() },
{ Fields.annotation_.subject, "Test Scripting" },
{ Fields.annotation_.notetext, "Just For Importing Testing" },
});
var exportService = new ExportXmlService(XrmRecordService);
var exportRequest = new ExportXmlRequest
{
Folder = new Folder(workFolder),
RecordTypesToExport = types.Select(t => new ExportRecordType()
{
RecordType = new RecordType(t, t)
}),
IncludeNNRelationshipsBetweenEntities = true,
IncludeNotes = true
};
var response = exportService.Execute(exportRequest, new ServiceRequestController(Controller));
Assert.IsFalse(response.HasError);
foreach (var type in types)
{
DeleteAll(type);
}
var application = CreateAndLoadTestApplication <ImportXmlModule>();
var importRequest = new ImportXmlRequest
{
Folder = new Folder(workFolder)
};
var importResponse = application.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest);
Assert.IsFalse(importResponse.HasError);
var rMetadata = XrmService.GetRelationshipMetadata(Relationships.jmcg_testentity_.jmcg_testentity_jmcg_testentity.Name);
foreach (var record in createRecords)
{
var loaded = Refresh(record);
if (createRecords[0].Id == loaded.Id)
{
var notes = XrmService.RetrieveAllAndClauses(Entities.annotation, new[]
{
new ConditionExpression(Fields.annotation_.objectid, ConditionOperator.Equal, loaded.Id)
});
Assert.AreEqual(1, notes.Count());
var associated = XrmService.GetAssociatedIds(rMetadata.SchemaName, rMetadata.Entity1IntersectAttribute, loaded.Id, rMetadata.Entity2IntersectAttribute);
Assert.AreEqual(1, associated.Count());
Assert.AreEqual(createRecords[1].Id, associated.First());
}
}
}
public void DeploymentExportXmlModuleTestExportWithSpecificValues()
{
DeleteAll(Entities.account);
var account = CreateRecordAllFieldsPopulated(Entities.account);
FileUtility.DeleteFiles(TestingFolder);
var accountRecord = XrmRecordService.Get(account.LogicalName, account.Id.ToString());
var application = CreateAndLoadTestApplication <ExportXmlModule>();
application.AddModule <SavedRequestModule>();
var instance = new ExportXmlRequest();
instance.IncludeNotes = true;
instance.IncludeNNRelationshipsBetweenEntities = true;
instance.Folder = new Folder(TestingFolder);
instance.RecordTypesToExport = new[]
{
new ExportRecordType()
{
Type = ExportType.AllRecords,
RecordType = new RecordType(Entities.account, Entities.account),
SpecificRecordsToExport = new LookupSetting[0]
}
};
var entryForm = application.NavigateToDialogModuleEntryForm <ExportXmlModule, ExportXmlDialog>();
application.EnterObject(instance, entryForm);
var recordTypesGrid = entryForm.GetEnumerableFieldViewModel(nameof(ExportXmlRequest.RecordTypesToExport));
var row = recordTypesGrid.GridRecords.First();
row.EditRow();
var exportTypeEntry = entryForm.ChildForms.First() as RecordEntryFormViewModel;
Assert.IsNotNull(exportTypeEntry);
exportTypeEntry.LoadFormSections();
//okay so at this point we aere in the export type form
//need to add a row to the explicit value grid which will open the form
var specificValuesGrid = exportTypeEntry.GetEnumerableFieldViewModel(nameof(ExportRecordType.ExplicitValuesToSet));
specificValuesGrid.AddRow();
var specificValueEntry = exportTypeEntry.ChildForms.First() as RecordEntryFormViewModel;
Assert.IsNotNull(specificValueEntry);
specificValueEntry.LoadFormSections();
var fieldSelectionViewModel = specificValueEntry.GetRecordFieldFieldViewModel(nameof(ExportRecordType.ExplicitFieldValues.FieldToSet));
var clearValueViewModel = specificValueEntry.GetBooleanFieldFieldViewModel(nameof(ExportRecordType.ExplicitFieldValues.ClearValue));
//select several field types and verify the field control changes to the correct type for that field
fieldSelectionViewModel.Value = fieldSelectionViewModel.ItemsSource.First(f => f.Key == Fields.account_.customertypecode);
Assert.IsTrue(specificValueEntry.GetFieldViewModel(nameof(ExportRecordType.ExplicitFieldValues.ValueToSet)) is PicklistFieldViewModel);
Assert.IsTrue(specificValueEntry.GetPicklistFieldFieldViewModel(nameof(ExportRecordType.ExplicitFieldValues.ValueToSet)).ItemsSource.Any());
fieldSelectionViewModel.Value = fieldSelectionViewModel.ItemsSource.First(f => f.Key == Fields.account_.primarycontactid);
Assert.IsTrue(specificValueEntry.GetFieldViewModel(nameof(ExportRecordType.ExplicitFieldValues.ValueToSet)) is LookupFieldViewModel);
specificValueEntry.GetLookupFieldFieldViewModel(nameof(ExportRecordType.ExplicitFieldValues.ValueToSet)).Search();
Assert.IsTrue(specificValueEntry.GetLookupFieldFieldViewModel(nameof(ExportRecordType.ExplicitFieldValues.ValueToSet)).LookupGridViewModel.DynamicGridViewModel.GridRecords.Any());
//verify the field value hidden if we select to clear the value
clearValueViewModel.Value = true;
Assert.IsFalse(specificValueEntry.GetFieldViewModel(nameof(ExportRecordType.ExplicitFieldValues.ValueToSet)).IsVisible);
clearValueViewModel.Value = false;
//okay so this is the specific field and value we will set
var fakeExplicitExportValue = "fakeExplicitExportValue";
fieldSelectionViewModel.Value = fieldSelectionViewModel.ItemsSource.First(f => f.Key == Fields.account_.address1_line1);
Assert.IsTrue(specificValueEntry.GetFieldViewModel(nameof(ExportRecordType.ExplicitFieldValues.ValueToSet)) is StringFieldViewModel);
var descriptionViewModel = specificValueEntry.GetStringFieldFieldViewModel(nameof(ExportRecordType.ExplicitFieldValues.ValueToSet));
descriptionViewModel.Value = fakeExplicitExportValue;
Assert.IsTrue(specificValueEntry.Validate());
specificValueEntry.SaveButtonViewModel.Invoke();
Assert.IsFalse(exportTypeEntry.ChildForms.Any());
//okay lets add an explicit lookup value as well
specificValuesGrid = exportTypeEntry.GetEnumerableFieldViewModel(nameof(ExportRecordType.ExplicitValuesToSet));
specificValuesGrid.AddRow();
specificValueEntry = exportTypeEntry.ChildForms.First() as RecordEntryFormViewModel;
Assert.IsNotNull(specificValueEntry);
specificValueEntry.LoadFormSections();
fieldSelectionViewModel = specificValueEntry.GetRecordFieldFieldViewModel(nameof(ExportRecordType.ExplicitFieldValues.FieldToSet));
fieldSelectionViewModel.Value = fieldSelectionViewModel.ItemsSource.First(f => f.Key == Fields.account_.primarycontactid);
var lookupFieldViewModel = specificValueEntry.GetLookupFieldFieldViewModel(nameof(ExportRecordType.ExplicitFieldValues.ValueToSet));
lookupFieldViewModel.Search();
Assert.IsTrue(lookupFieldViewModel.LookupGridViewModel.DynamicGridViewModel.GridRecords.Any());
lookupFieldViewModel.LookupGridViewModel.DynamicGridViewModel.SelectedRow = lookupFieldViewModel.LookupGridViewModel.DynamicGridViewModel.GridRecords.First();
lookupFieldViewModel.OnRecordSelected(lookupFieldViewModel.LookupGridViewModel.DynamicGridViewModel.GridRecords.First().Record);
Assert.IsTrue(specificValueEntry.Validate());
specificValueEntry.SaveButtonViewModel.Invoke();
Assert.IsFalse(exportTypeEntry.ChildForms.Any());
//okay lets add an explicit picklist value as well
specificValuesGrid = exportTypeEntry.GetEnumerableFieldViewModel(nameof(ExportRecordType.ExplicitValuesToSet));
specificValuesGrid.AddRow();
specificValueEntry = exportTypeEntry.ChildForms.First() as RecordEntryFormViewModel;
Assert.IsNotNull(specificValueEntry);
specificValueEntry.LoadFormSections();
fieldSelectionViewModel = specificValueEntry.GetRecordFieldFieldViewModel(nameof(ExportRecordType.ExplicitFieldValues.FieldToSet));
fieldSelectionViewModel.Value = fieldSelectionViewModel.ItemsSource.First(f => f.Key == Fields.account_.customertypecode);
var picklistFieldViewModel = specificValueEntry.GetPicklistFieldFieldViewModel(nameof(ExportRecordType.ExplicitFieldValues.ValueToSet));
Assert.IsTrue(picklistFieldViewModel.ItemsSource.Any());
picklistFieldViewModel.Value = picklistFieldViewModel.ItemsSource.First();
Assert.IsTrue(specificValueEntry.Validate());
specificValueEntry.SaveButtonViewModel.Invoke();
Assert.IsFalse(exportTypeEntry.ChildForms.Any());
Assert.IsTrue(exportTypeEntry.Validate());
exportTypeEntry.SaveButtonViewModel.Invoke();
Assert.IsFalse(entryForm.ChildForms.Any());
//okay lets verify save and load object as well
//initially the dynamic object property for setting san explicit type
//did not seralise due to known types in the serialiser
//lets remove any saved requests as this part relies on it being the only saved one
var savedRequests = new SavedSettings()
{
SavedRequests = new object[0]
};
var settingsManager = application.Controller.ResolveType <ISettingsManager>();
settingsManager.SaveSettingsObject(savedRequests, typeof(ExportXmlRequest));
//trigger save request
var saveRequestButton = entryForm.GetButton("SAVEREQUEST");
saveRequestButton.Invoke();
//enter and save details
var saveRequestForm = application.GetSubObjectEntryViewModel(entryForm);
var detailsEntered = new SaveAndLoadFields()
{
Name = "TestName"
};
application.EnterAndSaveObject(detailsEntered, saveRequestForm);
Assert.IsFalse(entryForm.ChildForms.Any());
Assert.IsFalse(entryForm.LoadingViewModel.IsLoading);
//trigger load request
var loadRequestButton = entryForm.GetButton("LOADREQUEST");
loadRequestButton.Invoke();
var loadRequestForm = application.GetSubObjectEntryViewModel(entryForm);
//select and load the saved request
var subGrid = loadRequestForm.GetEnumerableFieldViewModel(nameof(SavedSettings.SavedRequests));
Assert.IsTrue(subGrid.GridRecords.Count() == 1);
subGrid.GridRecords.First().IsSelected = true;
var loadButton = subGrid.DynamicGridViewModel.GetButton("LOADREQUEST");
loadButton.Invoke();
//verify loads
Assert.IsFalse(entryForm.ChildForms.Any());
Assert.IsFalse(entryForm.LoadingViewModel.IsLoading);
//this one will invoke the export
Assert.IsTrue(entryForm.Validate());
entryForm.SaveButtonViewModel.Invoke();
//verify the exported records had the explicit value we set in them
var importServoice = new ImportXmlService(XrmRecordService);
var loadEntities = importServoice.LoadEntitiesFromXmlFiles(TestingFolder);
foreach (var entity in loadEntities)
{
Assert.AreEqual(fakeExplicitExportValue, entity.GetStringField(Fields.account_.address1_line1));
}
}
public void DeploymentExportXmlModuleTest()
{
//script 2 exports
//first one with only one specific field
var account = CreateAccount();
FileUtility.DeleteFiles(TestingFolder);
var application = CreateAndLoadTestApplication <ExportXmlModule>();
var instance = new ExportXmlRequest();
instance.IncludeNotes = true;
instance.IncludeNNRelationshipsBetweenEntities = true;
instance.Folder = new Folder(TestingFolder);
instance.RecordTypesToExport = new[]
{
new ExportRecordType()
{
Type = ExportType.AllRecords,
RecordType = new RecordType(Entities.account, Entities.account),
IncludeAllFields = false,
IncludeOnlyTheseFields = new [] { new FieldSetting()
{
RecordField = new RecordField(Fields.account_.createdby, Fields.account_.createdby)
} }
}
};
var response = application.NavigateAndProcessDialog <ExportXmlModule, ExportXmlDialog, ExportXmlResponse>(instance);
Assert.IsFalse(response.HasError);
Assert.IsTrue(FileUtility.GetFiles(TestingFolder).Any());
var importXmlService = new ImportXmlService(XrmRecordService);
var loaded = importXmlService.LoadEntitiesFromXmlFiles(TestingFolder);
foreach (var item in loaded)
{
Assert.IsNull(item.GetField(Fields.account_.createdon));
Assert.IsNotNull(item.GetField(Fields.account_.createdby));
Assert.IsNotNull(item.GetField(Fields.account_.name));
}
FileUtility.DeleteFiles(TestingFolder);
//first verify when all fields selected
application = CreateAndLoadTestApplication <ExportXmlModule>();
instance = new ExportXmlRequest();
instance.IncludeNotes = true;
instance.IncludeNNRelationshipsBetweenEntities = true;
instance.Folder = new Folder(TestingFolder);
instance.RecordTypesToExport = new[]
{
new ExportRecordType()
{
Type = ExportType.AllRecords,
RecordType = new RecordType(Entities.account, Entities.account),
IncludeAllFields = true
}
};
response = application.NavigateAndProcessDialog <ExportXmlModule, ExportXmlDialog, ExportXmlResponse>(instance);
Assert.IsFalse(response.HasError);
Assert.IsTrue(FileUtility.GetFiles(TestingFolder).Any());
loaded = importXmlService.LoadEntitiesFromXmlFiles(TestingFolder);
foreach (var item in loaded)
{
Assert.IsNotNull(item.GetField(Fields.account_.createdon));
Assert.IsNotNull(item.GetField(Fields.account_.createdby));
Assert.IsNotNull(item.GetField(Fields.account_.name));
}
}
private IEnumerable <string> GetUpdateFields(string type, ImportXmlService importService)
{
var updateFields = XrmService.GetFields(type).Where(f => importService.IsIncludeField(f, type));
return(updateFields);
}
