public void AddHardware(HardwareComponent hardware) { this.MaxCapacity += hardware.MaxCapacity; this.MaxMemory += hardware.MaxMemory; this.hardwareByName.Add(hardware.Name, hardware); }
private void RegisterHardware(string[] inputLine) { HardwareComponent newPowerComponent = this.hardwareFactory.CreateHardwareComponentComponent(inputLine); this.systemRepository.AddToRepository(newPowerComponent); }
public async Task <IActionResult> Edit(int id, [Bind("ID,Name,Description,DateAdded,DateModified")] HardwareComponent hardwareComponent) { if (id != hardwareComponent.ID) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(hardwareComponent); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!HardwareComponentExists(hardwareComponent.ID)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(hardwareComponent)); }
/// <summary> /// This method adds a hardware component to the database /// </summary> /// <param name="component">The component to be added</param> /// <returns></returns> public async Task AddComponent(HardwareComponent component) { var command = dbConnection.CreateCommand(); command.CommandText = $@"INSERT INTO components( ComponentAmount, ComponentDrawer, ComponentName, ComponentNotes, ComponentOrderWarningMinimum, ComponentRack, ComponentUID ) VALUES( {component.componentAmount}, {component.componentDrawer}, '{component.componentName}', '{component.componentNotes}', {component.componentOrderWarning}, {component.componentRack}, '{component.componentUid}' )"; await command.ExecuteNonQueryAsync(); }
public static void Destroy(List <HardwareComponent> dump, string command) { if (dump.Any(h => h.Name == command)) { HardwareComponent hardware = dump.Where(h => h.Name == command).First(); dump.Remove(hardware); } }
public void AddToRepository(HardwareComponent component) { if (component == null) { return; } this.hardwareComponents.Add(component); }
public static void Restore(List <HardwareComponent> computer, List <HardwareComponent> dump, string command) { if (dump.Any(h => h.Name == command)) { HardwareComponent hardware = dump.Where(h => h.Name == command).First(); dump.Remove(hardware); computer.Add(hardware); } }
public async Task StandardSqliteStorageModel_UpdateComponent_UpdatesCorrectComponent() { HardwareComponent component = new HardwareComponent("#2", 10, 50, 6, "dudeldu", "super cool", 42); await model.UpdateHardwareComponent(component); var getResultComponent = await model.GetHardwareComponent("#2"); Assert.AreEqual(component.componentName, getResultComponent.componentName); }
public async Task InMemoryDataBase_Update_UpdatesCorrectComponent() { InMemoryDatabaseSubstitute substitute = CreateSubstitute(); HardwareComponent component = new HardwareComponent("#2", 50, 10, 200, "Core i9-9900K", "An overpriced processor", 1); await substitute.UpdateHardwareComponent(component); var getResultComponent = await substitute.GetHardwareComponent("#2"); Assert.AreEqual(component.componentName, getResultComponent.componentName); }
private void Dump(string[] inputArgs) { HardwareComponent componentToDump = this.SystemRepository.RemoveFromRepository(inputArgs[1]); if (componentToDump == null) { return; } this.dumpRepository.AddToRepository(componentToDump); }
public async Task <IActionResult> Create([Bind("ID,Name,Description,DateAdded,DateModified")] HardwareComponent hardwareComponent) { if (ModelState.IsValid) { _context.Add(hardwareComponent); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(hardwareComponent)); }
public HardwareComponent RemoveFromRepository(string componentName) { HardwareComponent component = this.hardwareComponents.FirstOrDefault(x => x.Name == componentName); if (component == null) { return(null); } this.hardwareComponents.Remove(component); return(component); }
public void AttachSoftwareToHardware(SoftwareComponent softwareComponent) { HardwareComponent componentToAttachTo = this.HardwareComponents.FirstOrDefault(x => x.Name == softwareComponent.HardwareName); if (componentToAttachTo == null) { return; } componentToAttachTo.AddComponent(softwareComponent); }
private static void DumpHardware(List <HardwareComponent> hardware, List <HardwareComponent> dumpedHardware, List <string> input) { string hardwareToRemoveName = input[1]; if (hardware.Any(h => h.Name == hardwareToRemoveName)) { HardwareComponent hardwareToRemove = hardware.First(h => h.Name == hardwareToRemoveName); hardware.Remove(hardware.First(h => h.Name == hardwareToRemoveName)); dumpedHardware.Add(hardwareToRemove); } }
private static void ReleaseSoftwareFromHardware(string[] commands, List <HardwareComponent> hardwareComponents, List <SoftwareComponent> softwareComponents) { string desiredHardwareName = commands[1]; string softwareToRemoveName = commands[2]; HardwareComponent desiredComponent = hardwareComponents.FirstOrDefault(x => x.Name == desiredHardwareName); SoftwareComponent unwantedSoftware = softwareComponents.FirstOrDefault(x => x.Name == softwareToRemoveName); if (desiredComponent.Softwares.Any(x => x.Name == softwareToRemoveName)) { desiredComponent.Softwares.Remove(unwantedSoftware); } desiredComponent.ReleaseSoftware(unwantedSoftware); }
public void AddSoftwareToHardware(string hardwareName, SoftwareComponent software) { HardwareComponent hardware = null; if (this.hardwareByName.TryGetValue(hardwareName, out hardware)) { if (hardware.AddSoftware(software)) { this.CapacityInUse += software.CapacityConsumation; this.MemoryInUse += software.MemoryConsumation; this.AddedSoftware++; } } }
/// <summary> /// This method returns only the requested hardware component. /// It fetches the components based on its uid. /// </summary> /// <param name="uid">The uid of the component</param> /// <returns>The requested HardwareComponent</returns> public async Task <HardwareComponent> GetHardwareComponent(string uid) { var command = dbConnection.CreateCommand(); command.CommandText = $@"SELECT * FROM components WHERE ComponentUID='{uid}'"; var reader = await command.ExecuteReaderAsync(); await reader.ReadAsync(); var component = new HardwareComponent(reader.GetString(6), reader.GetInt32(3), reader.GetInt32(1), reader.GetInt32(2), reader.GetString(0), reader.GetString(4), reader.GetInt32(5)); return(component); }
public async Task <Dictionary <string, HardwareComponent> > GetHardwareComponents() { var command = inMemDataBase.CreateCommand(); command.CommandText = @"SELECT * FROM components"; var reader = command.ExecuteReader(); Dictionary <string, HardwareComponent> queryResult = new Dictionary <string, HardwareComponent>(); while (reader.Read()) { HardwareComponent component = new HardwareComponent(reader.GetString(6), reader.GetInt32(3), reader.GetInt32(1), reader.GetInt32(2), reader.GetString(0), reader.GetString(4), reader.GetInt32(5)); queryResult.Add(component.componentUid, component); } return(queryResult); }
/// <summary> /// This method updates a specified component /// </summary> /// <param name="component">The new component information</param> /// <returns></returns> public async Task UpdateHardwareComponent(HardwareComponent component) { var command = dbConnection.CreateCommand(); command.CommandText = $@"UPDATE components SET ComponentName = '{component.componentName}', ComponentRack = {component.componentRack}, ComponentDrawer = {component.componentDrawer}, ComponentAmount = {component.componentAmount}, ComponentNotes = '{component.componentNotes}', ComponentOrderWarningMinimum = {component.componentOrderWarning} WHERE ComponentUID = '{component.componentUid}'; "; await command.ExecuteNonQueryAsync(); }
public void RemoveSoftwareFromHardware(string hardwareName, string softwareName) { HardwareComponent hardware = null; if (this.hardwareByName.TryGetValue(hardwareName, out hardware)) { int capacityBeforeRemoving = hardware.CurrentCapacity; int memoryBeforeRemoving = hardware.CurrentMemory; if (hardware.RemoveSoftware(softwareName)) { this.CapacityInUse -= (capacityBeforeRemoving - hardware.CurrentCapacity); this.MemoryInUse -= (memoryBeforeRemoving - hardware.CurrentMemory); this.AddedSoftware--; } } }
public void Dump(string hardwareComponentName) { HardwareComponent hardware = null; if (this.hardwareByName.TryGetValue(hardwareComponentName, out hardware)) { this.hardwareByName.Remove(hardwareComponentName); this.dumpedHardwareByName.Add(hardware.Name, hardware); this.MaxCapacity -= hardware.MaxCapacity; this.MaxMemory -= hardware.MaxMemory; this.MemoryInUse -= hardware.CurrentMemory; this.CapacityInUse -= hardware.CurrentCapacity; this.AddedSoftware -= hardware.GetSoftwareCount; } }
public void ReleaseSoftwareComponent(string hardwareComponentName, string softwareComponentName) { HardwareComponent hardwareComponent = this.HardwareComponents.FirstOrDefault(x => x.Name == hardwareComponentName); if (hardwareComponent == null) { return; } SoftwareComponent softwareComponent = hardwareComponent.GetSoftwareComponent(softwareComponentName); if (softwareComponent == null) { return; } hardwareComponent.RemoveComponent(softwareComponent); }
public virtual HardwareComponent CreateHardwareComponentComponent(string[] inputArgs) { HardwareComponent newComponent = null; string[] componentData = inputArgs[1].Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries); switch (inputArgs[0]) { case "RegisterPowerHardware": newComponent = this.CreatePowerHardware(componentData); break; case "RegisterHeavyHardware": newComponent = this.CreateHeavyHardware(componentData); break; } return(newComponent); }
/// <summary> /// This method returns a dictionary of type string, HardwareComponent. /// It reads all available components and returns them. /// </summary> /// <returns>Dictionary<string, HardwareComponent></returns> public async Task <Dictionary <string, HardwareComponent> > GetHardwareComponents() { var command = dbConnection.CreateCommand(); command.CommandText = $@"SELECT * FROM components"; var reader = await command.ExecuteReaderAsync(); Dictionary <string, HardwareComponent> components = new Dictionary <string, HardwareComponent>(); while (await reader.ReadAsync()) { HardwareComponent component = new HardwareComponent(reader.GetString(6), reader.GetInt32(3), reader.GetInt32(1), reader.GetInt32(2), reader.GetString(0), reader.GetString(4), reader.GetInt32(5)); components.Add(component.componentUid, component); } return(components); }
public void HardwareComponent_ConstructorArgumentsPassedIn_SavedCorrectly() { string name = "LM324"; string uid = "#001"; int orderWarningLimit = 10; int quantity = 3; int rack = 50; int drawer = 2; string notes = "Great component! 10/10"; HardwareComponent component = new HardwareComponent(componentName: name, componentNotes: notes, componentAmount: quantity, componentDrawer: drawer, componentOrderWarning: orderWarningLimit, componentRack: rack, componentUid: uid); Assert.AreEqual(component.componentUid, uid); Assert.AreEqual(component.componentRack, rack); Assert.AreEqual(component.componentOrderWarning, orderWarningLimit); Assert.AreEqual(component.componentNotes, notes); Assert.AreEqual(component.componentName, name); Assert.AreEqual(component.componentDrawer, drawer); Assert.AreEqual(component.componentAmount, quantity); }
public bool AddComponent(HardwareComponent component) { try { if (String.IsNullOrEmpty(component.RoomUID)) { var room = Company.Buildings[0]?.Rooms[0]; if (room != null) { component.RoomUID = room.UID; room.Components.Add(component); } } return(true); } catch (Exception e) { Console.WriteLine(e.ToString()); return(false); } }
public static void ReleaseSoftwareComponent(List <HardwareComponent> computer, string command) { string[] tokens = command.Split(new[] { ", " }, StringSplitOptions.RemoveEmptyEntries).Select(s => s.Trim()) .ToArray(); string hardwareName = tokens[0]; string softwareName = tokens[1]; if (computer.Any(h => h.Name == hardwareName)) { HardwareComponent hardware = computer.Where(h => h.Name == hardwareName).First(); if (hardware.SeeSoftware().Any(s => s.Name == softwareName)) { SoftwareComponent software = hardware.SeeSoftware().Where(s => s.Name == softwareName).First(); hardware.RemoveSoftwareComponent(software); hardware.UsedCapacity -= software.CapacityConsumption; hardware.UsedMemory -= software.MemoryConsumption; } } }
public string DumpAnalyze() { int countPowerComponents = 0; int countHeavyComponents = 0; int countExpressSoftware = 0; int countLightSoftware = 0; int dumpMemory = 0; int dumpCapacity = 0; foreach (string hardwareName in this.dumpedHardwareByName.Keys) { HardwareComponent component = this.dumpedHardwareByName[hardwareName]; if (component.Type == "Power") { countPowerComponents++; } else { countHeavyComponents++; } countExpressSoftware += component.ExpressSoftwareCount; countLightSoftware += component.LightSoftwareCount; dumpMemory += component.CurrentMemory; dumpCapacity += component.CurrentCapacity; } StringBuilder builder = new StringBuilder(); builder.AppendLine("Dump Analysis"); builder.AppendLine($"Power Hardware Components: {countPowerComponents}"); builder.AppendLine($"Heavy Hardware Components: {countHeavyComponents}"); builder.AppendLine($"Express Software Components: {countExpressSoftware}"); builder.AppendLine($"Light Software Components: {countLightSoftware}"); builder.AppendLine($"Total Dumped Memory: {dumpMemory}"); builder.Append($"Total Dumped Capacity: {dumpCapacity}"); return(builder.ToString()); }
public static void RegisterLightSoftware(List <HardwareComponent> computer, string command) { string[] tokens = command.Split(new[] { ", " }, StringSplitOptions.RemoveEmptyEntries).Select(s => s.Trim()) .ToArray(); string hardwareName = tokens[0]; string softwareName = tokens[1]; long capacity = long.Parse(tokens[2]); long memory = long.Parse(tokens[3]); if (computer.Any(h => h.Name == hardwareName)) { HardwareComponent hardware = computer.Where(h => h.Name == hardwareName).First(); if (hardware.MaximumCapacity - hardware.UsedCapacity >= capacity && hardware.MaximumMemory - hardware.UsedMemory >= memory) { SoftwareComponent software = new LightSoftwareComponent(softwareName, capacity, memory); hardware.AddSoftwareComponent(software); hardware.UsedCapacity += software.CapacityConsumption; hardware.UsedMemory += software.MemoryConsumption; } } }
public static HardwareComponent CreateComponentFromTypeString(string typeString) { HardwareComponent component = null; switch (typeString) { case "Router": component = new Router(); break; case "Switch": component = new Switch(); break; case "AccessPoint": component = new AccessPoint(); break; case "DesktopPc": component = new DesktopPc(); break; case "Notebook": component = new Notebook(); break; case "Server": component = new Server(); break; case "Drucker": component = new Drucker(); break; } return(component); }