edit

2026-03-19 23:31:41 +03:00
parent ce3a3f02d2
commit a47a7a5a3b
104 changed files with 21982 additions and 0 deletions
--- a/XLAB2/PrsnDirectoryWindowViewModel.cs
+++ b/XLAB2/PrsnDirectoryWindowViewModel.cs
@@ -0,0 +1,790 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Windows.Input;
+
+namespace XLAB2
+{
+    internal sealed class PrsnDirectoryWindowViewModel : ObservableObject
+    {
+        private readonly IPrsnDirectoryDialogService _dialogService;
+        private readonly PrsnDirectoryService _service;
+        private bool _isBusy;
+        private List<PrsnDirectoryItem> _prsnCache;
+        private string _searchText;
+        private PrdspvDirectoryItem _selectedPrdspv;
+        private PrfrDirectoryItem _selectedPrfr;
+        private PrfrvdDirectoryItem _selectedPrfrvd;
+        private PrsnDirectoryItem _selectedPrsn;
+        private string _statusText;
+
+        public PrsnDirectoryWindowViewModel(PrsnDirectoryService service, IPrsnDirectoryDialogService dialogService)
+        {
+            _service = service;
+            _dialogService = dialogService;
+            _prsnCache = new List<PrsnDirectoryItem>();
+
+            PrsnItems = new ObservableCollection<PrsnDirectoryItem>();
+            PrfrItems = new ObservableCollection<PrfrDirectoryItem>();
+            PrfrvdItems = new ObservableCollection<PrfrvdDirectoryItem>();
+            PrdspvItems = new ObservableCollection<PrdspvDirectoryItem>();
+
+            AddPrsnCommand = new RelayCommand(delegate { AddPrsnAsync(); }, delegate { return !IsBusy; });
+            EditPrsnCommand = new RelayCommand(delegate { EditPrsnAsync(); }, delegate { return !IsBusy && SelectedPrsn != null; });
+            DeletePrsnCommand = new RelayCommand(delegate { DeletePrsnAsync(); }, delegate { return !IsBusy && SelectedPrsn != null; });
+            AddPrfrCommand = new RelayCommand(delegate { AddPrfrAsync(); }, delegate { return !IsBusy && SelectedPrsn != null; });
+            EditPrfrCommand = new RelayCommand(delegate { EditPrfrAsync(); }, delegate { return !IsBusy && SelectedPrfr != null; });
+            DeletePrfrCommand = new RelayCommand(delegate { DeletePrfrAsync(); }, delegate { return !IsBusy && SelectedPrfr != null; });
+            AddPrfrvdCommand = new RelayCommand(delegate { AddPrfrvdAsync(); }, delegate { return !IsBusy && SelectedPrfr != null; });
+            EditPrfrvdCommand = new RelayCommand(delegate { EditPrfrvdAsync(); }, delegate { return !IsBusy && SelectedPrfrvd != null; });
+            DeletePrfrvdCommand = new RelayCommand(delegate { DeletePrfrvdAsync(); }, delegate { return !IsBusy && SelectedPrfrvd != null; });
+            AddPrdspvCommand = new RelayCommand(delegate { AddPrdspvAsync(); }, delegate { return !IsBusy && SelectedPrfr != null; });
+            EditPrdspvCommand = new RelayCommand(delegate { EditPrdspvAsync(); }, delegate { return !IsBusy && SelectedPrdspv != null; });
+            DeletePrdspvCommand = new RelayCommand(delegate { DeletePrdspvAsync(); }, delegate { return !IsBusy && SelectedPrdspv != null; });
+            RefreshCommand = new RelayCommand(delegate { RefreshAsync(); }, delegate { return !IsBusy; });
+
+            UpdateStatus();
+        }
+
+        public ICommand AddPrdspvCommand { get; private set; }
+        public ICommand AddPrfrCommand { get; private set; }
+        public ICommand AddPrfrvdCommand { get; private set; }
+        public ICommand AddPrsnCommand { get; private set; }
+        public ICommand DeletePrdspvCommand { get; private set; }
+        public ICommand DeletePrfrCommand { get; private set; }
+        public ICommand DeletePrfrvdCommand { get; private set; }
+        public ICommand DeletePrsnCommand { get; private set; }
+        public ICommand EditPrdspvCommand { get; private set; }
+        public ICommand EditPrfrCommand { get; private set; }
+        public ICommand EditPrfrvdCommand { get; private set; }
+        public ICommand EditPrsnCommand { get; private set; }
+        public ObservableCollection<PrdspvDirectoryItem> PrdspvItems { get; private set; }
+        public ObservableCollection<PrfrDirectoryItem> PrfrItems { get; private set; }
+        public ObservableCollection<PrfrvdDirectoryItem> PrfrvdItems { get; private set; }
+        public ObservableCollection<PrsnDirectoryItem> PrsnItems { get; private set; }
+        public ICommand RefreshCommand { get; private set; }
+
+        public bool IsBusy
+        {
+            get { return _isBusy; }
+            private set
+            {
+                if (SetProperty(ref _isBusy, value))
+                {
+                    RaiseCommandStates();
+                }
+            }
+        }
+
+        public string SearchText
+        {
+            get { return _searchText; }
+            set
+            {
+                if (SetProperty(ref _searchText, value))
+                {
+                    ApplySearchFilter();
+                    UpdateStatus();
+                }
+            }
+        }
+
+        public PrdspvDirectoryItem SelectedPrdspv
+        {
+            get { return _selectedPrdspv; }
+            set
+            {
+                if (SetProperty(ref _selectedPrdspv, value))
+                {
+                    RaiseCommandStates();
+                    UpdateStatus();
+                }
+            }
+        }
+
+        public PrfrDirectoryItem SelectedPrfr
+        {
+            get { return _selectedPrfr; }
+            set
+            {
+                if (SetProperty(ref _selectedPrfr, value))
+                {
+                    RaiseCommandStates();
+                    LoadLeafTablesForSelection();
+                    UpdateStatus();
+                }
+            }
+        }
+
+        public PrfrvdDirectoryItem SelectedPrfrvd
+        {
+            get { return _selectedPrfrvd; }
+            set
+            {
+                if (SetProperty(ref _selectedPrfrvd, value))
+                {
+                    RaiseCommandStates();
+                    UpdateStatus();
+                }
+            }
+        }
+
+        public PrsnDirectoryItem SelectedPrsn
+        {
+            get { return _selectedPrsn; }
+            set
+            {
+                if (SetProperty(ref _selectedPrsn, value))
+                {
+                    RaiseCommandStates();
+                    LoadPrfrForSelection();
+                    UpdateStatus();
+                }
+            }
+        }
+
+        public string StatusText
+        {
+            get { return _statusText; }
+            private set { SetProperty(ref _statusText, value); }
+        }
+
+        public async Task InitializeAsync()
+        {
+            await ExecuteBusyOperationAsync(async delegate { await RefreshPrsnCoreAsync(null, null, null, null); });
+        }
+
+        private void AddPrdspvAsync()
+        {
+            if (SelectedPrfr == null)
+            {
+                return;
+            }
+
+            var result = _dialogService.ShowPrdspvEditDialog(new PrdspvDirectoryItem { EmploymentId = SelectedPrfr.EmploymentId }, true, PrdspvItems.ToList(), _service);
+            if (result == null)
+            {
+                return;
+            }
+
+            RunMutationOperation(async delegate
+            {
+                var createdId = await Task.Run(delegate { return _service.AddPrdspvItem(result); });
+                await RefreshPrsnCoreAsync(SelectedPrsn == null ? (int?)null : SelectedPrsn.Id, result.EmploymentId, SelectedPrfrvd == null ? (int?)null : SelectedPrfrvd.Id, createdId);
+                _dialogService.ShowInfo("Запись PRDSPV добавлена.");
+            });
+        }
+
+        private void AddPrfrAsync()
+        {
+            if (SelectedPrsn == null)
+            {
+                return;
+            }
+
+            var result = _dialogService.ShowPrfrEditDialog(new PrfrDirectoryItem { PersonId = SelectedPrsn.Id }, true, PrfrItems.ToList(), _service);
+            if (result == null)
+            {
+                return;
+            }
+
+            RunMutationOperation(async delegate
+            {
+                var createdId = await Task.Run(delegate { return _service.AddPrfrItem(result); });
+                await RefreshPrsnCoreAsync(result.PersonId, createdId, null, null);
+                _dialogService.ShowInfo("Запись PRFR добавлена.");
+            });
+        }
+
+        private void AddPrfrvdAsync()
+        {
+            if (SelectedPrfr == null)
+            {
+                return;
+            }
+
+            var result = _dialogService.ShowPrfrvdEditDialog(new PrfrvdDirectoryItem { EmploymentId = SelectedPrfr.EmploymentId }, true, PrfrvdItems.ToList(), _service);
+            if (result == null)
+            {
+                return;
+            }
+
+            RunMutationOperation(async delegate
+            {
+                var createdId = await Task.Run(delegate { return _service.AddPrfrvdItem(result); });
+                await RefreshPrsnCoreAsync(SelectedPrsn == null ? (int?)null : SelectedPrsn.Id, result.EmploymentId, createdId, SelectedPrdspv == null ? (int?)null : SelectedPrdspv.Id);
+                _dialogService.ShowInfo("Запись PRFRVD добавлена.");
+            });
+        }
+
+        private void AddPrsnAsync()
+        {
+            var result = _dialogService.ShowPrsnEditDialog(new PrsnDirectoryItem(), true, _prsnCache.ToList());
+            if (result == null)
+            {
+                return;
+            }
+
+            RunMutationOperation(async delegate
+            {
+                var createdId = await Task.Run(delegate { return _service.AddPrsnItem(result); });
+                await RefreshPrsnCoreAsync(createdId, null, null, null);
+                _dialogService.ShowInfo("Запись PRSN добавлена.");
+            });
+        }
+
+        private void ApplyPrsnFilter(int? preferredId)
+        {
+            var filteredItems = _prsnCache.Where(delegate(PrsnDirectoryItem item) { return MatchesSearch(item); }).ToList();
+            PrsnItems.Clear();
+            foreach (var item in filteredItems)
+            {
+                PrsnItems.Add(item);
+            }
+
+            SelectedPrsn = preferredId.HasValue
+                ? PrsnItems.FirstOrDefault(delegate(PrsnDirectoryItem item) { return item.Id == preferredId.Value; })
+                : PrsnItems.FirstOrDefault();
+        }
+
+        private void ApplySearchFilter()
+        {
+            if (!IsBusy)
+            {
+                ApplyPrsnFilter(SelectedPrsn == null ? (int?)null : SelectedPrsn.Id);
+            }
+        }
+
+        private static PrdspvDirectoryItem ClonePrdspv(PrdspvDirectoryItem source)
+        {
+            return new PrdspvDirectoryItem
+            {
+                EmploymentId = source.EmploymentId,
+                Id = source.Id,
+                Notes = source.Notes,
+                ReceivedOn = source.ReceivedOn,
+                StampCode = source.StampCode,
+                StampTypeId = source.StampTypeId,
+                StampTypeName = source.StampTypeName
+            };
+        }
+
+        private static PrfrDirectoryItem ClonePrfr(PrfrDirectoryItem source)
+        {
+            return new PrfrDirectoryItem
+            {
+                DismissalDate = source.DismissalDate,
+                EmploymentId = source.EmploymentId,
+                Guid = source.Guid,
+                HireDate = source.HireDate,
+                IsPinAuth = source.IsPinAuth,
+                LastVacationEndDate = source.LastVacationEndDate,
+                LastVacationStartDate = source.LastVacationStartDate,
+                NextVacationEndDate = source.NextVacationEndDate,
+                NextVacationStartDate = source.NextVacationStartDate,
+                OrganizationId = source.OrganizationId,
+                OrganizationName = source.OrganizationName,
+                PersonId = source.PersonId,
+                PersonnelNumber = source.PersonnelNumber,
+                PinChangedAt = source.PinChangedAt,
+                PinHash = source.PinHash,
+                PositionId = source.PositionId,
+                PositionName = source.PositionName,
+                PositionStartDate = source.PositionStartDate,
+                QualificationPlanDate = source.QualificationPlanDate
+            };
+        }
+
+        private static PrfrvdDirectoryItem ClonePrfrvd(PrfrvdDirectoryItem source)
+        {
+            return new PrfrvdDirectoryItem
+            {
+                ActivityId = source.ActivityId,
+                ActivityName = source.ActivityName,
+                EmploymentId = source.EmploymentId,
+                Id = source.Id
+            };
+        }
+
+        private static PrsnDirectoryItem ClonePrsn(PrsnDirectoryItem source)
+        {
+            return new PrsnDirectoryItem
+            {
+                Email = source.Email,
+                ExternalId = source.ExternalId,
+                FirstName = source.FirstName,
+                FullName = source.FullName,
+                Guid = source.Guid,
+                Id = source.Id,
+                LastName = source.LastName,
+                Notes = source.Notes,
+                Patronymic = source.Patronymic,
+                Phone = source.Phone
+            };
+        }
+
+        private void DeletePrdspvAsync()
+        {
+            if (SelectedPrdspv == null)
+            {
+                return;
+            }
+
+            var selected = SelectedPrdspv;
+            if (!_dialogService.Confirm(string.Format("Удалить клеймо \"{0}\"?", selected.StampCode)))
+            {
+                return;
+            }
+
+            RunMutationOperation(async delegate
+            {
+                var result = await Task.Run(delegate { return _service.DeletePrdspvItem(selected.Id); });
+                if (!result.IsDeleted)
+                {
+                    _dialogService.ShowWarning(result.WarningMessage);
+                    return;
+                }
+
+                await RefreshPrsnCoreAsync(SelectedPrsn == null ? (int?)null : SelectedPrsn.Id, selected.EmploymentId, SelectedPrfrvd == null ? (int?)null : SelectedPrfrvd.Id, null);
+                _dialogService.ShowInfo("Запись PRDSPV удалена.");
+            });
+        }
+
+        private void DeletePrfrAsync()
+        {
+            if (SelectedPrfr == null)
+            {
+                return;
+            }
+
+            var selected = SelectedPrfr;
+            if (!_dialogService.Confirm(string.Format("Удалить запись персонала в организации \"{0}\"?", selected.OrganizationName)))
+            {
+                return;
+            }
+
+            RunMutationOperation(async delegate
+            {
+                var result = await Task.Run(delegate { return _service.DeletePrfrItem(selected.EmploymentId); });
+                if (!result.IsDeleted)
+                {
+                    _dialogService.ShowWarning(result.WarningMessage);
+                    return;
+                }
+
+                await RefreshPrsnCoreAsync(selected.PersonId, null, null, null);
+                _dialogService.ShowInfo("Запись PRFR удалена.");
+            });
+        }
+
+        private void DeletePrfrvdAsync()
+        {
+            if (SelectedPrfrvd == null)
+            {
+                return;
+            }
+
+            var selected = SelectedPrfrvd;
+            if (!_dialogService.Confirm(string.Format("Удалить вид деятельности \"{0}\"?", selected.ActivityName)))
+            {
+                return;
+            }
+
+            RunMutationOperation(async delegate
+            {
+                var result = await Task.Run(delegate { return _service.DeletePrfrvdItem(selected.Id); });
+                if (!result.IsDeleted)
+                {
+                    _dialogService.ShowWarning(result.WarningMessage);
+                    return;
+                }
+
+                await RefreshPrsnCoreAsync(SelectedPrsn == null ? (int?)null : SelectedPrsn.Id, selected.EmploymentId, null, SelectedPrdspv == null ? (int?)null : SelectedPrdspv.Id);
+                _dialogService.ShowInfo("Запись PRFRVD удалена.");
+            });
+        }
+
+        private void DeletePrsnAsync()
+        {
+            if (SelectedPrsn == null)
+            {
+                return;
+            }
+
+            var selected = SelectedPrsn;
+            if (!_dialogService.Confirm(string.Format("Удалить персону \"{0}\"?", selected.FullName)))
+            {
+                return;
+            }
+
+            RunMutationOperation(async delegate
+            {
+                var result = await Task.Run(delegate { return _service.DeletePrsnItem(selected.Id); });
+                if (!result.IsDeleted)
+                {
+                    _dialogService.ShowWarning(result.WarningMessage);
+                    return;
+                }
+
+                await RefreshPrsnCoreAsync(null, null, null, null);
+                _dialogService.ShowInfo("Запись PRSN удалена.");
+            });
+        }
+
+        private async Task ExecuteBusyOperationAsync(Func<Task> operation)
+        {
+            try
+            {
+                IsBusy = true;
+                await operation();
+            }
+            catch (Exception ex)
+            {
+                _dialogService.ShowError(ex.Message);
+            }
+            finally
+            {
+                IsBusy = false;
+            }
+        }
+
+        private async Task ExecuteMutationOperationAsync(Func<Task> operation)
+        {
+            try
+            {
+                IsBusy = true;
+                await operation();
+            }
+            catch (InvalidOperationException ex)
+            {
+                _dialogService.ShowWarning(ex.Message);
+            }
+            catch (Exception ex)
+            {
+                _dialogService.ShowError(ex.Message);
+            }
+            finally
+            {
+                IsBusy = false;
+            }
+        }
+
+        private void EditPrdspvAsync()
+        {
+            if (SelectedPrdspv == null)
+            {
+                return;
+            }
+
+            var result = _dialogService.ShowPrdspvEditDialog(ClonePrdspv(SelectedPrdspv), false, PrdspvItems.ToList(), _service);
+            if (result == null)
+            {
+                return;
+            }
+
+            RunMutationOperation(async delegate
+            {
+                await Task.Run(delegate { _service.UpdatePrdspvItem(result); });
+                await RefreshPrsnCoreAsync(SelectedPrsn == null ? (int?)null : SelectedPrsn.Id, result.EmploymentId, SelectedPrfrvd == null ? (int?)null : SelectedPrfrvd.Id, result.Id);
+                _dialogService.ShowInfo("Запись PRDSPV обновлена.");
+            });
+        }
+
+        private void EditPrfrAsync()
+        {
+            if (SelectedPrfr == null)
+            {
+                return;
+            }
+
+            var result = _dialogService.ShowPrfrEditDialog(ClonePrfr(SelectedPrfr), false, PrfrItems.ToList(), _service);
+            if (result == null)
+            {
+                return;
+            }
+
+            RunMutationOperation(async delegate
+            {
+                await Task.Run(delegate { _service.UpdatePrfrItem(result); });
+                await RefreshPrsnCoreAsync(result.PersonId, result.EmploymentId, SelectedPrfrvd == null ? (int?)null : SelectedPrfrvd.Id, SelectedPrdspv == null ? (int?)null : SelectedPrdspv.Id);
+                _dialogService.ShowInfo("Запись PRFR обновлена.");
+            });
+        }
+
+        private void EditPrfrvdAsync()
+        {
+            if (SelectedPrfrvd == null)
+            {
+                return;
+            }
+
+            var result = _dialogService.ShowPrfrvdEditDialog(ClonePrfrvd(SelectedPrfrvd), false, PrfrvdItems.ToList(), _service);
+            if (result == null)
+            {
+                return;
+            }
+
+            RunMutationOperation(async delegate
+            {
+                await Task.Run(delegate { _service.UpdatePrfrvdItem(result); });
+                await RefreshPrsnCoreAsync(SelectedPrsn == null ? (int?)null : SelectedPrsn.Id, result.EmploymentId, result.Id, SelectedPrdspv == null ? (int?)null : SelectedPrdspv.Id);
+                _dialogService.ShowInfo("Запись PRFRVD обновлена.");
+            });
+        }
+
+        private void EditPrsnAsync()
+        {
+            if (SelectedPrsn == null)
+            {
+                return;
+            }
+
+            var result = _dialogService.ShowPrsnEditDialog(ClonePrsn(SelectedPrsn), false, _prsnCache.ToList());
+            if (result == null)
+            {
+                return;
+            }
+
+            RunMutationOperation(async delegate
+            {
+                await Task.Run(delegate { _service.UpdatePrsnItem(result); });
+                await RefreshPrsnCoreAsync(result.Id, SelectedPrfr == null ? (int?)null : SelectedPrfr.EmploymentId, SelectedPrfrvd == null ? (int?)null : SelectedPrfrvd.Id, SelectedPrdspv == null ? (int?)null : SelectedPrdspv.Id);
+                _dialogService.ShowInfo("Запись PRSN обновлена.");
+            });
+        }
+
+        private string[] GetSearchTokens()
+        {
+            return (SearchText ?? string.Empty)
+                .Split(new[] { ' ', '\t', '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries)
+                .Select(delegate(string token) { return token.Trim().ToUpperInvariant(); })
+                .Where(delegate(string token) { return token.Length > 0; })
+                .ToArray();
+        }
+
+        private void LoadLeafTablesForSelection()
+        {
+            if (!IsBusy)
+            {
+                RunBusyOperation(async delegate
+                {
+                    if (SelectedPrfr == null)
+                    {
+                        PrfrvdItems.Clear();
+                        PrdspvItems.Clear();
+                        SelectedPrfrvd = null;
+                        SelectedPrdspv = null;
+                        UpdateStatus();
+                        return;
+                    }
+
+                    await RefreshLeafTablesCoreAsync(SelectedPrfr.EmploymentId, null, null);
+                });
+            }
+        }
+
+        private void LoadPrfrForSelection()
+        {
+            if (!IsBusy)
+            {
+                RunBusyOperation(async delegate
+                {
+                    if (SelectedPrsn == null)
+                    {
+                        PrfrItems.Clear();
+                        PrfrvdItems.Clear();
+                        PrdspvItems.Clear();
+                        SelectedPrfr = null;
+                        SelectedPrfrvd = null;
+                        SelectedPrdspv = null;
+                        UpdateStatus();
+                        return;
+                    }
+
+                    await RefreshPrfrCoreAsync(SelectedPrsn.Id, null, null, null);
+                });
+            }
+        }
+
+        private bool MatchesSearch(PrsnDirectoryItem item)
+        {
+            if (item == null)
+            {
+                return false;
+            }
+
+            var tokens = GetSearchTokens();
+            if (tokens.Length == 0)
+            {
+                return true;
+            }
+
+            var haystack = string.Join(
+                " ",
+                new[]
+                {
+                    item.Id.ToString(),
+                    item.FullName,
+                    item.LastName,
+                    item.FirstName,
+                    item.Patronymic,
+                    item.Phone,
+                    item.Email,
+                    item.ExternalId,
+                    item.Guid,
+                    item.OrganizationNames,
+                    item.ActivityNames,
+                    item.StampNames,
+                    item.Notes
+                }
+                .Where(delegate(string value) { return !string.IsNullOrWhiteSpace(value); }))
+                .ToUpperInvariant();
+            return tokens.All(delegate(string token) { return haystack.IndexOf(token, StringComparison.Ordinal) >= 0; });
+        }
+
+        private async Task RefreshLeafTablesCoreAsync(int employmentId, int? prfrvdIdToSelect, int? prdspvIdToSelect)
+        {
+            var prfrvdTask = Task.Run(delegate { return _service.LoadPrfrvdItems(employmentId); });
+            var prdspvTask = Task.Run(delegate { return _service.LoadPrdspvItems(employmentId); });
+            await Task.WhenAll(prfrvdTask, prdspvTask);
+
+            PrfrvdItems.Clear();
+            foreach (var item in prfrvdTask.Result)
+            {
+                PrfrvdItems.Add(item);
+            }
+
+            PrdspvItems.Clear();
+            foreach (var item in prdspvTask.Result)
+            {
+                PrdspvItems.Add(item);
+            }
+
+            SelectedPrfrvd = prfrvdIdToSelect.HasValue
+                ? PrfrvdItems.FirstOrDefault(delegate(PrfrvdDirectoryItem item) { return item.Id == prfrvdIdToSelect.Value; })
+                : PrfrvdItems.FirstOrDefault();
+            SelectedPrdspv = prdspvIdToSelect.HasValue
+                ? PrdspvItems.FirstOrDefault(delegate(PrdspvDirectoryItem item) { return item.Id == prdspvIdToSelect.Value; })
+                : PrdspvItems.FirstOrDefault();
+            UpdateStatus();
+        }
+
+        private async Task RefreshPrfrCoreAsync(int personId, int? prfrIdToSelect, int? prfrvdIdToSelect, int? prdspvIdToSelect)
+        {
+            var items = await Task.Run(delegate { return _service.LoadPrfrItems(personId); });
+            PrfrItems.Clear();
+            foreach (var item in items)
+            {
+                PrfrItems.Add(item);
+            }
+
+            SelectedPrfr = prfrIdToSelect.HasValue
+                ? PrfrItems.FirstOrDefault(delegate(PrfrDirectoryItem item) { return item.EmploymentId == prfrIdToSelect.Value; })
+                : PrfrItems.FirstOrDefault();
+            if (SelectedPrfr == null)
+            {
+                PrfrvdItems.Clear();
+                PrdspvItems.Clear();
+                SelectedPrfrvd = null;
+                SelectedPrdspv = null;
+                UpdateStatus();
+                return;
+            }
+
+            await RefreshLeafTablesCoreAsync(SelectedPrfr.EmploymentId, prfrvdIdToSelect, prdspvIdToSelect);
+            UpdateStatus();
+        }
+
+        private async Task RefreshPrsnCoreAsync(int? prsnIdToSelect, int? prfrIdToSelect, int? prfrvdIdToSelect, int? prdspvIdToSelect)
+        {
+            var currentPrsnId = SelectedPrsn == null ? (int?)null : SelectedPrsn.Id;
+            _prsnCache = (await Task.Run(delegate { return _service.LoadPrsnItems(); })).ToList();
+
+            ApplyPrsnFilter(prsnIdToSelect.HasValue ? prsnIdToSelect : currentPrsnId);
+            if (SelectedPrsn == null)
+            {
+                PrfrItems.Clear();
+                PrfrvdItems.Clear();
+                PrdspvItems.Clear();
+                SelectedPrfr = null;
+                SelectedPrfrvd = null;
+                SelectedPrdspv = null;
+                UpdateStatus();
+                return;
+            }
+
+            await RefreshPrfrCoreAsync(SelectedPrsn.Id, prfrIdToSelect, prfrvdIdToSelect, prdspvIdToSelect);
+            UpdateStatus();
+        }
+
+        private void RaiseCommandStates()
+        {
+            ((RelayCommand)AddPrsnCommand).RaiseCanExecuteChanged();
+            ((RelayCommand)EditPrsnCommand).RaiseCanExecuteChanged();
+            ((RelayCommand)DeletePrsnCommand).RaiseCanExecuteChanged();
+            ((RelayCommand)AddPrfrCommand).RaiseCanExecuteChanged();
+            ((RelayCommand)EditPrfrCommand).RaiseCanExecuteChanged();
+            ((RelayCommand)DeletePrfrCommand).RaiseCanExecuteChanged();
+            ((RelayCommand)AddPrfrvdCommand).RaiseCanExecuteChanged();
+            ((RelayCommand)EditPrfrvdCommand).RaiseCanExecuteChanged();
+            ((RelayCommand)DeletePrfrvdCommand).RaiseCanExecuteChanged();
+            ((RelayCommand)AddPrdspvCommand).RaiseCanExecuteChanged();
+            ((RelayCommand)EditPrdspvCommand).RaiseCanExecuteChanged();
+            ((RelayCommand)DeletePrdspvCommand).RaiseCanExecuteChanged();
+            ((RelayCommand)RefreshCommand).RaiseCanExecuteChanged();
+        }
+
+        private void RefreshAsync()
+        {
+            RunBusyOperation(async delegate
+            {
+                await RefreshPrsnCoreAsync(
+                    SelectedPrsn == null ? (int?)null : SelectedPrsn.Id,
+                    SelectedPrfr == null ? (int?)null : SelectedPrfr.EmploymentId,
+                    SelectedPrfrvd == null ? (int?)null : SelectedPrfrvd.Id,
+                    SelectedPrdspv == null ? (int?)null : SelectedPrdspv.Id);
+            });
+        }
+
+        private async void RunBusyOperation(Func<Task> operation)
+        {
+            try
+            {
+                await ExecuteBusyOperationAsync(operation);
+            }
+            catch (Exception ex)
+            {
+                IsBusy = false;
+                _dialogService.ShowError(ex.Message);
+            }
+        }
+
+        private async void RunMutationOperation(Func<Task> operation)
+        {
+            try
+            {
+                await ExecuteMutationOperationAsync(operation);
+            }
+            catch (Exception ex)
+            {
+                IsBusy = false;
+                _dialogService.ShowError(ex.Message);
+            }
+        }
+
+        private void UpdateStatus()
+        {
+            var searchText = string.IsNullOrWhiteSpace(SearchText) ? null : SearchText.Trim();
+            StatusText = string.Format(
+                "{0}PRSN: {1}/{2}. PRFR: {3}. PRFRVD: {4}. PRDSPV: {5}.",
+                string.IsNullOrWhiteSpace(searchText) ? string.Empty : string.Format("Поиск: \"{0}\". ", searchText),
+                PrsnItems.Count,
+                _prsnCache.Count,
+                PrfrItems.Count,
+                PrfrvdItems.Count,
+                PrdspvItems.Count);
+        }
+    }
+}