/// <summary>
/// Imports the data sets and returns a map of old ids to new ids.
/// </summary>
/// <param name="sessionData">The session data.</param>
/// <param name="migrationData">Contains the data sets to import.</param>
/// <param name="validationResults">A list of validation results.</param>
/// <param name="migrationResults">A list to which import results will be appended.</param>
/// <returns>A map of data set ids, where the old id is the key and the new id is the value.</returns>
private Dictionary<string, string> ImportDataSets(SessionData sessionData, MigrationData migrationData, MigrationDataResults validationResults, MigrationDataResults migrationResults)
{
Dictionary<string, string> map = new Dictionary<string, string>();
GenericDataSetList dataSetList = this.manager.GetDataSetList(sessionData.UserId, false);
foreach (GenericDataSet dataSet in migrationData.DataSets)
{
var dataSetId = dataSet.Id;
if (!validationResults.GetNotificationsFor(dataSet).CanImport)
{
migrationResults.AddNotification(dataSet, MessageType.Information, string.Format(Messages.Import_DataSetSkipped, dataSet.Name));
continue;
}
// Match on dataset name and overwrite if one exists
var match = dataSetList.FirstOrDefault(ds => ds.Name == dataSet.Name);
if (match != null)
{
dataSet.Id = match.Id;
}
GenericDataSet savedDataSet = this.manager.SaveDataSet(dataSet, sessionData.UserId);
migrationResults.AddNotification(savedDataSet, MessageType.Information, string.Format(Messages.Import_DataSetSuccess, savedDataSet.Name));
map.Add(dataSetId, savedDataSet.Id);
}
return map;
}
public void OnlyVerifyMajorMinorVersion()
{
MigrationData migrationData = new MigrationData
{
SystemVersion = new Version(16, 5, 250)
};
this.validator.Validate(migrationData);
}
public void ValidateImportNonExistingEndpoint()
{
ServiceEndpoint serviceEndpoint = new ServiceEndpoint { Id = "48387627348jfksdfjmfkjd" };
MigrationData migrationData = new MigrationData();
migrationData.ServiceEndpoints.Add(serviceEndpoint);
migrationData.SystemVersion = new Version(16, 5);
MigrationDataResults results = this.validator.Validate(migrationData);
MigrationDataMessageList messages = results.GetNotificationsFor(serviceEndpoint);
Assert.AreEqual(0, messages.Count());
}
/// <summary>
/// Perform an import.
/// </summary>
/// <param name="sessionData">The session data.</param>
/// <param name="migrationData">The data to import.</param>
/// <param name="validator">A validator for validating data prior to import.</param>
/// <returns>The import process results.</returns>
public MigrationDataResults Import(SessionData sessionData, MigrationData migrationData, MigrationDataValidator validator)
{
MigrationDataResults validationResults = validator.Validate(migrationData);
MigrationDataResults migrationResults = new MigrationDataResults();
OrganisationList allOrganisations = this.manager.GetOrganisationList(sessionData.UserId, true);
Dictionary<string, string> orgMap = this.ImportOrganisations(sessionData.UserId, allOrganisations, migrationData.Organisations, validationResults, migrationResults);
RoleList allRoles = this.manager.GetRoleList(sessionData.UserId);
Dictionary<string, string> systemRoleMap = this.ImportRoles(sessionData.UserId, migrationData.Roles, allRoles, validationResults, migrationResults);
this.ImportUsers(sessionData, migrationData.Users, allRoles, allOrganisations, systemRoleMap, orgMap, validationResults, migrationResults);
this.ImportProducts(sessionData, migrationData, systemRoleMap, orgMap, validationResults, migrationResults);
return migrationResults;
}
public void ValidateMissingDataSourceConfiguration()
{
const string id = "3b3cf1a7631f4c3c9d58714549ec6d4d";
const string name = "Missing Security Configuration";
ProductDefinition product = new ProductDefinition { Id = id, Name = name };
MigrationData migrationData = new MigrationData();
migrationData.Products.Add(product);
migrationData.WorkflowConfigurations.Add(new WorkflowConfigurationContainer { ExternalId = id, Configuration = new WorkflowConfiguration() });
migrationData.SystemVersion = new Version(16, 5);
migrationData.Security = new List<SecurityConfiguration>() { new SecurityConfiguration(new ApplicationEntitlementList() { new ApplicationEntitlement(id, AccessLevel.NoAccess) { ProductId = id } }) };
MigrationDataResults results = this.validator.Validate(migrationData);
MigrationDataMessageList messages = results.GetNotificationsFor(product);
Assert.AreEqual(1, messages.Count());
MigrationDataMessage message = messages.First();
Assert.AreEqual(MessageType.Error, message.MessageType);
Assert.AreEqual(string.Format("Missing Data Source configuration for Product \"{0}\" - Product will not be imported", name), message.Message);
}
/// <summary>
/// Imports the service endpoints and returns a map of old ids to new ids.
/// </summary>
/// <param name="sessionData">The session data.</param>
/// <param name="migrationData">Contains the service endpoints to import.</param>
/// <param name="validationResults">A list of validation results.</param>
/// <param name="migrationResults">A list to which import results will be appended.</param>
/// <returns>A map of service endpoint ids, where the old id is the key and the new id is the value.</returns>
private Dictionary<string, string> ImportServiceEndpoints(SessionData sessionData, MigrationData migrationData, MigrationDataResults validationResults, MigrationDataResults migrationResults)
{
Dictionary<string, string> map = new Dictionary<string, string>();
foreach (ServiceEndpoint endpoint in migrationData.ServiceEndpoints)
{
if (!validationResults.GetNotificationsFor(endpoint).CanImport)
{
migrationResults.AddNotification(endpoint, MessageType.Information, string.Format(Messages.Import_ServiceEndpointSkipped, endpoint.Name));
continue;
}
ServiceEndpoint savedEndpoint;
try
{
savedEndpoint = this.manager.SaveServiceEndpoint(endpoint, sessionData.UserId);
}
catch (ValidationException e)
{
throw new Exception(string.Format(Messages.Validate_ServiceEndpointFailure, endpoint.Name, endpoint.Id, e.Results.First().Message));
}
migrationResults.AddNotification(savedEndpoint, MessageType.Information, string.Format(Messages.Import_ServiceEndpointSuccess, savedEndpoint.Name));
map.Add(endpoint.Id, savedEndpoint.Id);
}
return map;
}
/// <summary>
/// Imports the products.
/// </summary>
/// <param name="sessionData">The session data.</param>
/// <param name="migrationData">Contains the products to import.</param>
/// <param name="systemRoleMap">A map of role ids, where the old id is the key and the new id is the value.</param>
/// <param name="organisationMap">A map of organisation ids, where the old id is the key and the new id is the value.</param>
/// <param name="validationResults">A list of validation results.</param>
/// <param name="migrationResults">A list to which import results will be appended.</param>
private void ImportProducts(SessionData sessionData, MigrationData migrationData, Dictionary<string, string> systemRoleMap, Dictionary<string, string> organisationMap, MigrationDataResults validationResults, MigrationDataResults migrationResults)
{
const string importedMessage = "Imported via Workbench";
Dictionary<string, string> validatorMap = this.ImportValidators(sessionData.UserId, migrationData.Validators);
Dictionary<string, string> serviceEndpointMap = this.ImportServiceEndpoints(sessionData, migrationData, validationResults, migrationResults);
Dictionary<string, string> dataSetMap = this.ImportDataSets(sessionData, migrationData, validationResults, migrationResults);
SystemSettings settings = this.manager.GetSystemSettings(sessionData.UserId);
if (settings.EnableFormApprovals)
{
migrationData.Products.ForEach(p => p.BranchName = Constants.DefaultImportBranch);
}
foreach (ProductDefinition product in migrationData.Products)
{
if (!validationResults.GetNotificationsFor(product).CanImport)
{
continue;
}
ProductDataSourceConfiguration dataSourceConfiguration = migrationData.ProductDataSourceConfigurations[product.Id];
if (organisationMap.ContainsKey(product.OrganisationId))
{
product.OrganisationId = organisationMap[product.OrganisationId];
}
WorkflowConfigurationContainer workflowConfiguration = migrationData.WorkflowConfigurations[product.Id];
ApplicationEntitlementList applicationEntitlements = new ApplicationEntitlementList(migrationData.Security.SelectMany(s => s.ApplicationEntitlements).Where(e => e.ProductId == product.Id));
PageEntitlementList pageEntitlements = new PageEntitlementList(migrationData.Security.SelectMany(s => s.PageEntitlements).Where(e => e.ProductId == product.Id));
ControlEntitlementList controlEntitlements = new ControlEntitlementList(migrationData.Security.SelectMany(s => s.ControlEntitlements).Where(e => e.ProductId == product.Id));
MetadataEntitlementList metadataEntitlements = new MetadataEntitlementList(migrationData.Security.SelectMany(s => s.MetadataEntitlements).Where(e => e.ProductId == product.Id));
SecurityConfiguration securityConfiguration = new SecurityConfiguration(applicationEntitlements, pageEntitlements, controlEntitlements, metadataEntitlements);
foreach (KeyValuePair<string, string> kvp in systemRoleMap)
{
foreach (ApplicationEntitlement entitlement in applicationEntitlements.Where(e => e.RoleId == kvp.Key))
{
entitlement.RoleId = systemRoleMap[entitlement.RoleId];
}
foreach (PageEntitlement entitlement in pageEntitlements.Where(e => e.RoleId == kvp.Key))
{
entitlement.RoleId = systemRoleMap[entitlement.RoleId];
}
foreach (ControlEntitlement entitlement in controlEntitlements.Where(e => e.RoleId == kvp.Key))
{
entitlement.RoleId = systemRoleMap[entitlement.RoleId];
}
foreach (MetadataEntitlement entitlement in metadataEntitlements.Where(e => e.RoleId == kvp.Key))
{
entitlement.RoleId = systemRoleMap[entitlement.RoleId];
}
foreach (EmailWorkflowTransitionAction emailTransition in workflowConfiguration.Configuration.States.SelectMany(s => s.Transitions).SelectMany(t => t.TransitionActionList).OfType<EmailWorkflowTransitionAction>().Where(ewt => ewt.PdfRenderRole == kvp.Key))
{
emailTransition.PdfRenderRole = systemRoleMap[emailTransition.PdfRenderRole];
}
}
string mappedId;
// Update control validators with new IDs
IEnumerable<ControlRegexValidator> controlValidators = product.FormDefinition.Pages.AllControls.AllValidators();
foreach (ControlRegexValidator validator in controlValidators)
{
bool available = validatorMap.TryGetValue(validator.ValidatorId, out mappedId);
if (available)
{
validator.ValidatorId = mappedId;
}
}
// Update prebuilt option sources with new IDs
List<ControlWithOptions> prebuiltOptionControls = product.FormDefinition.Pages.AllControls.FindAllRecursive<ControlWithOptions>(x => x.OptionSource.Type == OptionSourceType.Prebuilt);
foreach (ControlWithOptions prebuiltOptionControl in prebuiltOptionControls)
{
bool available = dataSetMap.TryGetValue(((PrebuiltOptionSource)prebuiltOptionControl.OptionSource).DataSetId, out mappedId);
if (available)
{
((PrebuiltOptionSource)prebuiltOptionControl.OptionSource).DataSetId = mappedId;
}
}
// Update service endpoints with new IDs
this.UpdateServiceEndpoints(product, dataSourceConfiguration, workflowConfiguration.Configuration, serviceEndpointMap);
product.EditComment = importedMessage;
ProductVariation productVariation = null;
if (product.IsChildForm)
{
productVariation = migrationData.ProductVariations.Exists(p => p.ProductId == product.Id)
? migrationData.ProductVariations.First(p => p.ProductId == product.Id)
: new ProductVariation
{
AddedControls = new List<int>(),
EditedControls = new List<int>(),
RemovedControls = new List<int>()
};
}
Product savedProduct = this.manager.SaveProduct(sessionData, product, workflowConfiguration.Configuration, securityConfiguration, dataSourceConfiguration, productVariation);
migrationResults.AddNotification(savedProduct, MessageType.Information, string.Format(Messages.Import_ProductSuccess, savedProduct.Name, savedProduct.Version));
}
}
/// <summary>
/// Validates the <paramref name="migrationData"/> and returns the results as a list of messages.
/// </summary>
/// <param name="migrationData">The migration data to validate.</param>
/// <returns>A list of warnings resulting from the validation.</returns>
public MigrationDataResults Validate(MigrationData migrationData)
{
MigrationDataResults results = new MigrationDataResults();
Version currentSystemVersion = this.dataAccess.GetSystemVersion();
if (migrationData.SystemVersion != null && currentSystemVersion.CompareTo(migrationData.SystemVersion, 2) != 0)
{
string message = currentSystemVersion.CompareTo(migrationData.SystemVersion, 2) > 0 ?
string.Format(Messages.Validate_TargetSystemVersionTooHigh, currentSystemVersion.ToString(2), migrationData.SystemVersion.ToString(2)) :
string.Format(Messages.Validate_TargetSystemVersionTooLow, currentSystemVersion.ToString(2), migrationData.SystemVersion.ToString(2));
throw new MigrationVersionException(message);
}
if (migrationData.SystemVersion == null)
{
string message = string.Format(Messages.Validate_ExportMissingVersion, currentSystemVersion.ToString(2));
throw new MigrationVersionException(message);
}
this.ValidateProducts(migrationData, results);
if (migrationData.Users.Count > 0)
{
IEnumerable<string> usernames = migrationData.Users.Select(p => p.Username);
OrganisationList orgList = this.dataAccess.GetOrganisationList();
UserSearchCriteria filter = new UserSearchCriteria
{
OrganisationIds = orgList.Select(x => x.Id).ToList(),
Usernames = usernames.ToList()
};
UserList foundUsers = this.dataAccess.FindUsers(filter);
foreach (User u in foundUsers)
{
results.AddNotification(migrationData.Users.FirstOrDefault(user => user.Username == u.Username), MessageType.Error, string.Format(Messages.Validate_UserExistsUsername, u.Username));
}
}
if (migrationData.Roles.Count > 0)
{
RoleList allRoles = this.dataAccess.GetRoleList();
foreach (Role r in allRoles.Where(r => !r.SystemDefined))
{
if (migrationData.Roles.Contains(r.Id))
{
results.AddNotification(r, MessageType.Error, string.Format(Messages.Validate_RoleExistsId, r.RoleName));
}
}
}
if (migrationData.Organisations.Count > 0)
{
OrganisationList allOrganisations = this.dataAccess.GetOrganisationList();
foreach (Organisation org in allOrganisations)
{
MigrationOrganisation migrationOrgMatchId = migrationData.Organisations.FirstOrDefault(o => o.Id == org.Id);
if (migrationOrgMatchId != null)
{
results.AddNotification(migrationOrgMatchId, MessageType.Error, string.Format(Messages.Validate_OrgExistsId, org.Name));
}
else
{
MigrationOrganisation migrationOrgMatchName = migrationData.Organisations.FirstOrDefault(o => o.Name == org.Name);
if (migrationOrgMatchName != null)
{
results.AddNotification(migrationOrgMatchName, MessageType.Warning, string.Format(Messages.Validate_OrgExistsId, org.Name));
}
}
}
}
if (migrationData.ServiceEndpoints.Count > 0)
{
ServiceEndpointList allEndpoints = this.dataAccess.GetServiceEndpointList();
foreach (ServiceEndpoint endpoint in allEndpoints)
{
if (migrationData.ServiceEndpoints.Contains(endpoint.Id))
{
results.AddNotification(endpoint, MessageType.Error, string.Format(Messages.Validate_ServiceEndpointExistsId, endpoint.Name, endpoint.Id));
}
}
}
if (migrationData.DataSets.Count > 0)
{
GenericDataSetList allDataSets = this.dataAccess.GetDataSetList(false);
foreach (GenericDataSet dataSet in allDataSets)
{
if (migrationData.DataSets.Any(x => x.Id == dataSet.Id))
{
results.AddNotification(dataSet, MessageType.Warning, string.Format(Messages.Validate_DataSetExistsId, dataSet.Name, dataSet.Id));
}
}
}
return results;
}
/// <summary>
/// Validates the products.
/// </summary>
/// <param name="migrationData">The migration data.</param>
/// <param name="results">The results.</param>
private void ValidateProducts(MigrationData migrationData, MigrationDataResults results)
{
foreach (ProductDefinition p in migrationData.Products)
{
if (!migrationData.ProductDataSourceConfigurations.ContainsKey(p.Id))
{
results.AddNotification(p, MessageType.Error, string.Format(Messages.Validate_ProductMissingDataSourceConfig, p.Name));
}
if (migrationData.Security.SelectMany(s => s.ApplicationEntitlements).All(e => e.ProductId != p.Id))
{
results.AddNotification(p, MessageType.Error, string.Format(Messages.Validate_ProductMissingSecurityConfig, p.Name));
}
if (!migrationData.WorkflowConfigurations.Contains(p.Id))
{
results.AddNotification(p, MessageType.Error, string.Format(Messages.Validate_ProductMissingWorkflowConfig, p.Name));
}
if (!results.GetNotificationsFor(p).CanImport)
{
continue;
}
try
{
Product foundProduct = this.dataAccess.GetProduct<ProductSearchResult>(p.Id);
results.AddNotification(p, MessageType.Warning, string.Format(Messages.Validate_ProductWillBeOverriden, migrationData.Products[p.Id].Name, foundProduct.Name));
}
catch (NullReferenceException)
{
// Product does not already exist.
}
}
}
/// <summary>
/// Imports data into the data store, including users, roles, forms etc.
/// </summary>
/// <param name="session">An authenticated session object.</param>
/// <param name="importData">The data to be imported.</param>
/// <returns>
/// The results of the import process.
/// </returns>
public MigrationDataResults Import(SessionData session, MigrationData importData)
{
return this.migrationDataImporter.Import(session, importData, this.migrationDataValidator);
}
public void ValidateSourceVersionLowerThanTarget()
{
MigrationData migrationData = new MigrationData
{
SystemVersion = new Version(16, 4)
};
this.validator.Validate(migrationData);
}
public void ValidateNotOverwriteExistingServiceEndpoint()
{
const string id = "53858ea7f9d8ee351cff376a";
ServiceEndpoint serviceEndpoint = new ServiceEndpoint { Id = id };
MigrationData migrationData = new MigrationData();
migrationData.ServiceEndpoints.Add(serviceEndpoint);
migrationData.SystemVersion = new Version(16, 5);
MigrationDataResults results = this.validator.Validate(migrationData);
MigrationDataMessageList messages = results.GetNotificationsFor(serviceEndpoint);
Assert.AreEqual(1, messages.Count());
MigrationDataMessage message = messages.First();
Assert.AreEqual(MessageType.Error, message.MessageType);
Assert.AreEqual(string.Format("Service Endpoint \"Existing Service Endpoint\" with ID \"{0}\" exists - Service Endpoint will not be imported", id), message.Message);
}
public void ValidateMissingVersionNumber()
{
MigrationData migrationData = new MigrationData();
this.validator.Validate(migrationData);
}
