/// <summary>
/// Creates a node that is representative of the specified object (if applicable).
/// </summary>
/// <param name="entity">The entity.</param>
/// <returns></returns>
public static EnterpriseTestMapNode Create(object entity)
{
EnterpriseScenario scenario = entity as EnterpriseScenario;
if (scenario != null)
{
return(new EnterpriseTestMapNode(scenario));
}
VirtualResource resource = entity as VirtualResource;
if (resource != null)
{
return(new EnterpriseTestMapNode(resource));
}
VirtualResourceMetadata metadata = entity as VirtualResourceMetadata;
if (metadata != null)
{
return(new EnterpriseTestMapNode(metadata));
}
ConfigurationTreeFolder folder = entity as ConfigurationTreeFolder;
if (folder != null)
{
return(new EnterpriseTestMapNode(folder));
}
return(null);
}
/// <summary>
/// Checks the available VM Platforms in the database to make sure that
/// the number of VMs needed for the test does not exceed the available.
/// </summary>
/// <param name="scenario"></param>
/// <param name="platform"></param>
/// <param name="holdId"></param>
/// <returns>true if enough VM Platforms are available, false otherwise.</returns>
private static bool CheckPlatformsAvailable(EnterpriseScenario scenario, FrameworkClientPlatform platform, string holdId)
{
ScenarioPlatformUsageSet usages = new ScenarioPlatformUsageSet(scenario);
if (platform != null)
{
usages.Load(UserManager.CurrentUser, platform);
}
else if (string.IsNullOrEmpty(holdId) == false)
{
usages.Load(UserManager.CurrentUser, holdId);
}
else
{
usages.Load(UserManager.CurrentUser);
}
if (!usages.PlatformsAvailable)
{
using (InsufficientPlatformsErrorForm form = new InsufficientPlatformsErrorForm(usages))
{
form.ShowDialog();
return(false);
}
}
return(true);
}
/// <summary>
/// Initializes a new instance of the <see cref="EnterpriseTestMapNode"/> class.
/// </summary>
/// <param name="scenario">The scenario.</param>
public EnterpriseTestMapNode(EnterpriseScenario scenario)
: this(scenario.EnterpriseScenarioId)
{
FolderId = scenario.FolderId;
Name = scenario.Name;
NodeType = ConfigurationObjectType.EnterpriseScenario;
}
/// <summary>
/// Creates a <see cref="SessionTicket"/> using the specififed scenario name.
/// </summary>
/// <param name="scenarioNames">List of the scenarios to execute.</param>
/// <param name="sessionName">Name of the session to execute scenarios</param>
/// <param name="durationHours">The session duration in hours.</param>
/// <returns></returns>
/// <exception cref="System.InvalidOperationException">Scenario with specified name is not found in the database.</exception>
public static SessionTicket Create(IEnumerable <string> scenarioNames, string sessionName, int durationHours = 2)
{
SessionTicket ticket = new SessionTicket()
{
ExpirationDate = DateTime.Now.AddHours(durationHours),
DurationHours = durationHours,
SessionName = sessionName
};
using (EnterpriseTestContext context = new EnterpriseTestContext())
{
foreach (string scenarioName in scenarioNames)
{
if (!string.IsNullOrEmpty(scenarioName))
{
var scenario = EnterpriseScenario.Select(context, scenarioName);
if (scenario == null)
{
throw new InvalidOperationException($"'{scenarioName}' is not found in the database.");
}
((List <Guid>)ticket.ScenarioIds).Add(scenario.EnterpriseScenarioId);
}
}
}
return(ticket);
}
/// <summary>
/// Loads all data from the database required to build the manifests for this Scenario so that
/// properties like Resources and Quantities can be evaluated before the actual building of the manifests.
/// </summary>
private void Initialize()
{
using (EnterpriseTestContext context = new EnterpriseTestContext())
{
TraceFactory.Logger.Debug($"Loading all resources for scenarioId: {ScenarioId}");
// Get the enabled VirtualResources but filter out any disabled items from the VirtualResourceMetadataSet
var resources = EnterpriseScenario.SelectWithAllChildren(context, ScenarioId)?.VirtualResources.Where(e => e.Enabled);
if (resources == null || !resources.Any())
{
//No reason to continue if there are no resources
return;
}
foreach (var resource in resources)
{
var temp = resource.VirtualResourceMetadataSet.Where(x => x.Enabled).ToList();
resource.VirtualResourceMetadataSet.Clear();
temp.ForEach(resource.VirtualResourceMetadataSet.Add);
}
Resources = resources;
ManifestSet.ScenarioId = ScenarioId;
ManifestSet.ScenarioName = EnterpriseScenario.Select(context, ScenarioId).Name;
Quantities = new SessionResourceQuantity(Resources);
}
}
/// <summary>
/// Gets the entity object.
/// </summary>
/// <param name="id">The id.</param>
/// <returns></returns>
public EntityObject GetEntityObject(Guid id)
{
// Discard our old entity context and create a new one. This seems wasteful,
// but if we maintain the same context it will cache all the data that is ever
// loaded from it. This can cause huge memory growth over time, as well as
// concurrency issues. Creating a new context is cheap and avoids these issues.
if (_context != null)
{
_context.Dispose();
}
_context = new EnterpriseTestContext();
EnterpriseTestMapNode node = _databaseMap[id];
switch (node.NodeType)
{
case ConfigurationObjectType.EnterpriseScenario:
return(EnterpriseScenario.Select(_context, id));
case ConfigurationObjectType.VirtualResource:
return(VirtualResource.Select(_context, id));
case ConfigurationObjectType.ResourceMetadata:
return(VirtualResourceMetadata.Select(_context, id));
case ConfigurationObjectType.ScenarioFolder:
case ConfigurationObjectType.ResourceFolder:
case ConfigurationObjectType.MetadataFolder:
return(ConfigurationTreeFolder.Select(_context, id));
default:
return(null);
}
}
/// <summary>
/// Creates a copy of a Resource.
/// </summary>
/// <param name="source">The Source Resource to copy from</param>
/// <param name="srcParent"></param>
/// <param name="newParent"></param>
/// <param name="Mappings"></param>
/// <returns>Guid of the Resource node that was created</returns>
public Guid CopyResource(Guid source, Guid srcParent, Guid newParent, Dictionary <Guid?, Guid?> Mappings)
{
using (EnterpriseTestContext ctx = new EnterpriseTestContext())
{
VirtualResource vrSource = VirtualResource.Select(ctx, source);
VirtualResource vrCopy = vrSource.ShallowCopy();
HandleObjectChange(ctx, vrCopy);
ctx.SaveChanges();
EnterpriseScenario dstScenario;
if (vrSource.EnterpriseScenarioId == srcParent)
{
dstScenario = EnterpriseScenario.Select(ctx, newParent);
}
else
{
try
{
vrCopy.FolderId = (Guid)Mappings[srcParent];
dstScenario = EnterpriseScenario.Select(ctx, (Guid)Mappings[vrSource.EnterpriseScenarioId]);
}
catch (Exception)
{
throw new Exception("Cannot find New Target Scenario /Resource Folder for " + source.ToString());
}
}
dstScenario.VirtualResources.Add(vrCopy);
HandleObjectChange(ctx, vrCopy);
HandleObjectChange(ctx, dstScenario);
ctx.SaveChanges();
return(vrCopy.VirtualResourceId);
}
}
/// <summary>
/// Validates scenario data for the given scenario and checks to ensure enough free VMs (by platform type).
/// </summary>
/// <param name="scenario">The scenario to check.</param>
/// <param name="platform">The Virtual Machine Platform requested, if any.</param>
/// <param name="holdId">The Hold Id, if any.</param>
/// <returns>true if the check passes, false otherwise.</returns>
private static bool PerformScenarioIntegrityCheck(EnterpriseScenario scenario, FrameworkClientPlatform platform, string holdId)
{
List <string> issues = scenario.ValidateData().ToList();
issues.AddRange(ValidateUsages(scenario));
// STF-only
if (GlobalSettings.IsDistributedSystem)
{
if (!CheckPlatformsAvailable(scenario, platform, holdId))
{
return(false);
}
}
if (issues.Any())
{
StringBuilder message = new StringBuilder("The following issues were found with the selected scenario:\n");
message.Append(string.Join("\n", issues));
message.Append("\n\nDo you want to continue?");
DialogResult result = MessageBox.Show(message.ToString(), "Scenario Validation", MessageBoxButtons.YesNo, MessageBoxIcon.Warning);
return(result == DialogResult.Yes);
}
return(true);
}
private void LoadScenario(Guid scenarioId, EnterpriseTestContext context)
{
EnterpriseScenario scenario = EnterpriseScenario.Select(context, scenarioId);
if (scenario != null)
{
_scenario = scenario.Clone();
selectedScenario_TextBox.Text = _scenario.Name;
}
}
public ScenarioPlatformUsageForm(ScenarioPlatformUsageSet usages)
{
InitializeComponent();
_scenario = usages.Scenario;
_platformUsage = new SortableBindingList <ScenarioPlatformUsage>();
foreach (var usage in usages)
{
_platformUsage.Add(usage);
}
}
private void LoadVirtualResources()
{
_context = new EnterpriseTestContext();
ModifiedScenario = EnterpriseScenario.Select(_context, _scenarioId);
_resources = ModifiedScenario.VirtualResources.ToList();
this.Text = ModifiedScenario.Name;
}
private SessionResourceQuantity GetQuantities(EnterpriseScenario scenario)
{
// Force a load of VirtualResourceMetadata for this scenario. Otherwise, when the VirtualResourcePacker
// is doing its job the call to Clone() in the PackedSets property of packer will not deep copy the
// Metadata. This seems to be an issue with how the serialization is working when the entity is in
// a lazy loading mode. This code is just forcing the VirtualResourceMetadata to be loaded.
scenario.VirtualResources.SelectMany(x => x.VirtualResourceMetadataSet).Count();
// Determine the quantities for this scenario
return(new SessionResourceQuantity(scenario.VirtualResources.Where(x => x.Enabled == true)));
}
/// <summary>
/// Initializes the wizard page with the specified <see cref="WizardConfiguration"/>.
/// </summary>
/// <param name="configuration">The <see cref="WizardConfiguration"/>.</param>
public bool Initialize(WizardConfiguration configuration)
{
Ticket = configuration.Ticket;
_scenarios = new BindingList <ScenarioSelectionItem>();
scenarios_DataGridView.DataSource = null;
if (STFDispatcherManager.Dispatcher == null && STFDispatcherManager.ConnectToDispatcher() == false)
{
//The user canceled the connect dialog
return(false);
}
using (new BusyCursor())
{
using (EnterpriseTestContext context = new EnterpriseTestContext())
{
foreach (EnterpriseScenario scenario in EnterpriseScenario.Select(context, Ticket.ScenarioIds))
{
_scenarios.Add(new ScenarioSelectionItem(scenario));
}
LoadComboBoxes(context);
}
_bindingSource = new BindingSource(_scenarios, string.Empty);
scenarios_DataGridView.DataSource = _bindingSource;
}
//Set data from Ticket
if (Ticket.SessionId != null)
{
SetEstimatedRunTime();
sessionName_ComboBox.Text = string.IsNullOrEmpty(Ticket.SessionName) ? "Multiple Scenarios" : Ticket.SessionName;
}
if (!_initial)
{
SessionClient.Instance.Close(Ticket.SessionId);
sessionType_ComboBox.SelectedText = Ticket.SessionType;
if (!string.IsNullOrEmpty(Ticket.EmailAddresses))
{
runtime_NumericUpDown.Value = Math.Min(Ticket.DurationHours, runtime_NumericUpDown.Maximum);
}
}
environment_Label.Text = "{0} {1} Environment".FormatWith(GlobalSettings.Items[Setting.Organization], GlobalSettings.Items[Setting.Environment]);
dispatcher_Label.Text = STFDispatcherManager.Dispatcher.HostName;
_initial = false;
return(true);
}
public ScenarioSelectionItem(EnterpriseScenario scenario)
{
ScenarioId = scenario.EnterpriseScenarioId;
Name = scenario.Name;
EstimatedRunTime = scenario.EstimatedRuntime;
// ScenarioSettings override the default
if (!string.IsNullOrEmpty(scenario.ScenarioSettings))
{
ScenarioSettings settings = LegacySerializer.DeserializeDataContract <ScenarioSettings>(scenario.ScenarioSettings);
EstimatedRunTime = settings.EstimatedRunTime;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ConfigurationObjectTag" /> class
/// representing an <see cref="EnterpriseScenario" /> object.
/// </summary>
/// <param name="scenario">The <see cref="EnterpriseScenario" />.</param>
/// <exception cref="ArgumentNullException"><paramref name="scenario" /> is null.</exception>
public ConfigurationObjectTag(EnterpriseScenario scenario)
{
if (scenario == null)
{
throw new ArgumentNullException(nameof(scenario));
}
Id = scenario.EnterpriseScenarioId;
ObjectType = ConfigurationObjectType.EnterpriseScenario;
Name = scenario.Name;
FolderId = scenario.FolderId;
}
/// <summary>
/// Initializes this instance for configuration of a new object.
/// </summary>
public override void Initialize()
{
var scenario = new EnterpriseScenario();
scenario.Owner = UserManager.CurrentUserName;
// Find all groups the user is a member of and add them to the new instance
using (EnterpriseTestContext context = new EnterpriseTestContext())
{
scenario.AddGroups(context, UserManager.CurrentUserName);
}
Initialize(scenario);
}
/// <summary>
/// EnterpriseScenarioContract constructor.
/// </summary>
/// <param name="scenario">The EnterpriseScnenario.</param>
/// <param name="version">The scenario version.</param>
public EnterpriseScenarioContract(EnterpriseScenario scenario, string version)
: this()
{
Company = scenario.Company;
Description = scenario.Description;
Name = scenario.Name;
Owner = scenario.Owner;
Vertical = scenario.Vertical;
ContractVersion = version;
foreach (var group in scenario.UserGroups)
{
UserGroups.Add(group.GroupName);
}
}
/// <summary>
/// Creates the folders within a scenario during import
/// </summary>
/// <param name="contract">The contract.</param>
/// <param name="scenario">The scenario.</param>
/// <param name="context">The context.</param>
/// <param name="importMaps">The import maps.</param>
private void CreateFolders(EnterpriseScenarioContract contract, EnterpriseScenario scenario, EnterpriseTestContext context, List <ContractFactory.ImportMap> importMaps)
{
try
{
foreach (var folder in contract.Folders)
{
// create the folder with parent defaulted to scenario
var newFolderEntity = ConfigurationTreeFolder.CreateConfigurationTreeFolder(SequentialGuid.NewGuid(), folder.Name, folder.FolderType);
newFolderEntity.ParentId = scenario.EnterpriseScenarioId;
context.AddToConfigurationTreeFolders(newFolderEntity);
// set children for folder based on import mapping
var childMaps = (from c in folder.ChildIds
join i in importMaps on c equals i.OldId
select i);
if (childMaps.Any())
{
newFolderEntity.ParentId = childMaps.First().NewParentId;
switch (folder.FolderType)
{
case "ResourceFolder":
var vr = (from e in scenario.VirtualResources
join c in childMaps on e.VirtualResourceId equals c.NewId
select e).ToList();
vr.ForEach(x => x.FolderId = newFolderEntity.ConfigurationTreeFolderId);
break;
case "MetadataFolder":
var md = (from e in scenario.VirtualResources.SelectMany(x => x.VirtualResourceMetadataSet)
join c in childMaps on e.VirtualResourceMetadataId equals c.NewId
select e).ToList();
md.ForEach(x => x.FolderId = newFolderEntity.ConfigurationTreeFolderId);
break;
default:
break;
}
}
}
}
catch (Exception ex)
{
TraceFactory.Logger.Error("Error creating folders within scenario", ex);
}
}
/// <summary>
/// Creates a new scenario under the specified parent id.
/// </summary>
/// <param name="folderId">The folder id.</param>
/// <returns>The ID of the created scenario.</returns>
public Guid CreateScenario(Guid?folderId)
{
// Create a new scenario
EnterpriseScenario scenario = new EnterpriseScenario();
scenario.FolderId = folderId;
scenario.Owner = UserManager.CurrentUserName;
using (EnterpriseTestContext context = new EnterpriseTestContext())
{
scenario.AddGroups(context, scenario.Owner);
context.EnterpriseScenarios.AddObject(scenario);
HandleObjectChange(context, scenario);
context.SaveChanges();
}
return(scenario.EnterpriseScenarioId);
}
private bool PerformDataIntegrityCheck(EnterpriseTestContext context, Guid scenarioId)
{
EnterpriseScenario scenario = EnterpriseScenario.Select(context, scenarioId);
if (platform_RadioButton.Checked)
{
return(WizardPageManager.PerformScenarioIntegrityCheck(scenario, (FrameworkClientPlatform)platform_ComboBox.SelectedItem));
}
else if (holdId_RadioButton.Checked)
{
return(WizardPageManager.PerformScenarioIntegrityCheck(scenario, (string)holdId_ComboBox.SelectedItem));
}
else
{
return(WizardPageManager.PerformScenarioIntegrityCheck(scenario));
}
}
/// <summary>
/// Performs final validation before allowing the user to navigate away from the page.
/// </summary>
/// <returns>
/// True if this page was successfully validated.
/// </returns>
public bool Complete()
{
if (!ValidateInput())
{
return(false);
}
// We're gonna need a data context several times in the following lines
using (EnterpriseTestContext context = new EnterpriseTestContext())
{
List <EnterpriseScenario> scenarios = EnterpriseScenario.Select(context, Ticket.ScenarioIds).ToList();
// Perform a data integrity check on the scenarios
if (PerformDataIntegrityCheck(scenarios) == false)
{
return(false);
}
//PopulateNotificationSettings() TODO: What about the email list? The ticket has an email list. Can we repurpose it for batch operations?
// Populate ticket data from the UI
Ticket.ScenarioIds = GetSelectedScenarioIds();
Ticket.CollectEventLogs = false;
Ticket.SessionName = sessionName_ComboBox.Text;
Ticket.SessionType = sessionType_ComboBox.Text;
Ticket.SessionCycle = sessionCycle_ComboBox.Text;
Ticket.Reference = WizardPageManager.GetReferenceData(reference_TextBox);
Ticket.SessionNotes = notes_TextBox.Text;
Ticket.DurationHours = (int)runtime_NumericUpDown.Value;
SessionLogRetention logRetention = EnumUtil.GetByDescription <SessionLogRetention>((string)retention_ComboBox.SelectedItem);
Ticket.ExpirationDate = logRetention.GetExpirationDate(DateTime.Now);
Ticket.LogLocation = GlobalSettings.WcfHosts[WcfService.DataLog];
SetAssociatedProducts(context, scenarios);
// Doesn't make sense to save session name for batch operation.
context.SaveChanges();
}
// Initiate the session with the dispatcher
TraceFactory.Logger.Debug($"Calling Initiate() on {Ticket.SessionId}");
SessionClient.Instance.InitiateSession(Ticket);
return(true);
}
/// <summary>
/// Creates composite contract data for the specified scenario.
/// Scenario data + Printer data + Document data.
/// </summary>
/// <param name="scenario"></param>
/// <param name="includePrinters">When true, causes all print device data to be serialized as part of the export process.</param>
/// <param name="includeDocuments">When true, causes the documents to be serialized as part of the export process</param>
/// <returns></returns>
public static EnterpriseScenarioCompositeContract Create(EnterpriseScenario scenario, bool includePrinters, bool includeDocuments)
{
var scenarioContract = Create(scenario);
var contract = new EnterpriseScenarioCompositeContract(scenarioContract);
if (includePrinters)
{
using (var context = DbConnect.AssetInventoryContext())
{
foreach (var printer in contract.Scenario.AllAssets.Where(x => x.AssetType == "Printer"))
{
var asset = context.Assets.OfType <Printer>().FirstOrDefault(x => x.AssetId.Equals(printer.AssetId));
if (asset != null)
{
contract.Printers.Add(Create <PrinterContract>(asset));
UpdateStatus("Exporting {0}".FormatWith(printer.AssetId));
}
else
{
TraceFactory.Logger.Error("Asset Id {0} was NULL".FormatWith(printer.AssetId));
UpdateStatus("Missing {0}".FormatWith(printer.AssetId));
}
}
}
}
if (includeDocuments)
{
using (DocumentLibraryContext context = DbConnect.DocumentLibraryContext())
{
foreach (var documentContract in contract.Scenario.TestDocuments)
{
string fileName = Path.GetFileName(documentContract.Original);
TestDocument document = context.TestDocuments.Include(n => n.TestDocumentExtension).FirstOrDefault(x => x.FileName.Equals(fileName));
if (document != null)
{
contract.Documents.Load(document, includeDocuments);
UpdateStatus("Exporting {0}".FormatWith(fileName));
}
}
}
}
return(contract);
}
private void LoadScenario(Guid scenarioId, EnterpriseTestContext context)
{
EnterpriseScenario scenario = EnterpriseScenario.Select(context, scenarioId);
if (scenario != null)
{
Ticket.ScenarioIds = new List <Guid>()
{
scenarioId
};
_scenario = scenario;
selectedScenario_TextBox.Text = scenario.Name;
runtime_NumericUpDown.Value = Math.Min(scenario.EstimatedRuntime, runtime_NumericUpDown.Maximum); //Ensure we don't exceed the NumericUpDown.Maximum.
//Populate Associated Products
_scenarioProducts = WizardPageManager.GetAssociatedProducts(context, scenario);
scenarioProductBindingSource.DataSource = _scenarioProducts;
scenarioProductBindingSource.ResetBindings(true);
}
}
/// <summary>
/// Creates contract data for the specified scenario.
/// </summary>
/// <param name="scenario"></param>
/// <returns></returns>
public static EnterpriseScenarioContract Create(EnterpriseScenario scenario)
{
EnterpriseScenarioContract contract = new EnterpriseScenarioContract(scenario, "1.0");
Guid scenarioId = scenario.EnterpriseScenarioId;
SystemManifest manifest = CreateReferenceManifest(scenarioId);
AddTestDocumentInfoToContract(scenario.EnterpriseScenarioId, contract, manifest);
AddAssetInfoToContract(scenario.EnterpriseScenarioId, contract, manifest);
AddActivityUsageDataToContract(contract, scenarioId);
AddFolderDataToContract(contract, scenario);
foreach (var resource in scenario.VirtualResources)
{
var resourceDetail = VirtualResourceDetailBuilder.CreateBaseDetail(resource);
contract.ResourceDetails.Add(resourceDetail);
UpdateStatus("Exporting {0}".FormatWith(resourceDetail.Name));
}
return(contract);
}
private void add_Button_Click(object sender, EventArgs e)
{
using (ScenarioSelectionForm selectionForm = new ScenarioSelectionForm())
{
if (selectionForm.ShowDialog() == DialogResult.OK)
{
EnterpriseScenario scenario = null;
using (new BusyCursor())
{
using (EnterpriseTestContext context = new EnterpriseTestContext())
{
scenario = EnterpriseScenario.Select(context, selectionForm.SelectedScenarioId);
_bindingSource.Add(new ScenarioSelectionItem(scenario));
}
}
_bindingSource.MoveLast();
SetEstimatedRunTime();
}
}
}
private void LoadScenarios(XElement scenarios)
{
_scenarioList.Clear();
foreach (var scenario in scenarios.Elements("Scenario"))
{
using (EnterpriseTestContext context = new EnterpriseTestContext())
{
var enterpriseScenario = EnterpriseScenario.Select(context, Guid.Parse(scenario.Value));
if (enterpriseScenario != null)
{
_scenarioList.Add(new ScenarioQueueList()
{
ScenarioName = enterpriseScenario.Name, ScenarioId = enterpriseScenario.EnterpriseScenarioId, Status = "Yet to Start"
});
}
else
{
MessageBox.Show("Scenario:{0} not found".FormatWith(scenario.Value));
}
}
}
}
/// <summary>
/// Creates a copy of a scenario. Can make an exact copy, or one that has the name appendeed with a time/date stamp
/// </summary>
/// <param name="source">The Source scenario Id</param>
/// <param name="parent">Parent if available</param>
/// <returns>Guid of the Scenario node that was created</returns>
public Guid CopyScenario(Guid source, Guid?parent)
{
using (EnterpriseTestContext ctx = new EnterpriseTestContext())
{
var srcScenario = EnterpriseScenario.Select(ctx, source);
Guid dst = CreateScenario(parent);
EnterpriseScenario dstScenario = EnterpriseScenario.Select(ctx, dst);
dstScenario.Name = srcScenario.Name;
dstScenario.Description = srcScenario.Description;
dstScenario.Vertical = srcScenario.Vertical;
dstScenario.Company = srcScenario.Company;
HandleObjectChange(ctx, dstScenario);
if (parent != null)
{
HandleObjectChange(ctx, GetEntityObject((Guid)parent));
}
ctx.SaveChanges();
return(dst);
}
}
private void MoveHandler(EnterpriseTestContext context, IEnumerable <Guid> affected)
{
foreach (Guid affectedId in affected)
{
EnterpriseTestMapNode moved = _databaseMap[affectedId];
switch (moved.NodeType)
{
case ConfigurationObjectType.EnterpriseScenario:
var scenario = EnterpriseScenario.Select(context, affectedId);
scenario.FolderId = moved.FolderId;
HandleObjectChange(context, scenario);
break;
case ConfigurationObjectType.VirtualResource:
var resource = VirtualResource.Select(context, affectedId);
resource.EnterpriseScenarioId = (Guid)moved.ParentId;
resource.FolderId = moved.FolderId;
HandleObjectChange(context, resource);
break;
case ConfigurationObjectType.ResourceMetadata:
var metadata = VirtualResourceMetadata.Select(context, affectedId);
metadata.VirtualResourceId = (Guid)moved.ParentId;
metadata.FolderId = moved.FolderId;
HandleObjectChange(context, metadata);
break;
case ConfigurationObjectType.ScenarioFolder:
case ConfigurationObjectType.ResourceFolder:
case ConfigurationObjectType.MetadataFolder:
var folder = ConfigurationTreeFolder.Select(context, affectedId);
folder.ParentId = moved.ParentId;
HandleObjectChange(context, folder);
break;
}
}
context.SaveChanges();
}
/// <summary>
/// Renames the object with the specified id.
/// </summary>
/// <param name="id">The id.</param>
/// <param name="name">The name.</param>
public void Rename(Guid id, string name)
{
using (EnterpriseTestContext context = new EnterpriseTestContext())
{
EnterpriseTestMapNode node = _databaseMap[id];
switch (node.NodeType)
{
case ConfigurationObjectType.EnterpriseScenario:
var scenario = EnterpriseScenario.Select(context, id);
scenario.Name = name;
HandleObjectChange(context, scenario);
break;
case ConfigurationObjectType.VirtualResource:
var resource = VirtualResource.Select(context, id);
resource.Name = name;
HandleObjectChange(context, resource);
break;
case ConfigurationObjectType.ResourceMetadata:
var metadata = VirtualResourceMetadata.Select(context, id);
metadata.Name = name;
HandleObjectChange(context, metadata);
break;
case ConfigurationObjectType.ScenarioFolder:
case ConfigurationObjectType.ResourceFolder:
case ConfigurationObjectType.MetadataFolder:
var folder = ConfigurationTreeFolder.Select(context, id);
folder.Name = name;
HandleObjectChange(context, folder);
break;
}
context.SaveChanges();
}
}
private static IEnumerable <string> ValidateUsages(EnterpriseScenario scenario)
{
List <VirtualResourceMetadata> metadatas = scenario.VirtualResources.SelectMany(v => v.VirtualResourceMetadataSet).ToList();
AssetInventoryContext assetContext = DbConnect.AssetInventoryContext();
DocumentLibraryContext docContext = DbConnect.DocumentLibraryContext();
try
{
StringBuilder message = new StringBuilder();
foreach (VirtualResourceMetadata metadata in metadatas)
{
message.Clear();
if (!ValidatePrintQueueUsage(metadata.PrintQueueUsage, assetContext))
{
message.Append(metadata.Name);
message.Append(" has no Print Queue definition");
}
if (!ValidateDocumentUsage(metadata.DocumentUsage, docContext))
{
message.Append(message.Length == 0 ? $"{metadata.Name} has no " : " or ");
message.Append("documents selected");
}
if (message.Length > 0)
{
message.Append(".");
yield return(message.ToString());
}
}
}
finally
{
assetContext.Dispose();
docContext.Dispose();
}
}
