private void HandleScanProgress(object progress)
        {
            switch (progress)
            {
            case GenericProgress genericProgress:
                switch (genericProgress.ProgressEvent)
                {
                case GenericProgress.Event.SCAN_CREATING_INDEXES:
                    ScanLogs.Add(Localization.CreatingIndexes);
                    break;
                }
                break;

            case ScanProgress scanProgress:
                if (scanProgress.Error)
                {
                    ScanLogs.Add($"{scanProgress.RelativeFilePath} — {Localization.Error}.");
                }
                else if (scanProgress.Found)
                {
                    FoundItems.Add(new ScanResultItemViewModel(LibgenObjectType.NON_FICTION_BOOK, 0, null, scanProgress.RelativeFilePath,
                                                               scanProgress.Authors, scanProgress.Title));
                }
                else
                {
                    NotFoundItems.Add(scanProgress.RelativeFilePath);
                }
                UpdateResultTabHeaders();
                break;

            case ScanCompleteProgress scanCompleteProgress:
                ScanLogs.Add(Localization.GetScanCompleteString(scanCompleteProgress.Found, scanCompleteProgress.NotFound, scanCompleteProgress.Errors));
                break;
            }
        }
        private void SetUidToNotFoundItem(AddressModel globalAddress)
        {
            var adr = SelectedNotFoundItem;

            adr.Number      = globalAddress.Number;
            adr.KgiopStatus = globalAddress.KgiopStatus;
            adr.Uid         = globalAddress.Uid;
            NotFoundItems.Refresh();

            _eventAggregator.GetEvent <PubSubEvent <AddressModel> >().Publish(adr);
        }
예제 #3
0
        private void HandleScanProgress <T>(object progress) where T : LibgenObject
        {
            switch (progress)
            {
            case GenericProgress genericProgress:
                switch (genericProgress.ProgressEvent)
                {
                case GenericProgress.Event.SCAN_CREATING_INDEXES:
                    ScanLogs.Add(Localization.CreatingIndexes);
                    break;
                }
                break;

            case ScanProgress <T> scanProgress:
                switch (scanProgress.LibgenObject)
                {
                case NonFictionBook nonFictionBook:
                    FoundItems.Add(new NonFictionScanResultItemViewModel(scanProgress.RelativeFilePath, nonFictionBook));
                    break;

                case FictionBook fictionBook:
                    FoundItems.Add(new FictionScanResultItemViewModel(scanProgress.RelativeFilePath, fictionBook));
                    break;

                case SciMagArticle sciMagArticle:
                    FoundItems.Add(new SciMagScanResultItemViewModel(scanProgress.RelativeFilePath, sciMagArticle));
                    break;
                }
                UpdateResultTabHeaders();
                break;

            case ScanUnknownProgress scanUnknownProgress:
                if (scanUnknownProgress.Error)
                {
                    var error = new ScanResultErrorItemViewModel(scanUnknownProgress.RelativeFilePath, scanUnknownProgress.ErrorType);
                    ResolveErrorDescription(error);
                    Errors.Add(error);
                    UpdateResultTabHeaders();
                }
                else
                {
                    NotFoundItems.Add(scanUnknownProgress.RelativeFilePath);
                    UpdateResultTabHeaders();
                }
                break;

            case ScanCompleteProgress scanCompleteProgress:
                ScanLogs.Add(Localization.GetScanCompleteString(scanCompleteProgress.Found, scanCompleteProgress.NotFound, scanCompleteProgress.Errors));
                break;
            }
        }
        public AddressToAddressViewModel(Repository repository, IEventAggregator eventAggregator)
        {
            _repository       = repository;
            _eventAggregator  = eventAggregator;
            _excelApplication = (Application)ExcelDnaUtil.Application;

            createGlobalAddressesView();

            (this as INotifyPropertyChanged).PropertyChanged += (obj, args) =>
            {
                if (args.PropertyName == nameof(FindText))
                {
                    Items?.Refresh();
                }
                else if (args.PropertyName == nameof(SelectedNotFoundItem) && SelectedNotFoundItem != null)
                {
                    FindText = getFindText(SelectedNotFoundItem.Address);
                }
            };

            (repository as INotifyPropertyChanged).PropertyChanged += (sender, args) =>
            {
                if (args.PropertyName == "AddressList")
                {
                    createGlobalAddressesView();
                }
            };

            _eventAggregator.GetEvent <PubSubEvent <AddressModel> >().Subscribe(adr =>
            {
                var findAdr = adr.Address.Replace(" ", "");
                var findDst = adr.District.Replace(" ", "");
                var list    = (NotFoundItems.SourceCollection as IEnumerable <AddressModel>);

                var curAdr = list.Where(i => i.Number == 0).FirstOrDefault(it => it.Address.Replace(" ", "") == findAdr & it.District.Replace(" ", "") == findDst);
                if (curAdr != null)
                {
                    curAdr.Number      = adr.Number;
                    curAdr.KgiopStatus = adr.KgiopStatus;
                    curAdr.Uid         = adr.Uid;
                    NotFoundItems.Refresh();

                    SelectedNotFoundItem = list.Where(i => i.Number == 0).FirstOrDefault();
                }
            });
        }