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