Example #1
0
        private static void SyncIntervalTimeLogs()
        {
            _computer = JsonLocalDatabase.Instance.Computer;
            //var users = _computer.ComputerUsers?
            //    .Where(u => u.Synced && u.Enabled && u.ComputerUserId > 0).ToList();
            var intervals = _computer.LogTimeIntervals.Where(l => !l.Synced).ToList();

            if (intervals.Count == 0)
            {
                return;
            }
            var intervalsResource = intervals.Select(i => i.ToResource(_computer.ComputerId, i.ComputerUser));
            //LocalLogger.Log(intervalsResource);
            var client     = new ServerClient();
            var response   = client.PostToServer(Settings.ApiUrl, "api/LogTimeIntervals", intervalsResource, _jsonWebToken);
            var returnLogs = response.Content.ReadAsAsync <List <LogTimeIntervalResource> >().Result.ToList();

            //LocalLogger.Log(returnLogs);
            foreach (var log in returnLogs)
            {
                var interval = intervals.FirstOrDefault(i => i.StartTime == log.StartTime);
                if (interval != null)
                {
                    interval.LogTimeIntervalId = log.LogTimeIntervalId;
                    interval.Synced            = true;
                }
            }
            JsonLocalDatabase.Instance.Computer = _computer;
        }
Example #2
0
        private static void SyncUsers()
        {
            _computer = JsonLocalDatabase.Instance.Computer;
            var users = _computer.ComputerUsers?
                        .Where(u => !u.Synced && u.Enabled)
                        .Select(u => u.ToResource(_computer.ComputerId)).ToList();

            if (users == null || users.Count == 0)
            {
                return;
            }
            LocalLogger.Log($"Syncing {users.Count} {(users.Count > 1 ? "users" : "user")}.");
            var client   = new ServerClient();
            var response = client.PostToServer(Settings.ApiUrl, "api/ComputerUsers", users, _jsonWebToken);

            if (!response.IsSuccessStatusCode)
            {
                return;
            }
            //LocalLogger.Log(response);
            var returnUsers = response.Content.ReadAsAsync <List <ComputerUserResource> >().Result.Select(d => d.ToLocal()).ToList();

            foreach (var user in returnUsers)
            {
                var oldUser = _computer.ComputerUsers.FirstOrDefault(u => u.Name == user.Name);
                if (oldUser == null)
                {
                    continue;
                }
                oldUser.Synced         = true;
                oldUser.ComputerUserId = user.ComputerUserId;
            }
            JsonLocalDatabase.Instance.Computer = _computer;
        }
 public static ComputerResourceModel ToResourceModel(this ComputerLocal computer)
 {
     return(new ComputerResourceModel()
     {
         Name = computer.Name,
         Cpu = computer.Cpu,
         Gpu = computer.Gpu,
         Ram = computer.Ram,
         OperatingSystem = computer.OperatingSystem,
         MacAddress = computer.MacAddress,
         ComputerId = computer.ComputerId
     });
 }
Example #4
0
        private static void SyncBlockedSites()
        {
            _computer = JsonLocalDatabase.Instance.Computer;
            var client      = new ServerClient();
            var response    = client.GetFromServer(Settings.ApiUrl, $"api/BlockedSites/{_computer.ComputerId}", _jsonWebToken);
            var returnSites = response.Content.ReadAsAsync <List <BlockedSiteResource> >().Result.ToList();

            foreach (var user in _computer.ComputerUsers)
            {
                user.BlockedSites.Clear();
                var userSites = returnSites.Where(rs => rs.ComputerUserId == user.ComputerUserId)
                                .Select(s => s.ToLocal());
                user.BlockedSites.AddRange(userSites);
            }
            JsonLocalDatabase.Instance.Computer = _computer;
        }
Example #5
0
        public static ComputerLocal GetComputer()
        {
            var computer = new ComputerLocal()
            {
                Cpu              = GetCpuName().Replace("(tm)", "™").Replace("(R)", "®").Replace("(TM)", "™").Replace("(C)", "©"),
                Gpu              = GetGpuName(),
                Name             = Environment.MachineName,
                Ram              = GetTotalRamInGigaBytes(),
                OperatingSystem  = GetWindowsName(),
                MacAddress       = GetMacAddress(),
                Disks            = GetDisks(),
                ComputerUsers    = ComputerUsersHelper.GetComputerUsers(),
                LogTimeIntervals = new List <LogTimeIntervalLocal>()
            };

            return(computer);
        }
Example #6
0
        private static void GenerateDisks(ComputerLocal computer)
        {
            var disksAmount = Settings.MaxAmountOfDisks.Random(1);
            var diskLetters = GenerateUniqueLetters(disksAmount).ToArray();

            for (var i = 0; i < disksAmount; i++)
            {
                var totalSpace = 2048.0.Random(10.0);
                var disk       = new DiskLocal()
                {
                    TotalSpaceInGigaBytes = totalSpace,
                    FreeSpaceInGigaBytes  = totalSpace.Random(0.5),
                    Letter = $"{char.ToUpper(diskLetters.ElementAt(i))}:\\",
                    Name   = Samples.DiskNames.Random()
                };
                computer.Disks.Add(disk);
            }
        }
Example #7
0
        public static ComputerLocal GenerateComputer()
        {
            var computer = new ComputerLocal()
            {
                Name             = $"{Samples.Manufacturers.Random()} - PC",
                Cpu              = Samples.Cpus.Random(),
                Gpu              = Samples.Gpus.Random(),
                Ram              = Math.Pow(2, 6.Random()),
                OperatingSystem  = $"Microsoft Windows {Samples.OperatingSystems.Random()}",
                ComputerUsers    = new List <ComputerUserLocal>(),
                LogTimeIntervals = new List <LogTimeIntervalLocal>(),
                Disks            = new List <DiskLocal>()
            };

            GenerateDisks(computer);
            GenerateComputerUsers(computer);
            GenerateLogTimeIntervals(computer);
            return(computer);
        }
Example #8
0
        private static void GenerateComputerUsers(ComputerLocal computer)
        {
            var userAmount = Settings.MaxAmountOfComputerUsers.Random(5);
            var names      = GenerateUniqueUserNames(userAmount);

            for (var i = 0; i < userAmount; i++)
            {
                var computerUser = new ComputerUserLocal()
                {
                    Name           = names.ElementAtOrDefault(i),
                    FullName       = 2.Random() == 0 ? names.ElementAtOrDefault(i) : "",
                    PrivilegeLevel = i == 0 ? "Administrator" : (3.Random() == 0 ? "Administrator" : "Standard user"),
                    BlockedApps    = new List <BlockedAppLocal>(),
                    BlockedSites   = new List <BlockedSiteLocal>()
                };
                GenerateBlockedApps(computerUser);
                GenerateBlockedSites(computerUser);
                computer.ComputerUsers.Add(computerUser);
            }
        }
        public static bool NeedsUpdate(this ComputerLocal oldComputer, ComputerLocal newComputer)
        {
            if (oldComputer == null)
            {
                return(true);
            }
            if (newComputer == null)
            {
                return(false);
            }

            var isDifferent = !(oldComputer.Name == newComputer.Name &&
                                oldComputer.Cpu == newComputer.Cpu &&
                                oldComputer.Gpu == newComputer.Gpu &&
                                Math.Abs(oldComputer.Ram - newComputer.Ram) < 0.10 &&
                                oldComputer.OperatingSystem == newComputer.OperatingSystem &&
                                oldComputer.MacAddress == newComputer.MacAddress);

            return(isDifferent);
        }
Example #10
0
        private static void GenerateLogTimeIntervals(ComputerLocal computer)
        {
            var now = DateTime.Now;

            computer.ComputerUsers.Add(null);
            var dateTime = new DateTime(now.Year, now.Month, now.Day, 2.Random(), 60.Random(), 0);

            for (var i = 0; i < Settings.MaxAmountOfLogTimeIntervals.Random(6); i++)
            {
                var timeSpan = new TimeSpan(2.Random(), 57.Random(), 0);
                var log      = new LogTimeIntervalLocal()
                {
                    ComputerUser = computer.ComputerUsers.Random().Name,
                    StartTime    = dateTime,
                    Duration     = timeSpan,
                    State        = computer.ComputerUsers.Random() == null ? "Idle" : (2.Random() == 0 ? "Idle" : "Active"),
                };
                computer.LogTimeIntervals.Add(log);
                computer.ComputerUsers.RemoveAll(u => u == null);
            }
        }
Example #11
0
        private static void SyncComputer()
        {
            _computer = JsonLocalDatabase.Instance.Computer;
            if (_computer.Synced)
            {
                return;
            }
            var client   = new ServerClient();
            var response = client.PostToServer(Settings.ApiUrl, "api/Computers", _computer.ToResourceModel(), _jsonWebToken);

            if (!response.IsSuccessStatusCode)
            {
                LocalLogger.Log(response.Content.ReadAsStringAsync());
                return;
            }

            var computerId = response.Content.ReadAsAsync <int>().Result;

            _computer.Synced     = true;
            _computer.ComputerId = computerId;
            JsonLocalDatabase.Instance.Computer = _computer;
            //LocalLogger.Log($"ComputerId: {computerId}");
        }
Example #12
0
        private static void SyncDisks()
        {
            _computer = JsonLocalDatabase.Instance.Computer;
            //var disks = _computer.Disks.Where(d => !d.Synced).Select(d => d.ToResourceModel(_computer.ComputerId)).ToList();
            var disks = _computer.Disks;

            if (disks.All(d => d.Synced))
            {
                return;
            }
            LocalLogger.Log($"Syncing {disks.Count}.");
            var client   = new ServerClient();
            var response = client.PostToServer(Settings.ApiUrl, "api/Disks", disks.Select(d => d.ToResourceModel(_computer.ComputerId)).ToList(), _jsonWebToken);

            //LocalLogger.Log(response);
            if (!response.IsSuccessStatusCode)
            {
                return;
            }
            var returnDisks = response.Content.ReadAsAsync <List <DiskResource> >().Result.Select(d => d.ToLocal()).ToList();

            _computer.Disks = returnDisks;
            JsonLocalDatabase.Instance.Computer = _computer;
        }
Example #13
0
        private static void SyncBlockedApps()
        {
            _computer = JsonLocalDatabase.Instance.Computer;
            var users = _computer.ComputerUsers?
                        .Where(u => u.Synced && u.Enabled && u.ComputerUserId > 0 && u.BlockedApps.Any(a => !a.Synced)).ToList();
            var client = new ServerClient();

            if (users != null && users.Count > 0)
            {
                var apps         = new List <BlockedAppLocal>();
                var appsResource = new List <BlockedAppResource>();
                foreach (var user in users)
                {
                    apps.AddRange(user.BlockedApps.Where(a => !a.Synced));
                    appsResource.AddRange(user.BlockedApps.Where(a => !a.Synced).Select(a => a.ToResource(user.ComputerUserId)));
                }
                if (apps.Count == 0)
                {
                    return;
                }
                LocalLogger.Log($"Syncing {apps.Count} {(apps.Count == 1 ? "app" : "apps")}.");
                var response   = client.PostToServer(Settings.ApiUrl, $"api/BlockedApps/{_computer.ComputerId}", appsResource, _jsonWebToken);
                var returnApps = response.Content.ReadAsAsync <List <BlockedAppResource> >().Result.ToList();
                if (!response.IsSuccessStatusCode)
                {
                    return;
                }
                foreach (var user in users)
                {
                    if (user.BlockedApps == null)
                    {
                        continue;
                    }
                    foreach (var app in user.BlockedApps)
                    {
                        var tempApp = returnApps.FirstOrDefault(a => a.Path == app.Path && a.ComputerUserId == user.ComputerUserId);
                        if (tempApp == null)
                        {
                            continue;
                        }
                        app.BlockedAppId = tempApp.BlockedAppId;
                        app.Synced       = true;
                    }
                }
            }

            var syncResponse = client.GetFromServer(Settings.ApiUrl, $"api/BlockedApps/{_computer.ComputerId}", _jsonWebToken);
            var allLocalApps = new List <BlockedAppLocal>();

            if (_computer.ComputerUsers != null)
            {
                foreach (var user in _computer.ComputerUsers)
                {
                    allLocalApps.AddRange(user.BlockedApps.Where(a => a.Synced));
                }
            }
            var allApps = syncResponse.Content.ReadAsAsync <List <BlockedAppResource> >().Result.ToList();
            //LocalLogger.Log(allApps);
            var removedAppsIds = allLocalApps.Select(a => a.BlockedAppId).ToList();

            foreach (var app in allApps)
            {
                var user = _computer.ComputerUsers?.FirstOrDefault(u => u.ComputerUserId == app.ComputerUserId);
                if (user == null)
                {
                    continue;
                }
                if (user.BlockedApps.All(a => a.Path != app.Path))
                {
                    user.BlockedApps.Add(new BlockedAppLocal
                    {
                        Active       = app.Active,
                        BlockedAppId = app.BlockedAppId,
                        Name         = app.Name,
                        Path         = app.Path,
                        Synced       = true
                    });
                }
                else
                {
                    var oldApp = user.BlockedApps.FirstOrDefault(a => a.Path == app.Path);
                    if (oldApp == null)
                    {
                        continue;
                    }
                    oldApp.Name         = app.Name;
                    oldApp.Path         = app.Path;
                    oldApp.Active       = app.Active;
                    oldApp.Synced       = true;
                    oldApp.BlockedAppId = app.BlockedAppId;
                }
                removedAppsIds.RemoveAll(i => i == app.BlockedAppId);
            }

            // Removes locally all blocked apps removed via web app.
            if (_computer.ComputerUsers != null)
            {
                foreach (var user in _computer.ComputerUsers)
                {
                    user.BlockedApps.RemoveAll(a => removedAppsIds.Contains(a.BlockedAppId));
                }
            }

            //LocalLogger.Log(returnApps);
            JsonLocalDatabase.Instance.Computer = _computer;
        }