public async void AsyncUpdateBiosInformation()
{
IsModelInformationBeingUpdated = true;
ModelInformationUpdateProgress = "Loading BIOS data...";
Bios = await Task.Run(() =>
{
IServiceFactory sf = ServiceFactoryProducer.GetServiceFactory();
IBIOSService bs = sf.CreateBIOSService();
return(bs.GetBIOS());
});
IsModelInformationBeingUpdated = false;
}
private async void AsyncUpdateGroupUserInformation()
{
IsModelInformationBeingUpdated = true;
ModelInformationUpdateProgress = "Loading user and group information...";
GroupUserData = await Task.Run(() =>
{
IServiceFactory sf = ServiceFactoryProducer.GetServiceFactory();
IGroupUserService iguf = sf.CreateGroupUserService();
return(iguf.GetGroupUserDictionary());
});
IsModelInformationBeingUpdated = false;
}
public async void AsyncUpdateShareInformation()
{
IsModelInformationBeingUpdated = true;
List <Share> shares = await Task.Run(() =>
{
IServiceFactory sf = ServiceFactoryProducer.GetServiceFactory();
IShareService ss = sf.CreateShareService();
return(ss.GetShares());
});
foreach (Share share in shares)
{
Shares.Add(share);
}
IsModelInformationBeingUpdated = false;
}
public async void AsyncUpdateNetworkAdapterInformation(object parameter = null)
{
IsModelInformationBeingUpdated = true;
List <NetworkAdapter> nads = await Task.Run(() =>
{
IServiceFactory sf = ServiceFactoryProducer.GetServiceFactory();
INetworkAdapterService inas = sf.CreateNetworkAdapterService();
return(inas.GetNetworkAdapters());
});
foreach (NetworkAdapter nad in nads)
{
_adapters.Add(nad);
}
IsModelInformationBeingUpdated = false;
}
public async void AsyncUpdateIp4RoutingTableInformation()
{
IsModelInformationBeingUpdated = true;
IServiceFactory sf = ServiceFactoryProducer.GetServiceFactory();
IIP4RoutingTableService ip4rt = sf.CreateIP4RoutingTableService();
ModelInformationUpdateProgress = "Loading Ip4 routing data...";
IP4Routes = await Task.Run(() =>
{
return(ip4rt.GetRoutes());
});
RaisePropertyChanged("IP4Routes");
IsModelInformationBeingUpdated = false;
}
public async void AsyncUpdateStartupEntryInformation()
{
IServiceFactory sf = ServiceFactoryProducer.GetServiceFactory();
IStartupEntryService rs = sf.CreateStartupEntryService();
IsModelInformationBeingUpdated = true;
ModelInformationUpdateProgress = "Loading startup entry data...";
StartupEntries = await Task.Run(() =>
{
return(rs.GetStartupEntries());
});
RaisePropertyChanged("StartupEntries");
IsModelInformationBeingUpdated = false;
}
public async void AsyncUpdateEnvironmentVariableInformation()
{
IsModelInformationBeingUpdated = true;
IServiceFactory sf = ServiceFactoryProducer.GetServiceFactory();
IEnvironmentVariableService evs = sf.CreateEnvironmentVariableService();
ModelInformationUpdateProgress = "Loading environment variable information...";
EnvironmentVariables = await Task.Run(() =>
{
return(evs.GetEnvironmentVariables());
});
RaisePropertyChanged("EnvironmentVariables");
IsModelInformationBeingUpdated = false;
}
public async void AsyncUpdateSystemInformation(object parameter = null)
{
IsModelInformationBeingUpdated = true;
_modelActivity = "(Fetching System Info)";
RaisePropertyChanged("ModelTarget");
UpdateSystemInformationCommand.RaiseCanExecuteChanged();
System = await Task.Run(() =>
{
IServiceFactory sf = ServiceFactoryProducer.GetServiceFactory();
IComputerSystemService css = sf.CreateComputerSystemService();
return(css.GetComputerSystem());
});
CpuInfo = new CPUInfoViewModel(_system.CpuInfo);
IsModelInformationBeingUpdated = false;
_modelActivity = "(Idle)";
PhysicalMemoryCount = System.PhysicalMemoryCollection.Count;
ulong tpm = 0;
foreach (PhysicalMemory pm in System.PhysicalMemoryCollection)
{
tpm += pm.Capacity;
}
TotalPhysicalMemoryInt = tpm;
FreePhysicalMemoryInt = System.FreePhysicalMemory;
UsedPhysicalMemoryInt = TotalPhysicalMemoryInt - FreePhysicalMemoryInt;
MemoryAllocation = _usedPhysicalMemoryInt / 1024 / 1024 + " / " + _totalPhysicalMemoryInt / 1024 / 1024 + " MegaBytes";
RaisePropertyChanged("ModelTarget");
UpdateSystemInformationCommand.RaiseCanExecuteChanged();
}
public async void AsyncUpdateProcessTreeInformation()
{
IsModelInformationBeingUpdated = true;
ModelInformationUpdateProgress = "Fetching process data...";
List <Process> processList = await Task.Run(() =>
{
IServiceFactory sf = ServiceFactoryProducer.GetServiceFactory();
IProcessService ps = sf.CreateProcessService();
return(ps.GetProcesses());
});
ModelInformationUpdateProgress = $"Loaded information about {processList.Count} processes!";
if (processList != null && processList.Count > 0)
{
_processesFlat.Clear();
_topFiveProcessByDataRead.Clear();
_topFiveProcessByDataWritten.Clear();
_topFiveProcessByPhysicalMemory.Clear();
_processes.Clear();
SelectedProcess = null;
ProcessesDataReadSeriesCollection.Clear();
ProcessesMemoryUsageSeriesCollection.Clear();
ProcessesDataWrittenSeriesCollection.Clear();
processList = processList.OrderByDescending(o => o.PhysicalMemory).ToList();
foreach (Process proc in processList)
{
_processesFlat.Add(proc);
if (proc.IsOrphanProcess)
{
Processes.Add(proc);
}
}
for (int i = 0; i < 5; i++)
{
_topFiveProcessByPhysicalMemory.Add(processList.ElementAt(i).ProcessName + " - " + processList.ElementAt(i).Pid, processList.ElementAt(i).PhysicalMemory);
}
processList = processList.OrderByDescending(o => o.WriteAmount).ToList();
for (int i = 0; i < 5; i++)
{
_topFiveProcessByDataWritten.Add(processList.ElementAt(i).ProcessName + " - " + processList.ElementAt(i).Pid, processList.ElementAt(i).WriteAmount);
}
processList = processList.OrderByDescending(o => o.ReadAmount).ToList();
for (int i = 0; i < 5; i++)
{
_topFiveProcessByDataRead.Add(processList.ElementAt(i).ProcessName + " - " + processList.ElementAt(i).Pid, processList.ElementAt(i).ReadAmount);
}
ByPhysicalMemoryProcessNames = _topFiveProcessByPhysicalMemory.Keys.ToArray();
ByDataWrittenProcessNames = _topFiveProcessByDataWritten.Keys.ToArray();
ByDataReadProcessNames = _topFiveProcessByDataRead.Keys.ToArray();
ProcessesDataReadSeriesCollection.Add(CreateColumnSeries("Data Read (MB) ", _topFiveProcessByDataRead));
ProcessesMemoryUsageSeriesCollection.Add(CreateColumnSeries("Memory used (MB) ", _topFiveProcessByPhysicalMemory));
ProcessesDataWrittenSeriesCollection.Add(CreateColumnSeries("Data Written (MB) ", _topFiveProcessByDataWritten));
}
IsModelInformationBeingUpdated = false;
}
public async void AsyncUpdateUserSessionInformation()
{
IsModelInformationBeingUpdated = true;
IServiceFactory sf = ServiceFactoryProducer.GetServiceFactory();
IUserSessionService iuss = sf.CreateUserSessionService();
iuss.UpdateProgress += UpdateModelInformation;
List <UserSession> sessions = await Task.Run(() =>
{
return(iuss.GetUserSessions());
});
if (sessions != null)
{
UserSessions = new ObservableCollection <UserSession>();
LogonLogoffSeriesCollection = new SeriesCollection();
SessionDurationSeriesCollection = new SeriesCollection();
SessionDurationByWeekDaySeriesCollection = new SeriesCollection();
UserLoginHoursCounts = new Dictionary <string, int[]>();
UserLogoffHoursCounts = new Dictionary <string, int[]>();
UserSessionDurationCounts = new Dictionary <string, int[]>();
_userSessionDurationByDayOfWeek = new Dictionary <string, Dictionary <int, List <int> > >();
Users = new List <string>();
foreach (UserSession session in sessions)
{
UserSessions.Add(session);
//TO-DO clean up and optimize
int day = (int)session.Beginning.DayOfWeek;
int logonHour = session.Beginning.Hour;
int logoffHour = session.End.Hour;
int durationDays = (int)Math.Floor((session.Beginning.Hour + (session.Beginning.Minute / 60) + session.Duration.TotalHours) / 24);
int firstDayDuration = (logoffHour < logonHour || session.Duration.TotalHours >= 24) ? firstDayDuration = 24 - logonHour : 0;
int leftoverDayDuration = (int)Math.Floor((session.Duration.TotalHours - firstDayDuration) % 24);
int logonHourIndex = (int)Math.Ceiling(logonHour / 2.0) - 1;
int logoffHourIndex = (int)Math.Ceiling(logoffHour / 2.0) - 1;
logonHourIndex = logonHourIndex < 0 ? 0 : logonHourIndex;
logoffHourIndex = logoffHourIndex < 0 ? 0 : logoffHourIndex;
if (!Users.Contains(session.Username))
{
Users.Add(session.Username);
}
if (!UserLoginHoursCounts.ContainsKey(session.Username))
{
UserLoginHoursCounts.Add(session.Username, new int[12]);
}
if (!UserLogoffHoursCounts.ContainsKey(session.Username))
{
UserLogoffHoursCounts.Add(session.Username, new int[12]);
}
if (!UserSessionDurationCounts.ContainsKey(session.Username))
{
UserSessionDurationCounts.Add(session.Username, new int[24]);
}
if (!_userSessionDurationByDayOfWeek.ContainsKey(session.Username))
{
_userSessionDurationByDayOfWeek.Add(session.Username, new Dictionary <int, List <int> >());
for (int i = 0; i < 7; i++)
{
_userSessionDurationByDayOfWeek[session.Username].Add(i, new List <int>());
}
}
if (session.Duration.TotalHours < 23)
{
UserSessionDurationCounts[session.Username][(int)Math.Floor((double)session.Duration.Hours)]++;
}
else
{
UserSessionDurationCounts[session.Username][23]++;
}
UserLoginHoursCounts[session.Username][logonHourIndex]++;
UserLogoffHoursCounts[session.Username][logoffHourIndex]++;
for (int i = 0; i < durationDays; i++)
{
if (i == 0)
{
_userSessionDurationByDayOfWeek[session.Username][(day + i) % 7].Add(firstDayDuration);
}
else
{
_userSessionDurationByDayOfWeek[session.Username][(day + i) % 7].Add(24);
}
}
_userSessionDurationByDayOfWeek[session.Username][(day + durationDays) % 7].Add(leftoverDayDuration);
}
foreach (KeyValuePair <string, Dictionary <int, List <int> > > userdata in _userSessionDurationByDayOfWeek)
{
ColumnSeries cs = new ColumnSeries();
cs.Title = "Hours - " + userdata.Key;
cs.Values = new ChartValues <int>();
foreach (KeyValuePair <int, List <int> > day in userdata.Value)
{
day.Value.Sort();
int median = 0;
//TO-DO fix displaying hours for outliers. Activity in some week days may not be representative if it is not repeated often enough
if (day.Value.Count > 0)
{
median = day.Value[(int)Math.Floor((double)(day.Value.Count / 2))];
}
cs.Values.Add(median);
}
SessionDurationByWeekDaySeriesCollection.Add(cs);
}
foreach (string usrn in UserLoginHoursCounts.Keys)
{
ColumnSeries cs = new ColumnSeries();
cs.Title = "Logons - " + usrn;
cs.Values = new ChartValues <int>();
foreach (int day in UserLoginHoursCounts[usrn])
{
cs.Values.Add(day);
}
LogonLogoffSeriesCollection.Add(cs);
}
foreach (string usrn in UserLogoffHoursCounts.Keys)
{
ColumnSeries cs = new ColumnSeries();
cs.Title = "Logoffs - " + usrn;
cs.Values = new ChartValues <int>();
foreach (int day in UserLogoffHoursCounts[usrn])
{
cs.Values.Add(day);
}
LogonLogoffSeriesCollection.Add(cs);
}
foreach (string usrn in UserSessionDurationCounts.Keys)
{
ColumnSeries cs = new ColumnSeries();
cs.Title = "Sessions - " + usrn;
cs.Values = new ChartValues <int>();
foreach (int day in UserSessionDurationCounts[usrn])
{
cs.Values.Add(day);
}
SessionDurationSeriesCollection.Add(cs);
}
}
IsModelInformationBeingUpdated = false;
}
public async void AsyncUpdateComputerSessionInformation()
{
IsModelInformationBeingUpdated = true;
IServiceFactory sf = ServiceFactoryProducer.GetServiceFactory();
IComputerSessionService css = sf.CreateComputerSessionService();
css.UpdateProgress += UpdateModelInformation;
ModelInformationUpdateProgress = "Loading computer session data...";
ComputerSessions = await Task.Run(() =>
{
return(css.GetComputerSessions());
});
RaisePropertyChanged("ComputerSessions");
if (ComputerSessions != null && ComputerSessions.Count > 0)
{
StartupShutdownSeriesCollection = new SeriesCollection();
SessionDurationSeriesCollection = new SeriesCollection();
SessionDurationByWeekDaySeriesCollection = new SeriesCollection();
StartupHoursCounts = new int[12];
ShutdownHoursCounts = new int[12];
SessionDurationCounts = new int[24];
_sessionDurationByDayOfWeek = new Dictionary <int, List <int> >();
for (int i = 0; i < 7; i++)
{
_sessionDurationByDayOfWeek.Add(i, new List <int>());
}
foreach (ComputerSession session in ComputerSessions)
{
int day = (int)session.Beginning.DayOfWeek;
//TO-DO clean up and optimize
int logonHour = session.Beginning.Hour;
int logoffHour = session.End.Hour;
int durationDays = (int)Math.Floor((session.Beginning.Hour + (session.Beginning.Minute / 60) + session.Duration.TotalHours) / 24);
int firstDayDuration = (logoffHour < logonHour || session.Duration.TotalHours >= 24) ? firstDayDuration = 24 - logonHour: 0;
int leftoverDayDuration = (int)Math.Floor((session.Duration.TotalHours - firstDayDuration) % 24);
int logonHourIndex = (int)Math.Ceiling(logonHour / 2.0) - 1;
int logoffHourIndex = (int)Math.Ceiling(logoffHour / 2.0) - 1;
logonHourIndex = logonHourIndex < 0 ? 0 : logonHourIndex;
logoffHourIndex = logoffHourIndex < 0 ? 0 : logoffHourIndex;
if (session.Duration.TotalHours < 23)
{
SessionDurationCounts[(int)Math.Floor((double)session.Duration.Hours)]++;
}
else
{
SessionDurationCounts[23]++;
}
StartupHoursCounts[logonHourIndex]++;
ShutdownHoursCounts[logoffHourIndex]++;
for (int i = 0; i < durationDays; i++)
{
if (i == 0)
{
_sessionDurationByDayOfWeek[(day + i) % 7].Add(firstDayDuration);
}
else
{
_sessionDurationByDayOfWeek[(day + i) % 7].Add(24);
}
}
_sessionDurationByDayOfWeek[(day + durationDays) % 7].Add(leftoverDayDuration);
}
ColumnSeries cs = new ColumnSeries();
cs.Title = "Hours";
cs.Values = new ChartValues <int>();
foreach (KeyValuePair <int, List <int> > day in _sessionDurationByDayOfWeek)
{
day.Value.Sort();
int median = 0;
//TO-DO fix displaying hours for outliers. Activity in some week days may not be representative if it is not repeated often enough
if (day.Value.Count > 0)
{
median = day.Value[(int)Math.Floor((double)(day.Value.Count / 2))];
}
cs.Values.Add(median);
}
SessionDurationByWeekDaySeriesCollection.Add(cs);
ColumnSeries cs_startup = new ColumnSeries();
cs_startup.Title = "Startups";
cs_startup.Values = new ChartValues <int>();
foreach (int day in StartupHoursCounts)
{
cs_startup.Values.Add(day);
}
StartupShutdownSeriesCollection.Add(cs_startup);
ColumnSeries cs_shutdown = new ColumnSeries();
cs_shutdown.Title = "Shutdowns";
cs_shutdown.Values = new ChartValues <int>();
foreach (int day in ShutdownHoursCounts)
{
cs_shutdown.Values.Add(day);
}
StartupShutdownSeriesCollection.Add(cs_shutdown);
ColumnSeries cs_sessions = new ColumnSeries();
cs_sessions.Title = "Sessions";
cs_sessions.Values = new ChartValues <int>();
foreach (int day in SessionDurationCounts)
{
cs_sessions.Values.Add(day);
}
SessionDurationSeriesCollection.Add(cs_sessions);
}
IsModelInformationBeingUpdated = false;
}
