public async Task <bool> PopulateFromDir()
        {
            AllProjects.Clear();
            var allSlnFiles = await GetAllFilesByExentions(TargetDirectory);

            foreach (var cur in allSlnFiles)
            {
                if (!_solutionFileCache.ContainsKey(cur))
                {
                    _solutionFileCache.Add(cur, new SolutionFile(cur));
                }
                AllProjects.Add(_solutionFileCache[cur]);
            }
            Reporter.Report(AllProjects.Count + " projects found in directory.");
            return(true);
        }
Exemple #2
0
        private void ClearLoadedProjects()
        {
            ClearPreviousProjects();

            _allAnalyzeResults.Clear();

            if (_projectCollection != null)
            {
                _projectCollection.UnloadAllProjects();
                _projectCollection.Dispose();
            }

            _projectCollection = new ProjectCollection();

            IsLoaded = false;

            ShowPreviousProjectCommand.RaiseCanExecuteChanged();
            AllSolutions.Clear();
            AllProjects.Clear();
        }
Exemple #3
0
        private async void UpdateExecute()
        {
            try
            {
                projectWatcher?.Watcher?.Dispose();
                if (inUpdate || !Directory.Exists(ShortcutFolder))
                {
                    return;
                }

//                projectWatcher = new FileWatcherRx(ShortcutFolder, "", (NotifyFilters) 19, WatcherChangeTypes.All);
//                projectWatcher.Watcher.IncludeSubdirectories = true;
//                projectWatcher.Created.ObserveOn(dispatcher).Subscribe(s => OnCreatedProject(s.EventArgs));
//                projectWatcher.Deleted.ObserveOn(dispatcher).Subscribe(s => OnDeletedProject(s.EventArgs));
//                projectWatcher.Renamed.ObserveOn(dispatcher).Subscribe(s => OnRenamedProject(s.EventArgs));
//                projectWatcher.Changed.ObserveOn(dispatcher).Subscribe(s => OnChangedProject(s.EventArgs));
                inUpdate = true;
                var files = new List <FileInfo>();
                AllElements.Clear();
                AllProjects.Clear();
                await ShowProgressDialog(c =>
                {
                    c.SetIndeterminate();
                    if (ShortcutFolder == null || !Directory.Exists(ShortcutFolder))
                    {
                        return;
                    }

                    files = GetShortcutFiles(ShortcutFolder).Result;
                }, "Загрузка элементов...", "", false);

                if (!files.Any())
                {
                    ShowMessage("Не найдены файлы быстрых ссылок (xml)");
                    return;
                }

                foreach (var xmls in files.ChunkBy(50))
                {
                    var items = await GetShortcutItems(xmls);

                    foreach (var i in items)
                    {
                        Checks.CheckElement(i);
                        i.Project.Shortcuts.Add(i);
                        AllElements.Add(i);
                    }
                }

                var projects = Project.GetProjects();
                AllProjects.AddRange(projects);
                ProjectsVM.UpdateProjects();
            }
            catch (Exception ex)
            {
                ShowMessage(ex.ToString());
            }
            finally
            {
                inUpdate = false;
            }
        }
 protected override void OnDispose()
 {
     AllClients.Clear();
     AllProjects.Clear();
     AllStatuses.Clear();
 }
        private async Task GetProjectsAsync()
        {
            List <TimesheetEntry> timesheetEntries;

            ShownProjectsCollection.Clear();
            AllProjects.Clear();

            //Get all entries with a project ID
            using (var ctx = new DatabaseDir.Database())
                //Get entries
                timesheetEntries = ctx.TimesheetEntries.Include(ts => ts.vismaEntries.Select(ve => ve.LinkedRate)).ToList();

            //Convert to projects
            foreach (TimesheetEntry timesheetEntry in timesheetEntries)
            {
                //Filter empty project IDs
                if (string.IsNullOrWhiteSpace(timesheetEntry.ProjectID))
                {
                    continue;
                }

                //Filter timesheets with no "Arbejde" types
                if (timesheetEntry.vismaEntries.Where(x => x.LinkedRate.Type == "Arbejde").ToList().Count() == 0)
                {
                    continue;
                }

                //Filter if a period is specified
                if (SelectedWeek > 0 && SelectedYear > 0)
                {
                    DateTime from = DateHelper.WeekNumToDateTime(SelectedWeek, SelectedYear, 0);
                    DateTime to   = DateHelper.WeekNumToDateTime(SelectedWeek, SelectedYear, 6);

                    if (timesheetEntry.Date < from || timesheetEntry.Date > to)
                    {
                        continue; //Then skip
                    }
                }

                //Initalize
                double normalHours   = 0;
                double overtimeHours = 0;

                //Sum up hours from the entry
                foreach (VismaEntry vismaEntry in timesheetEntry.vismaEntries)
                {
                    //Filter non "Arbejde" (work) types
                    if (vismaEntry.LinkedRate.Type != "Arbejde")
                    {
                        continue;
                    }

                    //Sum overtime hours
                    if (vismaEntry.LinkedRate.Name == "Normal")
                    {
                        if (vismaEntry.Value > 0)
                        {
                            normalHours += vismaEntry.Value;
                        }
                    }
                    else
                    {
                        overtimeHours += vismaEntry.Value;
                    }
                }

                //Add time to project
                if (!AllProjects.Where(p => p.ProjectID == timesheetEntry.ProjectID).ToList().Any())
                {
                    //If project is not already listed
                    AllProjects.Add(new Project(timesheetEntry.ProjectID, normalHours, overtimeHours));
                }
                else
                {
                    //Else add hours to existing
                    Project SelectedProject = AllProjects.Where(p => p.ProjectID == timesheetEntry.ProjectID).FirstOrDefault();
                    SelectedProject.TotalNormalHours   += normalHours;
                    SelectedProject.TotalOverTimeHours += overtimeHours;
                }
            }
            AllProjects.Sort((x, y) => string.Compare(x.ProjectID, y.ProjectID));
            FiltherProjects();
        }