public void GetSummaryInformation_ExpectingMemoryAvailable1024()
{
using (var viridianUtils = new ViridianUtils())
{
viridianUtils.SUT_ComputerSystemMO(
ViridianUtils.GetCurrentMethod(),
out uint ReturnValue,
out ManagementPath Job,
out ManagementPath ResultingSystem);
using (var computerSystem = new ComputerSystem(ResultingSystem))
{
var vssdCollection = ViridianUtils.GetVirtualSystemSettingDataListThroughSettingsDefineState(computerSystem);
var RequestedInformation = (uint[])Enum.GetValues(typeof(SummaryInformation.RequestedInformation));
var SettingData = new ManagementPath[] { vssdCollection.First().Path };
ReturnValue = viridianUtils.VSMS.GetSummaryInformation(RequestedInformation, SettingData, out ManagementBaseObject[] SummaryInformation);
using (var summaryInformation = new SummaryInformation(SummaryInformation.First()))
{
Assert.AreEqual(0U, ReturnValue);
Assert.AreEqual(1, vssdCollection.Count);
Assert.IsNotNull(SummaryInformation);
Assert.AreEqual(1, SummaryInformation.Length);
Assert.AreEqual(0U, summaryInformation.MemoryUsage);
}
}
}
}
public void RequestStateChange_ExpectingEnabledStateIsTwo()
{
using (var viridianUtils = new ViridianUtils())
{
viridianUtils.SUT_ComputerSystemMO(
ViridianUtils.GetCurrentMethod(),
out uint ReturnValue,
out ManagementPath Job,
out ManagementPath ResultingSystem);
using (var computerSystem = new ComputerSystem(ResultingSystem))
{
ReturnValue = computerSystem.RequestStateChange(2, null, out Job);
ViridianUtils.WaitForConcreteJobToEnd(Job);
computerSystem.UpdateObject();
Assert.IsNotNull(ResultingSystem);
Assert.AreEqual(4096U, ReturnValue);
Assert.AreEqual(2U, computerSystem.EnabledState);
ReturnValue = computerSystem.RequestStateChange(3, null, out Job);
ViridianUtils.WaitForConcreteJobToEnd(Job);
}
}
}
public void GetVirtualSystemThumbnailImage_ExpectingNotNullImage()
{
using (var viridianUtils = new ViridianUtils())
{
viridianUtils.SUT_ComputerSystemMO(
ViridianUtils.GetCurrentMethod(),
out uint ReturnValue,
out ManagementPath Job,
out ManagementPath ResultingSystem);
using (var computerSystem = new ComputerSystem(ResultingSystem))
{
ReturnValue = computerSystem.RequestStateChange(2, null, out Job);
ViridianUtils.WaitForConcreteJobToEnd(Job);
ReturnValue = viridianUtils.VSMS.GetVirtualSystemThumbnailImage(1000, ResultingSystem, 1000, out byte[] ImageData);
Assert.AreEqual(0U, ReturnValue);
Assert.IsNotNull(ImageData);
ReturnValue = computerSystem.RequestStateChange(3, null, out Job);
}
ViridianUtils.WaitForConcreteJobToEnd(Job);
}
}
protected void Page_Load(object sender, EventArgs e)
{
EditEnabled = CurrentModule.Permissions.Allowed(OperationType.Edit, CurrentUser);
if (!IsPostBack)
{
pnlEdit.Visible = true;
string ipAddress = IPNetworking.GetIP4Address(HttpContext.Current.Request);
kiosk = CheckInController.GetCurrentKiosk(ipAddress);
if (kiosk != null)
{
litLegend.Text = string.Format("Edit '{0}' Kiosk", kiosk.SystemName);
btnSave.Text = "Save";
EditKiosk(kiosk, ipAddress);
}
else
{
litLegend.Text = "Register New Kiosk";
btnSave.Text = "Add New";
EditKiosk(IPNetworking.GetHostName(ipAddress), ipAddress);
}
}
else
{
ViewState["returnURL"] = Request.UrlReferrer.ToString();
}
}
private void EditKiosk(ComputerSystem kiosk, string ipAddress)
{
hfSystemID.Value = kiosk.SystemId.ToString();
LoadPrinters();
LoadLocations();
CurrentPortalPage.TemplateControl.Title = kiosk.SystemName;
txtName.Text = kiosk.SystemName;
txtDnsName.Text = kiosk.DNSName;
txtIPAddress.Text = ipAddress;
txtDescription.Text = kiosk.Notes;
if (kiosk.SystemId != -1)
{
if (kiosk.Printer != null)
{
ddlPrinters.Items.FindByValue(kiosk.Printer.PrinterId.ToString()).Selected = true;
lblPrinterDescription.Text = kiosk.Printer.PrinterDescription;
}
else
{
ddlPrinters.Text = "-1";
}
foreach (Location location in kiosk.Locations)
{
tvLocations.FindNodeById(location.LocationId.ToString()).Checked = true;
}
}
btnSave.Visible = EditEnabled;
}
public void CreatingSCSIController_ExpectingOneRASDOfTypeSCSIController()
{
using (var viridianUtils = new ViridianUtils())
{
viridianUtils.SUT_ComputerSystemMO(
ViridianUtils.GetCurrentMethod(),
out uint ReturnValue,
out ManagementPath Job,
out ManagementPath ResultingSystem);
using (var primordialResourcePool = ViridianUtils.GetPrimordialResourcePool("Microsoft:Hyper-V:Synthetic SCSI Controller"))
using (var allocationCapabilities = ViridianUtils.GetAllocationCapabilities(primordialResourcePool))
using (var resourceAllocationSettingData = ViridianUtils.GetDefaultResourceAllocationSettingData(allocationCapabilities))
using (var computerSystem = new ComputerSystem(ResultingSystem))
using (var virtualSystemSettingData = ViridianUtils.GetVirtualSystemSettingDataListThroughSettingsDefineState(computerSystem).First())
{
var AffectedConfiguration = virtualSystemSettingData.Path;
var ResourceSettings = new string[] { resourceAllocationSettingData.LateBoundObject.GetText(TextFormat.WmiDtd20) };
ReturnValue = viridianUtils.VSMS.AddResourceSettings(AffectedConfiguration, ResourceSettings, out Job, out ManagementPath[] ResultingResourceSettings);
var rasdCollection = ViridianUtils.GetResourceAllocationgSettingData(virtualSystemSettingData, 6, "Microsoft:Hyper-V:Synthetic SCSI Controller");
Assert.AreEqual(0U, ReturnValue);
Assert.AreEqual(1, rasdCollection.Count);
Assert.AreEqual(1, ResultingResourceSettings.Length);
}
}
}
public async Task WatchVirtualSystemSettingDataCreation_ExpectTheSameConfigurationIDInObjectResultedAsTheOneDefined()
{
var watcherTask = Task.Run(() =>
{
var sut = EventWatcherFactory.GetWatcher(Scope.Virtualization.ScopeObject, InstanceCreationEvent.ClassName, new TimeSpan(0, 0, 100), VirtualSystemSettingData.ClassName);
var moInstanceCreationEvent = sut.WaitForNextEvent();
sut.Stop();
return(moInstanceCreationEvent);
}).ConfigureAwait(true);
using (var viridianUtils = new ViridianUtils())
{
viridianUtils.SUT_ComputerSystemMO(
ViridianUtils.GetCurrentMethod(),
out uint ReturnValue,
out ManagementPath Job,
out ManagementPath ResultingSystem);
using (var instanceCreationEvent = new InstanceCreationEvent(await watcherTask))
using (var virtualSystemSettingDataFromEvent = new VirtualSystemSettingData(instanceCreationEvent.TargetInstance))
using (var computerSystemAsDefineSystemResult = new ComputerSystem(ResultingSystem))
using (var virtualSystemSettingDataFromResultingSystem = ViridianUtils.GetVirtualSystemSettingDataListThroughSettingsDefineState(computerSystemAsDefineSystemResult).First())
{
Assert.IsNotNull(virtualSystemSettingDataFromEvent);
Assert.IsTrue(string.Compare(virtualSystemSettingDataFromResultingSystem.ConfigurationID, virtualSystemSettingDataFromEvent.ConfigurationID, false, CultureInfo.InvariantCulture) == 0);
}
Assert.AreEqual(0U, ReturnValue);
}
}
public void GettingProcessorSettingDataListOfVirtualSystemSettingData_ExpectingOne()
{
using (var viridianUtils = new ViridianUtils())
{
viridianUtils.SUT_ComputerSystemMO(
ViridianUtils.GetCurrentMethod(),
out uint ReturnValue,
out ManagementPath Job,
out ManagementPath ResultingSystem);
using (var computerSystem = new ComputerSystem(ResultingSystem))
{
ReturnValue = computerSystem.RequestStateChange(2, null, out Job);
ViridianUtils.WaitForConcreteJobToEnd(Job);
computerSystem.UpdateObject();
var vssdCollection = ViridianUtils.GetVirtualSystemSettingDataListThroughSettingsDefineState(computerSystem);
var sut = ViridianUtils.GetProcessorSettingDataList(vssdCollection.First());
Assert.AreEqual(1, vssdCollection.Count);
Assert.AreEqual(1, sut.Count);
ReturnValue = computerSystem.RequestStateChange(3, null, out Job);
}
ViridianUtils.WaitForConcreteJobToEnd(Job);
}
}
public void GetInstancesWithCondition_ExpectingOneElementBeingHostMachine()
{
var sut = ComputerSystem.GetInstances($"Name='{Environment.MachineName}'");
Assert.AreEqual(sut.Count, 1);
Assert.AreEqual(sut.Cast <ComputerSystem>().ToList().FirstOrDefault()?.Name, Environment.MachineName);
}
public void CreateSnapshot_ExpectingOneSnapshot()
{
using (var viridianUtils = new ViridianUtils())
{
viridianUtils.SUT_ComputerSystemMO(
ViridianUtils.GetCurrentMethod(),
out uint ReturnValue,
out ManagementPath Job,
out ManagementPath ResultingSystem);
viridianUtils.SUT_VirtualSystemSettingDataMO(
ViridianUtils.GetCurrentMethod(),
ResultingSystem,
out ReturnValue,
out Job,
out ManagementPath ResultingSnapshot);
ViridianUtils.WaitForConcreteJobToEnd(Job);
using (var computerSystem = new ComputerSystem(ResultingSystem))
{
var sovsCollection = ViridianUtils.GetSnapshotOfVirtualSystemList(computerSystem);
var mcsibCollection = ViridianUtils.GetMostCurrentSnapshotInBranchList(computerSystem);
Assert.AreEqual(1, sovsCollection.Count);
Assert.AreEqual(1, mcsibCollection.Count);
}
}
}
public void CreateInstance_ExpectingNotNullLateBoundObject()
{
using (var sut = ComputerSystem.CreateInstance())
{
Assert.IsNotNull(sut.LateBoundObject);
}
}
/// <summary>Copy constructor.</summary>
public ComputerSystem(ComputerSystem src)
{
totalResources = src.totalResources;
allocatedResources = src.allocatedResources;
damage = src.damage;
overclock = src.overclock;
}
public static List <Occurrence> SetupOccurrenceSearchMultipleOccurrences(ComputerSystem kiosk)
{
List <Occurrence> occurrences = new List <Occurrence>();
var occurrence = SetupOccurrenceSearch(kiosk);
occurrences.Add(occurrence);
var location = CheckInTestFactories.CreateLocation();
location.OccurrenceTypes.Add(occurrence.OccurrenceType);
location.Save(CheckInTestConstants.USER_ID);
occurrence.OccurrenceType.Locations.Add(location);
occurrence.OccurrenceType.Save(CheckInTestConstants.USER_ID);
kiosk.Locations.Add(location);
kiosk.Save();
kiosk.SaveLocations(new[] { location.LocationId });
var newOccurrence = CheckInTestFactories.CreateOccurrence();
newOccurrence.OccurrenceTypeID = occurrence.OccurrenceTypeID;
newOccurrence.StartTime = occurrence.StartTime;
newOccurrence.LocationID = location.LocationId;
newOccurrence.Save(CheckInTestConstants.USER_ID);
occurrences.Add(newOccurrence);
return(occurrences);
}
static public void GetComputerSystem(Dictionary <string, object> args, out ComputerSystem ComputerSystem)
{
ComputerSystem = ComputerSystem.GetInstances()
.Where((cs) =>
{
return(args.ToList().All(pair =>
{
var propertyName = pair.Key;
var propertyValue = pair.Value;
switch (propertyName)
{
case nameof(cs.Name):
var computerSystemName = Convert.ToString(cs.LateBoundObject[nameof(cs.Name)]);
var Name = Convert.ToString(propertyValue);
return string.Compare(computerSystemName, Name, true, CultureInfo.InvariantCulture) == 0;
default:
throw new Exception("Property value not handled or invalid!");
}
}));
})
.ToList()
.First();
}
public void TestMethod1()
{
ComputerSystem mediator = new ComputerSystem();
Computer computer = new Computer(mediator);
Keyboard keyboard = new Keyboard(mediator);
Screen screen = new Screen(mediator);
}
public static List <Occurrence> SetupOccurrenceSearchRoomBalancing(ComputerSystem kiosk)
{
List <Occurrence> occurrences = SetupOccurrenceSearchMultipleOccurrences(kiosk);
var attribute = new OccurrenceTypeAttribute
{
OccurrenceTypeId = occurrences.First().OccurrenceTypeID,
IsRoomBalancing = true
};
attribute.Save(CheckInTestConstants.USER_ID);
var person = CheckInTestFactories.CreateFamilyMember();
person.Save(CheckInTestConstants.ORG_ID, CheckInTestConstants.USER_ID, false);
var attendance = new OccurrenceAttendance
{
OccurrenceID = occurrences.First().OccurrenceID,
PersonID = person.PersonID,
Attended = true,
CheckInTime = DateTime.Now.AddMinutes(-2)
};
attendance.Save(CheckInTestConstants.USER_ID);
return(occurrences);
}
public void ApplySnapshot_ExpectingReturnLastSnapshotApplied()
{
using (var viridianUtils = new ViridianUtils())
{
viridianUtils.SUT_ComputerSystemMO(
ViridianUtils.GetCurrentMethod(),
out uint ReturnValue,
out ManagementPath Job,
out ManagementPath ResultingSystem);
viridianUtils.SUT_VirtualSystemSettingDataMO(
ViridianUtils.GetCurrentMethod(),
ResultingSystem,
out ReturnValue,
out Job,
out ManagementPath ResultingSnapshot);
ViridianUtils.WaitForConcreteJobToEnd(Job);
using (var computerSystem = new ComputerSystem(ResultingSystem))
{
var vssdCollection = ViridianUtils.GetVirtualSystemSettingDataListThroughSnapshotOfVirtualSystem(computerSystem);
ReturnValue = viridianUtils.VSSS.ApplySnapshot(vssdCollection.First().Path, out Job);
ViridianUtils.WaitForConcreteJobToEnd(Job);
var lasCollection = ViridianUtils.GetLastAppliedSnapshotList(computerSystem);
Assert.AreEqual(1, vssdCollection.Count);
}
Assert.AreEqual(4096U, ReturnValue);
}
}
public static Occurrence SetupOccurrenceSearch(ComputerSystem kiosk)
{
const string userID = CheckInTestConstants.USER_ID;
var occurrence = CheckInTestFactories.CreateOccurrence();
var type = CheckInTestFactories.CreateOccurrenceType();
var group = CheckInTestFactories.CreateOccurrenceTypeGroup();
group.Save(userID);
type.GroupId = group.GroupId;
type.Save(userID);
group.OccurrenceTypes.Add(type);
group.Save(userID);
occurrence.OccurrenceTypeID = type.OccurrenceTypeId;
occurrence.Save(userID);
type.Occurrences.Add(occurrence);
type.Save(userID);
var location = CheckInTestFactories.CreateLocation();
location.OccurrenceTypes.Add(type);
location.Save(userID);
occurrence.LocationID = location.LocationId;
occurrence.Save(userID);
type.Locations.Add(location);
type.Save(userID);
kiosk.Locations.Add(location);
kiosk.Save();
kiosk.SaveLocations(new[] { location.LocationId });
return(occurrence);
}
public void GetInstances_ExpectingAtLeastOneElementBeingHostMachine()
{
var sut = ComputerSystem.GetInstances();
Assert.IsTrue(sut.Count > 0);
Assert.AreEqual(sut.Cast <ComputerSystem>().ToList().FirstOrDefault()?.Name, Environment.MachineName);
}
public void AddEthernetConnectionToSyntheticEthernetPort_ExpectingOne()
{
using (var viridianUtils = new ViridianUtils())
{
viridianUtils.SUT_VirtualEthernetSwitchSettingDataMO(
ViridianUtils.GetCurrentMethod(),
"notes",
out uint ReturnValue,
out ManagementPath Job,
out ManagementPath ResultingSystem);
using (var virtualEthernetSwitch = new VirtualEthernetSwitch(ResultingSystem))
{
viridianUtils.SUT_ComputerSystemMO(
ViridianUtils.GetCurrentMethod(),
out ReturnValue,
out Job,
out ResultingSystem);
using (var primordialResourcePool = ViridianUtils.GetPrimordialResourcePool("Microsoft:Hyper-V:Synthetic Ethernet Port"))
using (var allocationCapabilities = ViridianUtils.GetAllocationCapabilities(primordialResourcePool))
using (var syntheticEthernetPortSettingData = ViridianUtils.GetDefaultSyntheticEthernetPortSettingData(allocationCapabilities))
using (var computerSystem = new ComputerSystem(ResultingSystem))
using (var virtualSystemSettingData = ViridianUtils.GetVirtualSystemSettingDataListThroughSettingsDefineState(computerSystem).First())
{
syntheticEthernetPortSettingData.LateBoundObject["VirtualSystemIdentifiers"] = new string[] { Guid.NewGuid().ToString("B") };
syntheticEthernetPortSettingData.LateBoundObject["ElementName"] = ViridianUtils.GetCurrentMethod();
syntheticEthernetPortSettingData.LateBoundObject["StaticMacAddress"] = false;
var AffectedConfiguration = virtualSystemSettingData.Path;
var ResourceSettings = new string[] { syntheticEthernetPortSettingData.LateBoundObject.GetText(TextFormat.WmiDtd20) };
ReturnValue = viridianUtils.VSMS.AddResourceSettings(AffectedConfiguration, ResourceSettings, out Job, out ManagementPath[] ResultingResourceSettings);
using (var syntheticEthernetPortSettingDataResulted = new SyntheticEthernetPortSettingData(ResultingResourceSettings[0]))
using (var ethernetConnectionPrimordialPool = ViridianUtils.GetPrimordialResourcePool("Microsoft:Hyper-V:Ethernet Connection"))
using (var allocationCapabilitiesEthernetConnection = ViridianUtils.GetAllocationCapabilities(ethernetConnectionPrimordialPool))
using (var ethernetPortAllocationSettingData = ViridianUtils.GetDefaultEthernetPortAllocationSettingData(allocationCapabilitiesEthernetConnection))
{
ethernetPortAllocationSettingData.LateBoundObject["Parent"] = syntheticEthernetPortSettingDataResulted.Path.Path;
ethernetPortAllocationSettingData.LateBoundObject["HostResource"] = new string[] { virtualEthernetSwitch.Path.Path };
AffectedConfiguration = virtualSystemSettingData.Path;
ResourceSettings = new string[] { ethernetPortAllocationSettingData.LateBoundObject.GetText(TextFormat.WmiDtd20) };
ReturnValue = viridianUtils.VSMS.AddResourceSettings(AffectedConfiguration, ResourceSettings, out Job, out ResultingResourceSettings);
var sepsdCollection = ViridianUtils.GetSyntheticEthernetPortSettingData(virtualSystemSettingData, 10, "Microsoft:Hyper-V:Synthetic Ethernet Port");
var epsdCollection = ViridianUtils.GetEthernetPortAllocationSettingData(virtualSystemSettingData, 33, "Microsoft:Hyper-V:Ethernet Connection");
Assert.AreEqual(0U, ReturnValue);
Assert.AreEqual(1, sepsdCollection.Count);
Assert.AreEqual(1, epsdCollection.Count);
Assert.AreEqual(1, ResultingResourceSettings.Length);
Assert.IsNotNull(virtualEthernetSwitch);
}
}
}
}
}
public static List <SnapshotOfVirtualSystem> GetSnapshotOfVirtualSystemList(ComputerSystem ComputerSystem)
{
return
(SnapshotOfVirtualSystem.GetInstances()
.Cast <SnapshotOfVirtualSystem>()
.Where((sovs) => string.Compare(sovs.Antecedent.Path, ComputerSystem.Path.Path, true, CultureInfo.InvariantCulture) == 0)
.ToList());
}
public static List <LastAppliedSnapshot> GetLastAppliedSnapshotList(ComputerSystem ComputerSystem)
{
return
(LastAppliedSnapshot.GetInstances()
.Cast <LastAppliedSnapshot>()
.Where((las) => string.Compare(las.Antecedent.Path, ComputerSystem.Path.Path, true, CultureInfo.InvariantCulture) == 0)
.ToList());
}
private static string SolvePart2(List <string> input)
{
var system = new ComputerSystem(new DecoderShipPart2());
system.ExecuteProgram(input);
return(system.SumOfAddressValues().ToString());
}
private void EditKiosk(string dnsName, string ipAddress)
{
kiosk = new ComputerSystem();
kiosk.Kiosk = true;
kiosk.DNSName = dnsName;
kiosk.SystemName = dnsName.Split('.')[0];
kiosk.Notes = "A kiosk for use with Arena check-in.";
EditKiosk(kiosk, ipAddress);
}
public ActionResult BuildSystem(int employeeID, string RAM, string HDDSize)
{
Employee employee = db.Employees.Find(employeeID);
ComputerSystem computerSystem = new ComputerSystem(RAM, HDDSize);
employee.SystemConfigurationDetails = computerSystem.Build();
db.Entry(employee).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
private DataRow createDataRowFromComputerSystem(DataTable table, ComputerSystem system)
{
DataRow result = table.NewRow();
result["Role"] = system.Role;
result["Domain"] = system.Domain;
result["Name"] = system.Name;
result["Type"] = system.Type;
return(result);
}
public virtual bool Assert(ComputerSystem computer, BIOS bios, IEnumerable <DiskDrive> disks, IEnumerable <PnPEntity> devices, IEnumerable <string> processes, IEnumerable <WindowsService> services)
{
#if DEBUG
Console.WriteLine();
Console.WriteLine("--------------------------------------------------------------");
Console.WriteLine("Asserting {0}", this.GetType().Name);
#endif
bool computerIsVirtual = IsVirtual(computer);
bool biosIsVirtual = IsVirtual(bios);
bool containsVirtualDisk = ContainsDisk(disks);
bool containsVirtualDevice = ContainsDevice(devices);
bool containsVirtualProcess = ContainsProcess(processes);
bool containsVirtualService = ContainsService(services);
#if DEBUG
if (computerIsVirtual)
{
Console.WriteLine("Detected as virtual machine given key computer information.");
}
if (biosIsVirtual)
{
Console.WriteLine("Detected as virtual machine given bios information.");
}
if (containsVirtualDisk)
{
Console.WriteLine("Detected as virtual machine given hard disk information.");
}
if (containsVirtualDevice)
{
Console.WriteLine("Detected as virtual machine given PnP devices information.");
}
if (containsVirtualProcess)
{
Console.WriteLine("Detected as virtual machine given processes information.");
}
if (containsVirtualService)
{
Console.WriteLine("Detected as virtual machine given Windows services information.");
}
#endif
return(computerIsVirtual ||
biosIsVirtual ||
containsVirtualDisk ||
containsVirtualDevice ||
containsVirtualProcess ||
containsVirtualService);
}
public static Occurrence SetupOccurrenceSearchInvalidMembershipRequired(ComputerSystem kiosk, Person person)
{
var occurrence = SetupOccurrenceSearch(kiosk);
var eventProfile = CheckInTestFactories.CreateEventProfile(occurrence);
eventProfile.Save(CheckInTestConstants.USER_ID);
occurrence.OccurrenceType.MembershipRequired = true;
occurrence.OccurrenceType.SyncWithProfile = eventProfile.ProfileID;
occurrence.Save(CheckInTestConstants.USER_ID);
return(occurrence);
}
public static Occurrence SetupOccurrenceSearchSpecialNeeds(ComputerSystem kiosk)
{
var occurrence = SetupOccurrenceSearch(kiosk);
var attribute = new OccurrenceTypeAttribute
{
IsSpecialNeeds = true,
OccurrenceTypeId = occurrence.OccurrenceTypeID
};
attribute.Save(CheckInTestConstants.USER_ID);
return(occurrence);
}
private static void AddComputerSystemNode(TreeNode computerNode, ComputerSystem.System computerSystem)
{
TreeNode computerSystemNode = new TreeNode("Computer System");
computerSystemNode.Nodes.Add("Currently logged on user - " + computerSystem.LoggedOnUser);
computerSystemNode.Nodes.Add("Manufacturer - " + computerSystem.Manufacturer);
computerSystemNode.Nodes.Add("Model - " + computerSystem.Model);
computerSystemNode.Nodes.Add("Domain - " + computerSystem.Domain);
computerSystemNode.Nodes.Add("Total Memory - " + FormatBytes(computerSystem.TotalMemory));
computerNode.Nodes.Add(computerSystemNode);
}
public override bool IsVirtual(ComputerSystem computer)
{
if (computer != null)
{
return(computer.Manufacturer.Contains("vmware") ||
computer.Model.Contains("vmware") ||
computer.OEMStringArray.Contains("virtual"));
}
else
{
return(false);
}
}
public Tui()
{
var scope = Wmi.GetScope();
var enumOptions = new EnumerationOptions {
EnsureLocatable = true
};
_system = ComputerSystem.GetInstances(scope, enumOptions).Cast <ComputerSystem>().FirstOrDefault();
_processor = Processor.GetInstances(scope, enumOptions).Cast <Processor>().FirstOrDefault();
_networkAdapters = NetworkAdapter.GetInstances(scope, enumOptions)
.Cast <NetworkAdapter>()
.Where(n => n.PhysicalAdapter);
_operatingSystem = new OperatingSystem0(scope);
}
public Keyboard(ComputerSystem mediator)
{
this.mediator = mediator;
}
public static ComputerSystem Get_ComputerSystem(ManagementScope scope)
{
ComputerSystem result = new ComputerSystem();
ObjectQuery wmiquery = new ObjectQuery("SELECT * FROM Win32_BIOS");
ManagementObjectSearcher searcher = new ManagementObjectSearcher(scope, wmiquery);
ManagementObjectCollection coll = searcher.Get();
foreach (ManagementObject queryObj in coll)
{
if (queryObj["Name"] != null) result.BIOS.Name = queryObj["Name"].ToString().Trim(' ');
if (queryObj["Manufacturer"] != null) result.BIOS.Manufacturer = queryObj["Manufacturer"].ToString().Trim(' ');
if (queryObj["ReleaseDate"] != null) result.BIOS.ReleaseDate = queryObj["ReleaseDate"].ToString().Trim(' ');
if (queryObj["SerialNumber"] != null) result.BIOS.SerialNumber = queryObj["SerialNumber"].ToString().Trim(' ');
if (queryObj["SMBIOSBIOSVersion"] != null) result.BIOS.SMBIOSVersion = queryObj["SMBIOSBIOSVersion"].ToString().Trim(' ');
}
wmiquery = new ObjectQuery("SELECT * FROM Win32_ComputerSystemProduct");
searcher = new ManagementObjectSearcher(scope, wmiquery);
coll = searcher.Get();
foreach (ManagementObject queryObj in coll)
{
if (queryObj["Version"] != null) result.Model = queryObj["Version"].ToString().Trim(' ');
if (queryObj["Vendor"] != null) result.Manufacturer = queryObj["Vendor"].ToString().Trim(' ');
if (queryObj["UUID"] != null) result.UUID = queryObj["UUID"].ToString().Trim(' ');
if (queryObj["Name"] != null) result.ProductNumber = queryObj["Name"].ToString().Trim(' ');
}
wmiquery = new ObjectQuery("SELECT * FROM Win32_SystemEnclosure");
searcher = new ManagementObjectSearcher(scope, wmiquery);
coll = searcher.Get();
foreach (ManagementObject queryObj in coll)
{
if (queryObj["ChassisTypes"] != null) result.Chassis.CaseType = ((ushort[])queryObj["ChassisTypes"])[0].ToString().Trim(' ');
if (queryObj["Manufacturer"] != null) result.Chassis.Manufacturer = queryObj["Manufacturer"].ToString().Trim(' ');
if (queryObj["SerialNumber"] != null) result.Chassis.SerialNumber = queryObj["SerialNumber"].ToString().Trim(' ');
if (queryObj["SMBIOSAssetTag"] != null) result.Chassis.AssetTag = queryObj["SMBIOSAssetTag"].ToString().Trim(' ');
}
wmiquery = new ObjectQuery("SELECT * FROM Win32_BaseBoard");
searcher = new ManagementObjectSearcher(scope, wmiquery);
coll = searcher.Get();
foreach (ManagementObject queryObj in coll)
{
if (queryObj["Product"] != null) result.Motherboard.Name = queryObj["Product"].ToString().Trim(' ');
if (queryObj["Manufacturer"] != null) result.Motherboard.Manufacturer = queryObj["Manufacturer"].ToString().Trim(' ');
if (queryObj["SerialNumber"] != null) result.Motherboard.SerialNumber = queryObj["SerialNumber"].ToString().Trim(' ');
if (queryObj["Version"] != null) result.Motherboard.Version = queryObj["Version"].ToString().Trim(' ');
}
wmiquery = new ObjectQuery("SELECT * FROM Win32_PortConnector");
searcher = new ManagementObjectSearcher(scope, wmiquery);
coll = searcher.Get();
foreach (ManagementObject queryObj in coll)
{
SystemPort p = new SystemPort();
if (queryObj["ExternalReferenceDesignator"] != null) p.Name = queryObj["ExternalReferenceDesignator"].ToString().Trim(' ');
if(p.Name == "")
{
if (queryObj["InternalReferenceDesignator"] != null) p.Name = queryObj["InternalReferenceDesignator"].ToString().Trim(' ');
}
if (queryObj["PortType"] != null) p.PortType = queryObj["PortType"].ToString().Trim(' ');
if (queryObj["ConnectorType"] != null) p.ConnectorType = ((ushort[])queryObj["ConnectorType"])[0].ToString().Trim(' ');
result.SystemPorts.Add(p);
}
wmiquery = new ObjectQuery("SELECT * FROM Win32_SystemSlot");
searcher = new ManagementObjectSearcher(scope, wmiquery);
coll = searcher.Get();
foreach (ManagementObject queryObj in coll)
{
SystemSlot s = new SystemSlot();
if (queryObj["SlotDesignation"] != null) s.SlotDesignation = queryObj["SlotDesignation"].ToString().Trim(' ');
if (queryObj["CurrentUsage"] != null) s.Availability = queryObj["CurrentUsage"].ToString().Trim(' ');
result.SystemSlots.Add(s);
}
return result;
}
public Screen(ComputerSystem mediator)
{
this.mediator = mediator;
}
public Computer(ComputerSystem mediator)
{
this.mediator = mediator;
}
private static void AddOperatingSystemNode(TreeNode computerNode, ComputerSystem.OperatingSystem operatingSystem)
{
TreeNode operatingSystemNode = new TreeNode("Operating System");
operatingSystemNode.Nodes.Add("Name - " + operatingSystem.Name);
operatingSystemNode.Nodes.Add("Version - " + operatingSystem.Version);
operatingSystemNode.Nodes.Add("OS Serial Number - " + operatingSystem.SerialNumber);
operatingSystemNode.Nodes.Add("Service Packs - " + operatingSystem.ServicePack);
operatingSystemNode.Nodes.Add("Windows Directory - " + operatingSystem.WindowsDirectory);
operatingSystemNode.Nodes.Add("Free Physical Memory - " + FormatBytes(operatingSystem.FreePhysicalMemory));
operatingSystemNode.Nodes.Add("Free Virtual Memory - " + FormatBytes(operatingSystem.FreeVirtualMemory));
operatingSystemNode.Nodes.Add("Install Date - " + operatingSystem.InstallDate.ToString());
operatingSystemNode.Nodes.Add("Local Date Time - " + operatingSystem.LocalDateTime.ToString());
operatingSystemNode.Nodes.Add("Last Boot Time - " + operatingSystem.LastBootUpTime.ToString());
computerNode.Nodes.Add(operatingSystemNode);
}
