public override void ExecuteExtention(MigrateRecordsRequest request, MigrateRecordsResponse response,
ServiceRequestController controller)
{
var exportService = new ExportXmlService(new XrmRecordService(request.SourceConnection));
var exportedEntities = new List <Entity>();
exportService.ProcessExport(request.RecordTypesToMigrate, request.IncludeNotes, request.IncludeNNRelationshipsBetweenEntities, controller.Controller
, (entity) => exportedEntities.Add(entity)
, (entity) => exportedEntities.Add(entity));
var removeDuplicates = new List <Entity>();
foreach (var entity in exportedEntities)
{
if (!removeDuplicates.Any(e => e.Id == entity.Id && e.LogicalName == entity.LogicalName))
{
removeDuplicates.Add(entity);
}
}
var importService = new DataImportService(new XrmRecordService(request.TargetConnection));
var matchOption = request.MatchByName ? DataImportService.MatchOption.PrimaryKeyThenName : DataImportService.MatchOption.PrimaryKeyOnly;
var dataImportResponse = importService.DoImport(removeDuplicates, controller, request.MaskEmails, matchOption: matchOption, includeOwner: request.IncludeOwner);
response.ConnectionMigratedInto = request.TargetConnection;
response.LoadDataImport(dataImportResponse);
response.Message = "The Record Migration Has Completed";
}
public void DeploymentImportXmlMultipleFilesForSameRecordTest()
{
var type = Entities.jmcg_testentity;
PrepareTests();
var workFolder = ClearFilesAndData(type);
var recordName1 = CreateTestRecord(TestEntityType, new Dictionary <string, object>
{
{ Fields.jmcg_testentity_.jmcg_name, "TestName1" }
});
var recordName2 = CreateTestRecord(TestEntityType, new Dictionary <string, object>
{
{ Fields.jmcg_testentity_.jmcg_name, "TestName2" }
});
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);
recordName1.SetField(Fields.jmcg_testentity_.jmcg_name, "TestName1 - Updated!");
recordName1 = UpdateFieldsAndRetreive(recordName1, Fields.jmcg_testentity_.jmcg_name);
exportResponse = exportService.Execute(exportRequest, new ServiceRequestController(Controller));
Assert.IsTrue(exportResponse.Success);
Assert.AreEqual(3, FileUtility.GetFiles(workFolder).Count());
var app = CreateAndLoadTestApplication <ImportXmlModule>();
var importRequest = new ImportXmlRequest
{
Folder = new Folder(workFolder)
};
var dialog = app.NavigateToDialog <ImportXmlModule, ImportXmlDialog>();
var entryViewmodel = app.GetSubObjectEntryViewModel(dialog);
//select the excel file with the errors and submit form
app.EnterAndSaveObject(importRequest, entryViewmodel);
//check validation results displayed
var validationResults = dialog.Controller.UiItems.First() as ObjectDisplayViewModel;
Assert.IsNotNull(validationResults);
Assert.IsTrue(validationResults.GetObject() is ImportXmlValidationDialog.DuplicateImportXmlRecords);
Assert.AreEqual(2, ((ImportXmlValidationDialog.DuplicateImportXmlRecords)validationResults.GetObject()).Duplicates.Count());
}
public void DeploymentImportXmlMaskEmailsTest()
{
PrepareTests();
var workFolder = ClearFilesAndData();
DeleteAll(Entities.account);
var entity = CreateAccount();
Assert.IsFalse(entity.GetStringField(Fields.account_.emailaddress1).Contains("_AT_"));
var accountsExport = new ExportRecordType()
{
Type = ExportType.AllRecords,
RecordType = new RecordType(Entities.account, Entities.account)
};
var exportRequest = new ExportXmlRequest
{
Folder = new Folder(workFolder),
RecordTypesToExport = new[] { accountsExport }
};
var exportService = new ExportXmlService(XrmRecordService);
var ecxportResponse = exportService.Execute(exportRequest, new ServiceRequestController(Controller));
Assert.IsFalse(ecxportResponse.HasError);
var importRequest = new ImportXmlRequest
{
Folder = new Folder(workFolder),
MaskEmails = true
};
var application = CreateAndLoadTestApplication <ImportXmlModule>();
var immportResponse = application.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest);
Assert.IsFalse(immportResponse.HasError);
entity = XrmService.GetFirst(Entities.account);
Assert.IsTrue(entity.GetStringField(Fields.account_.emailaddress1).Contains("_AT_"));
importRequest = new ImportXmlRequest
{
Folder = new Folder(workFolder),
MaskEmails = false
};
application = CreateAndLoadTestApplication <ImportXmlModule>();
immportResponse = application.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest);
Assert.IsFalse(immportResponse.HasError);
entity = XrmService.GetFirst(Entities.account);
Assert.IsFalse(entity.GetStringField(Fields.account_.emailaddress1).Contains("_AT_"));
}
public void DeploymentImportXmlCreateMultipleWithSameNameTest()
{
var type = Entities.jmcg_testentity;
PrepareTests();
var workFolder = ClearFilesAndData(type);
var recordName1a = CreateTestRecord(TestEntityType, new Dictionary <string, object>
{
{ Fields.jmcg_testentity_.jmcg_name, "TestName1" }
});
var recordName1b = CreateTestRecord(TestEntityType, new Dictionary <string, object>
{
{ Fields.jmcg_testentity_.jmcg_name, "TestName1" }
});
var recordName2 = CreateTestRecord(TestEntityType, new Dictionary <string, object>
{
{ Fields.jmcg_testentity_.jmcg_name, "TestName2" }
});
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);
DeleteAll(type);
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 records = XrmRecordService.RetrieveAll(type, new string[0]);
Assert.AreEqual(3, records.Count());
}
public override void ExecuteExtention(MigrateRecordsRequest request, MigrateRecordsResponse response,
LogController controller)
{
var exportService = new ExportXmlService(new XrmRecordService(request.SourceConnection));
var exportedEntities = new List <Entity>();
exportService.ProcessExport(request.RecordTypesToMigrate, request.IncludeNotes, request.IncludeNNRelationshipsBetweenEntities, controller
, (entity) => exportedEntities.Add(entity)
, (entity) => exportedEntities.Add(entity));
var importService = new ImportXmlService(new XrmRecordService(request.TargetConnection));
importService.DoImport(exportedEntities, controller, request.MaskEmails);
}
public void DeploymentImportXmlMultipleTest()
{
PrepareTests();
var types = new[] { Entities.jmcg_testentitytwo, Entities.jmcg_testentitythree, Entities.jmcg_testentity };
var workFolder = ClearFilesAndData(types);
var importService = new ImportXmlService(XrmRecordService);
var createRecords = new List <Entity>();
foreach (var type in types)
{
createRecords.Add(CreateTestRecord(type, importService));
}
var exportService = new ExportXmlService(XrmRecordService);
var exportRequest = new ExportXmlRequest
{
Folder = new Folder(workFolder),
RecordTypesToExport = types.Select(t => new ExportRecordType()
{
RecordType = new RecordType(t, t)
})
};
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);
}
public void DeploymentImportXmlKnowledgeArticleTest()
{
PrepareTests();
var type = "knowledgearticle";
if (XrmRecordService.RecordTypeExists(type))
{
DeleteAll(type);
var workFolder = ClearFilesAndData();
//create or get a knowledge article
var knowledgeArticle = XrmService.GetFirst(type, "articlepublicnumber", PopulateStringValue);
if (knowledgeArticle == null)
{
knowledgeArticle = CreateRecordAllFieldsPopulated("knowledgearticle");
}
//export to xml
var export = new ExportRecordType()
{
Type = ExportType.AllRecords,
RecordType = new RecordType(type, type)
};
var exportRequest = new ExportXmlRequest
{
Folder = new Folder(workFolder),
RecordTypesToExport = new[] { export }
};
var exportService = new ExportXmlService(XrmRecordService);
var ecxportResponse = exportService.Execute(exportRequest, new ServiceRequestController(Controller));
Assert.IsFalse(ecxportResponse.HasError);
//okay we will delete then create one with the same article number
XrmService.Delete(knowledgeArticle);
knowledgeArticle = CreateRecordAllFieldsPopulated("knowledgearticle");
var kaCount = XrmService.RetrieveAllEntityType(type).Count();
//import should match them
var importRequest = new ImportXmlRequest
{
Folder = new Folder(workFolder),
MaskEmails = true
};
var application = CreateAndLoadTestApplication <ImportXmlModule>();
var immportResponse = application.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest);
Assert.IsFalse(immportResponse.HasError);
Assert.AreEqual(kaCount, XrmService.RetrieveAllEntityType(type).Count());
//now lets just verify for create (delete it prioor to import)
XrmService.Delete(knowledgeArticle);
importRequest = new ImportXmlRequest
{
Folder = new Folder(workFolder),
MaskEmails = true
};
application = CreateAndLoadTestApplication <ImportXmlModule>();
immportResponse = application.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest);
Assert.IsFalse(immportResponse.HasError);
Assert.AreEqual(kaCount, XrmService.RetrieveAllEntityType(type).Count());
}
}
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, new ServiceRequestController(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, new ServiceRequestController(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 DeploymentImportXmlPortalTypeConfigTest()
{
PrepareTests();
var types = new[] { Entities.jmcg_testentitytwo, Entities.jmcg_testentitythree, Entities.jmcg_testentity };
var workFolder = ClearFilesAndData(types);
//okay this script is to verify importing microsoft portal types
//which aren't so simple as to just match by name
//as for example webpage have a root page, and language specific page(s)
//create a web page with an access control rule
RecreatePortalData();
var parentWebPage = XrmService.RetrieveAllAndClauses(Entities.adx_webpage, new[]
{
new ConditionExpression(Fields.adx_webpage_.adx_rootwebpageid, ConditionOperator.Null)
}).First();
//export to xml
var exportApp = new ExportXmlService(XrmRecordService);// CreateAndLoadTestApplication<ExportXmlModule>();
var exportRequest = new ExportXmlRequest
{
Folder = new Folder(workFolder),
IncludeNNRelationshipsBetweenEntities = true,
RecordTypesToExport = new[]
{
new ExportRecordType()
{
RecordType = new RecordType(Entities.adx_webrole, Entities.adx_webrole)
},
new ExportRecordType()
{
RecordType = new RecordType(Entities.adx_webpage, Entities.adx_webpage)
},
new ExportRecordType()
{
RecordType = new RecordType(Entities.adx_websitelanguage, Entities.adx_websitelanguage)
},
new ExportRecordType()
{
RecordType = new RecordType(Entities.adx_webpageaccesscontrolrule, Entities.adx_webpageaccesscontrolrule)
},
new ExportRecordType()
{
RecordType = new RecordType(Entities.adx_webform, Entities.adx_webform)
},
new ExportRecordType()
{
RecordType = new RecordType(Entities.adx_webformstep, Entities.adx_webformstep)
},
new ExportRecordType()
{
RecordType = new RecordType(Entities.adx_webformmetadata, Entities.adx_webformmetadata)
},
}
};
var exportResponse = exportApp.Execute(exportRequest, new ServiceRequestController(Controller));
Assert.IsFalse(exportResponse.HasError);
//lets recreate all the web page data so the ids don't match when importing
//this will verify it matches them based on the root/unique field configs in XrmTypesConfig
RecreatePortalData();
var application = CreateAndLoadTestApplication <ImportXmlModule>();
var importRequest = new ImportXmlRequest
{
Folder = new Folder(workFolder)
};
var importResponse = application.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest);
Assert.IsFalse(importResponse.HasError);
VerifyWebPageRecords();
//lets just do several other things which will verify some other matching logic
//delete the root page in the import files - this will verify the language specific page
//will correctly resolve its parent independently
//despite it having a different id and not being part of the import
var parentWebPageFile = FileUtility.GetFiles(workFolder).First(f => f.Contains(parentWebPage.Id.ToString().Replace("-", "_")));
File.Delete(parentWebPageFile);
importResponse = application.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest);
Assert.IsFalse(importResponse.HasError);
VerifyWebPageRecords();
//delete both web pages in the import files - this will verify the web page access contorl rule
//will correctly resolve its parent independently
//despite it having a different id and not being part of the import
var webPageFile = FileUtility.GetFiles(workFolder).Where(f => f.Contains(Entities.adx_webpage + "_"));
foreach (var file in webPageFile)
{
File.Delete(file);
}
importResponse = application.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest);
Assert.IsFalse(importResponse.HasError);
VerifyWebPageRecords();
//lets do the same but delete the web page access control rule
//first to verify it also matches the parent when creating
XrmService.Delete(XrmService.GetFirst(Entities.adx_webpageaccesscontrolrule));
importResponse = application.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest);
Assert.IsFalse(importResponse.HasError);
VerifyWebPageRecords();
}
public void DeploymentImportXmlProductsAndPricingTest()
{
PrepareTests();
//created csv files for all the relevant data so lets just hook into that to generate test data
GenerateProductData();
//export to xml
var exportApp = new ExportXmlService(XrmRecordService);// CreateAndLoadTestApplication<ExportXmlModule>();
var exportRequest = new ExportXmlRequest
{
Folder = new Folder(WorkFolder),
IncludeNNRelationshipsBetweenEntities = true,
RecordTypesToExport = new[]
{
new ExportRecordType()
{
RecordType = new RecordType(Entities.product, Entities.product)
},
new ExportRecordType()
{
RecordType = new RecordType(Entities.pricelevel, Entities.pricelevel)
},
new ExportRecordType()
{
RecordType = new RecordType(Entities.productpricelevel, Entities.productpricelevel)
},
new ExportRecordType()
{
RecordType = new RecordType(Entities.uom, Entities.uom)
},
new ExportRecordType()
{
RecordType = new RecordType(Entities.uomschedule, Entities.uomschedule)
},
}
};
//verify no errors
var exportResponse = exportApp.Execute(exportRequest, new ServiceRequestController(Controller));
Assert.IsFalse(exportResponse.HasError);
//delete all the data so when we import the xml it is creating new
DeleteProductData();
//import the xml
var application = CreateAndLoadTestApplication <ImportXmlModule>();
var importRequest = new ImportXmlRequest
{
Folder = new Folder(WorkFolder)
};
//verify no errors
var importResponse = application.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest);
Assert.IsFalse(importResponse.HasError);
//okay lets get the last created price list item
var query = XrmService.BuildQuery(Entities.productpricelevel, null, null, null);
query.Orders.Add(new OrderExpression(Fields.productpricelevel_.createdon, OrderType.Descending));
var latestPriceListItem = XrmService.RetrieveFirst(query);
//verify it has a price
var initialPrice = latestPriceListItem.GetMoneyValue(Fields.productpricelevel_.amount);
Assert.IsTrue(initialPrice > 0);
//now lets set it something else so we can verify it gets updated after the second run
latestPriceListItem.SetMoneyField(Fields.productpricelevel_.amount, initialPrice.Value + 1);
latestPriceListItem = UpdateFieldsAndRetreive(latestPriceListItem, Fields.productpricelevel_.amount);
//rerun the import
application = CreateAndLoadTestApplication <ImportXmlModule>();
importRequest = new ImportXmlRequest
{
Folder = new Folder(WorkFolder)
};
importResponse = application.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest);
Assert.IsFalse(importResponse.HasError);
//verify the price list item we updated is changed
latestPriceListItem = Refresh(latestPriceListItem);
Assert.AreEqual(initialPrice, latestPriceListItem.GetMoneyValue(Fields.productpricelevel_.amount));
}
private void CreateDeploymentPackage(CreatePackageRequest request, ServiceRequestController controller, CreatePackageResponse response)
{
var folderPath = request.FolderPath.FolderPath;
var tasksDone = 0;
var totalTasks = 4;
var xrmRecordService = XrmRecordService;
var service = xrmRecordService.XrmService;
var solution = service.Retrieve(Entities.solution, new Guid(request.Solution.Id));
tasksDone++;
if (solution.GetStringField(Fields.solution_.version) != request.ThisReleaseVersion)
{
controller.UpdateProgress(tasksDone, totalTasks, "Setting Release Version " + request.ThisReleaseVersion);
solution.SetField(Fields.solution_.version, request.ThisReleaseVersion);
service.Update(solution, new[] { Fields.solution_.version });
}
controller.UpdateProgress(tasksDone, totalTasks, "Exporting Solution " + request.Solution.Name);
var uniqueName = (string)solution.GetStringField(Fields.solution_.uniquename);
var req = new ExportSolutionRequest();
req.Managed = request.ExportAsManaged;
req.SolutionName = uniqueName;
var exportResponse = (ExportSolutionResponse)service.Execute(req);
var version = solution.GetStringField(Fields.solution_.version);
var versionText = version == null ? null : version.Replace(".", "_");
var fileName = string.Format("{0}_{1}{2}.zip", uniqueName, versionText,
request.ExportAsManaged ? "_managed" : null);
FileUtility.WriteToFile(folderPath, fileName, exportResponse.ExportSolutionFile);
++tasksDone;
if (request.DataToInclude != null && request.DataToInclude.Any())
{
controller.UpdateProgress(tasksDone, totalTasks, "Exporting Data " + request.Solution.Name);
var dataExportService = new ExportXmlService(xrmRecordService);
dataExportService.ExportXml(request.DataToInclude,
new Folder(GetDataExportFolder(folderPath)), request.IncludeNotes,
request.IncludeNNRelationshipsBetweenEntities, controller.Controller);
}
tasksDone++;
if (solution.GetStringField(Fields.solution_.version) != request.SetVersionPostRelease)
{
controller.UpdateProgress(tasksDone, totalTasks, "Setting New Solution Version " + request.SetVersionPostRelease);
solution.SetField(Fields.solution_.version, request.SetVersionPostRelease);
service.Update(solution, new[] { Fields.solution_.version });
}
if (request.DeployPackageInto != null)
{
if (response.HasError)
{
throw new Exception("Package Deployment Aborted Due To Errors During Creating");
}
else
{
var deployRequest = new DeployPackageRequest
{
FolderContainingPackage = request.FolderPath,
Connection = request.DeployPackageInto
};
var deployService = new DeployPackageService();
var deployPackageResponse = new DeployPackageResponse();
deployService.ExecuteExtention(deployRequest, deployPackageResponse, controller);
response.LoadDeployPackageResponse(deployPackageResponse);
}
}
}
