Exemple #1
0
        public void SaveViewCommand(object key)
        {
            bool isSaved = false;

            _reservationRequest.Value = DataObject;
            NotifyTaskCompletion.Create(_dataReservationService.SaveAsync(_reservationRequest), (sender, args) =>
            {
                if (sender is INotifyTaskCompletion <bool> taskCompletion)
                {
                    if (taskCompletion.IsFaulted)
                    {
                        DialogService?.ShowErrorMessage("Error during saving: " + taskCompletion.ErrorMessage);
                    }
                    if (taskCompletion.IsSuccessfullyCompleted)
                    {
                        isSaved = true;
                    }
                }
            });
            if (isSaved)
            {
                var dataPayLoad = new DataPayLoad
                {
                    Sender      = ViewModelUri.ToString(),
                    PayloadType = DataPayLoad.Type.UpdateView
                };
                EventManager.NotifyObserverSubsystem("ReservationRequests", dataPayLoad);
                DialogService?.ShowErrorMessage("Data saved with success!");
            }
        }
        public GetSurveysViewModel(string authToken)
        {
            var surveys = DependencyService
                          .Get <ISurveysService>();

            _surveysList = new NotifyTaskCompletion <IEnumerable <SurveyDetailsEntity> >(surveys.RetrieveAsync(authToken));
        }
Exemple #3
0
        protected override async Task OnRefreshAsync(CancellationToken ct)
        {
            try
            {
                this.ShowBusyStatus(Strings.Resources.TextLoading, true);

                this.RecommendedItemsTask    = new NotifyTaskCompletion <IEnumerable <ContentItemBase> >(DataSource.Current.GetRecommendedItemsAsync(ct));
                this.FriendsWatchedItemsTask = new NotifyTaskCompletion <IEnumerable <ContentItemBase> >(DataSource.Current.GetFriendsWatchedItemsAsync(ct));

                // Load queue data
                var list = new QueueCollection();
                list.AddRange(await DataSource.Current.GetQueueItemsAsync(Platform.Current.AuthManager.User?.ID, ct));
                this.Queue = list;

                ct.ThrowIfCancellationRequested();

                this.ShowBusyStatus("Updating tiles...");
                await Platform.Current.Notifications.CreateOrUpdateTileAsync(this);

                this.ClearStatus();
            }
            catch (OperationCanceledException)
            {
                this.ShowTimedStatus(Strings.Resources.TextCancellationRequested, 3000);
            }
            catch (Exception ex)
            {
                this.ShowTimedStatus(Strings.Resources.TextErrorGeneric);
                Platform.Current.Logger.LogError(ex, "Error during RefreshAsync");
            }
        }
Exemple #4
0
        public CompanyModule(IRepository repository)
        {
            _repository = repository;
            //            LoadPublishers();

            CompanyLoading = NotifyTaskCompletion.Create(() => LoadCompaniesAsync());
        }
        public CategoriesListViewModel(IProductService service, INavigationService navi, IScanner scanner)
        {
            _service = service;
            _navi = navi;
            _scanner = scanner;

            Items = new NotifyTaskCompletion<List<Product>>(_service.GetProducts());
            Categories = new NotifyTaskCompletion<List<string>>(_service.GetCategories());

            NavigateToCategory = new RelayCommand<string>(async cat =>
            {
                var items = (await _service.GetProductsForCategory(cat))
                    .OrderByDescending(i => i.Rating)
                    .ToList();

                if (items != null && items.Any())
                {
                    var page = App.GetProductsListPage(items, cat);
                    await _navi.PushAsync(page);
                }
                else
                {
                    await _navi.DisplayAlert("Error", "There are no items in the category " + cat);
                }
            });

            _searchCommand = new RelayCommand(Search, () => !string.IsNullOrWhiteSpace(SearchTerm));
            ScanCommand = new RelayCommand(async () =>
            {
                var result = await _scanner.Scan();

                SearchTerm = result.Text;
                Search();
            });
        }
        public MainViewModel()
        {
            _client = new WebServiceRepositoryClient();

            Services = new NotifyTaskCompletion<Service[]>(_client.GetServicesAsync());
            Companies = new NotifyTaskCompletion<Company[]>(_client.GetCompaniesAsync());
        }
Exemple #7
0
        protected override void DeleteItem(DataPayLoad payLoad)
        {
            bool isDeleted = false;

            NotifyTaskCompletion.Create(DeleteAsync(payLoad),
                                        (sender, args) =>
            {
                if (sender is INotifyTaskCompletion <bool> taskCompletion)
                {
                    if (taskCompletion.IsFaulted)
                    {
                        DialogService?.ShowErrorMessage("Error during aving: " + taskCompletion.ErrorMessage);
                    }

                    if (!taskCompletion.IsSuccessfullyCompleted)
                    {
                        return;
                    }
                    isDeleted = true;
                }
            });

            if (isDeleted)
            {
                var dataPayLoad = new DataPayLoad
                {
                    Sender      = ViewModelUri.ToString(),
                    PayloadType = DataPayLoad.Type.UpdateView
                };
                EventManager.NotifyObserverSubsystem("ReservationRequests", dataPayLoad);
                UnregisterToolBar(payLoad.PrimaryKeyValue);
                DeleteRegion();
                DialogService?.ShowErrorMessage("Data deleted with success!");
            }
        }
        public void ResultFromFinishedTask()
        {
            var fromResult = Task.FromResult(1);
            var completion = new NotifyTaskCompletion(fromResult);

            AssertCompletion.AreEqual(fromResult, completion);
        }
Exemple #9
0
 public void OnNavigatedTo(NavigationParameters parameters)
 {
     // Load all countries on load seems fine
     AllCountries = NotifyTaskCompletion.Create(async() => (await VkApi.GetAllCountriesAsync())
                                                .Select(x => new SearchableCountry(x))
                                                .ToLookup(x => char.ToUpperInvariant(x.DisplayName[0])));
 }
Exemple #10
0
        private bool ToBool(object arg)
        {
            if (arg is bool)
            {
                return((bool)arg);
            }

            if (arg is int)
            {
                return((int)arg >= 0);
            }

            if (arg is Visibility)
            {
                return((Visibility)arg == Visibility.Visible);
            }

            NotifyTaskCompletion <object> completion = arg as NotifyTaskCompletion <object>;

            if (completion != null)
            {
                return(completion.IsCompleted);
            }

            return(false);
        }
        public void StartAndNotify()
        {
            _incidentCompletion = NotifyTaskCompletion.Create <IEnumerable <BookingIncidentSummaryViewObject> >(
                _incidentService.GetPagedSummaryDoAsync(1, DefaultPageSize), (task, ev) =>
            {
                if (task is INotifyTaskCompletion <IEnumerable <BookingIncidentSummaryViewObject> > summaryCollection)
                {
                    if (summaryCollection.IsSuccessfullyCompleted)
                    {
                        var collection = summaryCollection.Result;


                        if (SummaryView is IncrementalList <BookingIncidentSummaryViewObject> summary)
                        {
                            var maxItems    = _incidentService.NumberItems;
                            PageCount       = _incidentService.NumberPage;
                            var summaryList = new IncrementalList <BookingIncidentSummaryViewObject>(LoadMoreItems)
                            {
                                MaxItemCount = (int)maxItems
                            };
                            summaryList.LoadItems(collection);
                            SummaryView = summaryList;
                        }
                    }
                    else
                    {
                        DialogService?.ShowErrorMessage("Cannot load more pages");
                    }
                }
            });
        }
Exemple #12
0
        /// <summary>
        /// cached data is loaded on demand, but may take a while to load on initial reference
        /// so we force loading early while waiting for user to type in user name and password so they don't notice
        /// </summary>
        private void preloadCache()
        {
            var cache = DataRepository.GetDataRepository.ReferenceData;

            var t = new Task <bool>(() =>
            {
                try
                {
                    foreach (var item in ReferenceDataCache.ReferenceDataTypes)
                    {
                        var dummy = cache[item.TypeName];
                    }
                    // if we didn't complete before user logged in and MainWindow created, then notify MainWindow we are done
                    Mediator.InvokeCallback(nameof(LoadingCompletedMessage), null);
                    return(true);
                }
                catch (Exception e)
                {
                    errorTracking?.logger?.Fatal(e, "Failed to load cached reference data!");
                    return(false);
                }
            });

            t.ConfigureAwait(false);
            t.Start();
            LoadingCacheCompletion = new NotifyTaskCompletion <bool>(t);
        }
Exemple #13
0
        public MainViewModel(IFileService fileService, IDialogService dialogService)
        {
            _fileService   = fileService ?? throw new ArgumentNullException(nameof(fileService));
            _dialogService = dialogService ?? throw new ArgumentNullException(nameof(dialogService));

            Users = new NotifyTaskCompletion <IList <User> >(_fileService.GetUsersStatistic());
        }
Exemple #14
0
        public void StartAndNotify()
        {
            _reservationCompletion = NotifyTaskCompletion.Create <IEnumerable <ReservationRequestSummary> >(
                _reservationRequestDataService.GetPagedSummaryDoAsync(1, DefaultPageSize), (task, ev) =>
            {
                if (task is INotifyTaskCompletion <IEnumerable <ReservationRequestSummary> > reservations)
                {
                    if (reservations.IsSuccessfullyCompleted)
                    {
                        var collection = reservations.Result;


                        if (SummaryView is IncrementalList <ReservationRequestSummary> summary)
                        {
                            var maxItems    = _reservationRequestDataService.NumberItems;
                            PageCount       = _reservationRequestDataService.NumberPage;
                            var summaryList = new IncrementalList <ReservationRequestSummary>(LoadMoreItems)
                            {
                                MaxItemCount = (int)maxItems
                            };
                            summaryList.LoadItems(collection);
                            SummaryView = summaryList;
                        }
                    }
                    else
                    {
                        DialogService?.ShowErrorMessage("No puedo cargar datos de peticiones : " + reservations.ErrorMessage);
                    }
                }
            });
        }
Exemple #15
0
        private void RefreshPeople()
        {
            _nextPage = null;

            LoadPeopleTask = NotifyTaskCompletion.Create(LoadPeople);
            RaisePropertyChanged(() => LoadPeopleTask);
        }
Exemple #16
0
        public override void StartAndNotify()
        {
            _incidentCompletion = NotifyTaskCompletion.Create <IEnumerable <UsersSummary> >(
                _incidentService.GetPagedSummaryDoAsync(1, DefaultPageSize), (task, ev) =>
            {
                if (task is INotifyTaskCompletion <IEnumerable <UsersSummary> > summaryCollection)
                {
                    if (summaryCollection.IsSuccessfullyCompleted)
                    {
                        var collection = summaryCollection.Result;


                        if (SummaryView is IncrementalList <UsersSummary> summary)
                        {
                            var maxItems    = _incidentService.NumberItems;
                            PageCount       = __incidentService.NumberPage;
                            var summaryList = new IncrementalList <UsersSummary>(LoadMoreItems)
                            {
                                MaxItemCount = (int)maxItems
                            };
                            summaryList.LoadItems(collection);
                            SummaryView = summaryList;
                        }
                    }
                    else
                    {
                        DialogService?.ShowErrorMessage(ErrorConstants.DataLoadError + " : " + reservations.ErrorMessage);
                    }
                }
            });
        }
        public PreferencesViewModel(IMvxNavigationService navigationService, IAuthService authService, IUserDialogs userDialogs, ITopNavigationViewModelService topNavigationViewModelService, IBottomNavigationViewModelService bottomNavigationViewModelService)
        {
            _navigationService                = navigationService;
            _topNavigationViewModelService    = topNavigationViewModelService;
            _bottomNavigationViewModelService = bottomNavigationViewModelService;

            _authService = authService;
            _userDialogs = userDialogs;


            ShowAddAlbumViewModelCommand = new MvxAsyncCommand(async() => await _navigationService.Navigate <ChangeAlbumViewModel>());

            ShowAddArtistViewModelCommand = new MvxAsyncCommand(async() => await _navigationService.Navigate <ChangeArtistViewModel>());

            ShowAddGenreViewModelCommand = new MvxAsyncCommand(async() => await _navigationService.Navigate <ChangeGenreViewModel>());

            ShowAddPlaylistViewModelCommand = new MvxAsyncCommand(async() => await _navigationService.Navigate <ChangePlaylistViewModel>());

            ShowAddSongViewModelCommand = new MvxAsyncCommand(async() => await _navigationService.Navigate <ChangeSongViewModel>());

            LogOutCommand = new MvxCommand(() =>
            {
                if (!IsTaskExecutedValueConverter.Convert(LogOutTask.Value))
                {
                    LogOutTask.Value = NotifyTaskCompletion.Create(AttemptLogOutAsync);
                }
            });
        }
Exemple #18
0
 /// <summary>
 ///  StartAndNotify.
 /// </summary>
 public void StartAndNotify()
 {
     _bookingSummaryCompletion = NotifyTaskCompletion.Create <IEnumerable <BookingSummaryViewObject> >(
         _bookingDataService.GetPagedSummaryDoAsync(1, DefaultPageSize), (sender, ev) =>
     {
         if (sender is INotifyTaskCompletion <IEnumerable <BookingSummaryViewObject> > bookingSummary)
         {
             if (bookingSummary.IsFaulted)
             {
                 DialogService?.ShowErrorMessage("Cannot load booking summary: " + bookingSummary.ErrorMessage);
                 return;
             }
             var booking     = bookingSummary.Result;
             var maxItems    = _bookingDataService.NumberItems;
             PageCount       = _bookingDataService.NumberPage;
             ItemCounts      = maxItems.ToString();
             var bookingList = new IncrementalList <BookingSummaryViewObject>(LoadMoreItems)
             {
                 MaxItemCount = (int)maxItems
             };
             bookingList.LoadItems(booking);
             SummaryView = bookingList;
         }
     });
 }
Exemple #19
0
        /// <summary>
        /// Searches for a given word.
        /// </summary>
        /// <param name="word">The word to search for.</param>
        public void SearchForWord(string word)
        {
            // TODO: the dictionary search is recorded in the first call. Perhaps find a better design?
            this.SearchResultsStands4           = NotifyTaskCompletion.Create(SearchForWordStands4Async(word));
            this.SearchResultsCollins           = NotifyTaskCompletion.Create(SearchForWordCollinsAsync(word));
            this.SearchResultsNetSpeakPreceding = NotifyTaskCompletion.Create(SearchForWordNetSpeakPrecedingAsync(word));
            this.SearchResultsNetSpeakFollowing = NotifyTaskCompletion.Create(SearchForWordNetSpeakFollowingAsync(word));
            this.SearchResultsStringNet         = NotifyTaskCompletion.Create(SearchForWordStringNetAsync(word));

            Task.Run(async() =>
            {
                try
                {
                    await SaveDictionarySearchAsync(word);
                }
                catch (AggregateException ae)
                {
                    ae.Handle(ex =>
                    {
                        Tools.Logger.Log("SaveDictionaryExternalHandler", ex);
                        return(true); // Handled
                    });
                }
            });
        }
Exemple #20
0
        /// <summary>
        ///  Generic method used for navigating. Retrieve an unique id for the new view and generate a view payload to be sent.
        /// </summary>
        /// <typeparam name="Entity">Entity Type of the view (same name as db column) </typeparam>
        /// <typeparam name="Dto">Data transfer object to be used.</typeparam>
        /// <param name="e">Entity</param>
        /// <param name="viewName">Name of the view</param>
        private void NewHelperView <Entity, Dto>(Entity e, string viewName, Uri viewModelUri) where Dto : BaseViewObject where Entity : class
        {
            var helperDataService = _dataService.GetHelperDataServices();
            var id = string.Empty;

            NotifyTaskCompletion.Create <string>(helperDataService.GetUniqueId(e), (task, ev) =>
            {
                if (task is INotifyTaskCompletion <string> result)
                {
                    if (result.IsSuccessfullyCompleted)
                    {
                        id = result.Task.Result;
                    }
                    else
                    {
                        _dialogService?.ShowErrorMessage("Error in identifier generation");
                    }
                }
            });
            var currentUri = new Uri(viewModelUri.ToString() + id);
            var factory    = DataPayloadFactory.GetInstance();
            var helperDto  = Activator.CreateInstance <Dto>();

            helperDto.Code = id;
            var dataPayload = factory.BuildInsertPayLoadDo <Dto>(viewName, helperDto, DataSubSystem.HelperSubsytsem, currentUri.ToString(), currentUri.ToString(), currentUri);

            NavigateView.Navigate(_regionManager, viewName);
        }
        public ChangeArtistViewModel(IMvxNavigationService navigationService, IUserDialogs userDialogs, IValidator validator, IArtistService artistService, IBottomNavigationViewModelService bottomNavigationViewModelService, ITopNavigationViewModelService topNavigationViewModelService)
        {
            _navigationService                = navigationService;
            _topNavigationViewModelService    = topNavigationViewModelService;
            _bottomNavigationViewModelService = bottomNavigationViewModelService;

            _userDialogs = userDialogs;

            _validationHelper = new ValidationHelper(validator, this, Errors.Value, (propertyName) => { FocusName.Value = propertyName; });

            _artistService = artistService;

            ValidateNameCommand = new MvxCommand(() => _validationHelper.Validate(() => Name));

            InitValidationCommand = new MvxCommand(() => {
                _validationHelper.ResetValidation();
            });

            ChangeCommand = new MvxCommand(() =>
            {
                if (!IsTaskExecutedValueConverter.Convert(ChangeTask.Value))
                {
                    ChangeTask.Value = NotifyTaskCompletion.Create(AttemptChangeAsync);
                }
            });
        }
Exemple #22
0
        protected override void DeleteItem(DataPayLoad payLoad)
        {
            NotifyTaskCompletion.Create <bool>(this.DeleteAsync(payLoad),
                                               ev: (sender, args) =>
            {
                if (!(sender is INotifyTaskCompletion <bool> taskCompletion))
                {
                    return;
                }
                if (taskCompletion.IsFaulted)
                {
                    DialogService?.ShowErrorMessage("Error during deleting the invoice");
                }

                if (!taskCompletion.IsSuccessfullyCompleted)
                {
                    return;
                }
                var dataPayLoad = new DataPayLoad()
                {
                    Sender      = ViewModelUri.ToString(),
                    PayloadType = DataPayLoad.Type.UpdateView
                };
                EventManager.NotifyObserverSubsystem(InvoiceModule.InvoiceSubSystem, dataPayLoad);
                UnregisterToolBar(payLoad.PrimaryKey);

                DeleteRegion();
            });
        }
 public override void ExecutePayload(IDataServices services, IEventManager manager, ref DataPayLoad payLoad)
 {
     DataServices   = services;
     EventManager   = manager;
     CurrentPayload = payLoad;
     ToolbarInitializationNotifier = NotifyTaskCompletion.Create <DataPayLoad>(HandleSaveOrUpdate(payLoad), ExecutedPayloadHandler);
 }
Exemple #24
0
 public MainViewModel(IBillCalculator billCalculator,
                      Task<IUserRepository> userRepositoryTask, IFuelPriceAccesser fuelPriceAccesser,
                      ITaksariDialogService messageBoxes)
 {
     //Register messengers
     IMvxMessenger messenger = Mvx.Resolve<IMvxMessenger>();
     messenger.Subscribe<ToggleUserActivityMessage>(OnToggleUserActivityMessageReceived, MvxReference.Strong);
     messenger.Subscribe<DeleteUserMessage>(OnDeleteUserMessageReceived, MvxReference.Strong);
     messenger.Subscribe<PaymentRequestedMessage>(OnPaymentRequestedMessageReceived, MvxReference.Strong);
     //FuelPriceAccesser. PropertyChangedEvent is handled for setting new fuelprices to _appsettings
     AppSettings.FuelPricesAreUpToDate = false;
     fuelPriceAccesser.FuelPricesUpdated += OnFuelPricesUpdated;
     //UserRepository
     _userRepositoryTask = userRepositoryTask;
     //Init SortingObservableCollections
     ActiveUserViewModelsTask =
         new NotifyTaskCompletion<ObservableCollection<IUserViewModel>>(InitActiveUserViewModelsAsync());
     ActiveUserViewModelsTask.PropertyChanged += OnActiveUsersTaskPropertyChanged;
     InActiveUserViewModelsTask =
         new NotifyTaskCompletion<ObservableCollection<IUserViewModel>>(InitInActiveUserViewModelsAsync());
     //BillCalculator
     _billCalculator = billCalculator;
     _billCalculator.CostsPerKm = AppSettings.FinalCostsPerKm;
     _billCalculator.BillsChanged += OnBillsChanged;
     _billCalculator.LocatorStatusChanged += OnLocatorStatusChanged;
     //Message boxes
     _dialogService = messageBoxes;
     //Default LocatorStatus
     LocatorStatus = new BindablePositionStatus(WrappedPositionStatus.Ready);
 }
Exemple #25
0
        public async Task <IAssistResult <T1> > HandleAssist <T, T1>(IAssist assist) where T : class where T1 : class
        {
            var list = await HelperDataServices.GetPagedQueryDoAsync <T>(assist.Query, 1, 100);

            var count = await HelperDataServices.GetItemsCount <T>();

            var resultMapped = _mapper.Map <IEnumerable <T>, IEnumerable <T1> >(list);
            IncrementalList <T1> valueList = new IncrementalList <T1>(LoadItems);

            valueList.LoadItems(resultMapped);

            valueList = new IncrementalList <T1>((x, index) => {
                NotifyTaskCompletion.Create(HelperDataServices.GetPagedQueryDoAsync <T>(assist.Query, index, 100), (sender, arg) =>
                {
                    if (sender is INotifyTaskCompletion <IEnumerable <T> > taskCompleted)
                    {
                        if (taskCompleted.IsSuccessfullyCompleted)
                        {
                            var resultValue = _mapper.Map <IEnumerable <T>, IEnumerable <T1> >(taskCompleted.Result);
                            valueList.LoadItems(resultValue);
                        }
                    }
                });
            })
            {
                MaxItemCount = count
            };


            T1 assistResult           = valueList.FirstOrDefault();
            IAssistResult <T1> result = new AssistResult <T1>(assistResult, valueList);

            return(result);
        }
Exemple #26
0
        private void RemoveSessionProc()
        {
            var result = MessageBox.Show("Are you sure you want to delete selected session?", "Session",
                                         MessageBoxButton.YesNo);

            if (result == MessageBoxResult.Yes)
            {
                try
                {
                    var enrollments =
                        _repository.Enrollment.GetRange(c => c.SessionCode == SelectedSession.Model.SessionId);

                    if (enrollments.Count > 0)
                    {
                        MessageBox.Show("Unable to delete sessions with enrollees");
                    }

                    else
                    {
                        NotifyTaskCompletion.Create(RemoveSessionAsync);
                    }
                }
                catch (Exception e)
                {
                    MessageBox.Show("Unable to delete opening");
                }
            }
        }
        public void NotifierT_TaskCompletesSuccessfully_NotifiesProperties()
        {
            var tcs                                 = new TaskCompletionSource <object>();
            var notifier                            = NotifyTaskCompletion.Create(tcs.Task);
            var taskNotification                    = PropertyNotified(notifier, n => n.Task);
            var statusNotification                  = PropertyNotified(notifier, n => n.Status);
            var isCompletedNotification             = PropertyNotified(notifier, n => n.IsCompleted);
            var isSuccessfullyCompletedNotification = PropertyNotified(notifier, n => n.IsSuccessfullyCompleted);
            var isCanceledNotification              = PropertyNotified(notifier, n => n.IsCanceled);
            var isFaultedNotification               = PropertyNotified(notifier, n => n.IsFaulted);
            var exceptionNotification               = PropertyNotified(notifier, n => n.Exception);
            var innerExceptionNotification          = PropertyNotified(notifier, n => n.InnerException);
            var errorMessageNotification            = PropertyNotified(notifier, n => n.ErrorMessage);
            var resultNotification                  = PropertyNotified(notifier, n => n.Result);

            tcs.SetResult(null);

            Assert.IsFalse(taskNotification());
            Assert.IsTrue(statusNotification());
            Assert.IsTrue(isCompletedNotification());
            Assert.IsTrue(isSuccessfullyCompletedNotification());
            Assert.IsFalse(isCanceledNotification());
            Assert.IsFalse(isFaultedNotification());
            Assert.IsFalse(exceptionNotification());
            Assert.IsFalse(innerExceptionNotification());
            Assert.IsFalse(errorMessageNotification());
            Assert.IsTrue(resultNotification());
        }
Exemple #28
0
 public AddStations(MainWindow mainWindow)
 {
     GetAllStationsAsync = new NotifyTaskCompletion <List <Stations> >(client.GetAllStationsAsync(new System.Net.Http.HttpClient()));
     this.mainWindow     = mainWindow;
     DataContext         = this;
     InitializeComponent();
 }
        public void Notifier_TaskFaulted_NotifiesProperties()
        {
            var tcs                                 = new TaskCompletionSource();
            var notifier                            = NotifyTaskCompletion.Create(tcs.Task);
            var taskNotification                    = PropertyNotified(notifier, n => n.Task);
            var statusNotification                  = PropertyNotified(notifier, n => n.Status);
            var isCompletedNotification             = PropertyNotified(notifier, n => n.IsCompleted);
            var isSuccessfullyCompletedNotification = PropertyNotified(notifier, n => n.IsSuccessfullyCompleted);
            var isCanceledNotification              = PropertyNotified(notifier, n => n.IsCanceled);
            var isFaultedNotification               = PropertyNotified(notifier, n => n.IsFaulted);
            var exceptionNotification               = PropertyNotified(notifier, n => n.Exception);
            var innerExceptionNotification          = PropertyNotified(notifier, n => n.InnerException);
            var errorMessageNotification            = PropertyNotified(notifier, n => n.ErrorMessage);

            tcs.SetException(new NotImplementedException());

            Assert.IsFalse(taskNotification());
            Assert.IsTrue(statusNotification());
            Assert.IsTrue(isCompletedNotification());
            Assert.IsFalse(isSuccessfullyCompletedNotification());
            Assert.IsFalse(isCanceledNotification());
            Assert.IsTrue(isFaultedNotification());
            Assert.IsTrue(exceptionNotification());
            Assert.IsTrue(innerExceptionNotification());
            Assert.IsTrue(errorMessageNotification());
        }
Exemple #30
0
        private void RemoveCandidateProc()
        {
            var result = MessageBox.Show("Are you sure you want to delete selected candidate?", "Candidate",
                                         MessageBoxButton.YesNo);

            if (result == MessageBoxResult.Yes)
            {
                try
                {
                    var history =
                        _repository.History.GetRange(c => c.CandidateId == SelectedCandidate.Model.CandidateId);
                    var canQual =
                        _repository.CanQualify.GetRange(c => c.CandidateId == SelectedCandidate.Model.CandidateId);
                    if (history.Count > 0)
                    {
                        MessageBox.Show("Unable to delete candidates with history");
                    }

                    else if (canQual.Count > 0)
                    {
                        MessageBox.Show("Unable to delete candidates with qualifications.");
                    }

                    else
                    {
                        NotifyTaskCompletion.Create(RemoveCandidateAsync);
                    }
                }
                catch (Exception e)
                {
                    MessageBox.Show("Unable to delete opening");
                }
            }
        }
        /// <summary>
        ///  This enable incremental load of the data.
        /// </summary>
        /// <param name="count"></param>
        /// <param name="baseIndex"></param>
        protected override void LoadMoreItems(uint count, int baseIndex)
        {
            var brokerDataService = DataServices.GetCommissionAgentDataServices();

            NotifyTaskCompletion.Create <IEnumerable <CommissionAgentSummaryViewObject> >(
                brokerDataService.GetPagedSummaryDoAsync(baseIndex, DefaultPageSize), PagingEvent);
        }
Exemple #32
0
        public LoginViewModel(IMvxNavigationService navigationService, IAuthService authService, IUserDialogs userDialogs, IValidator validator, IBottomNavigationViewModelService bottomNavigationViewModelService, ITopNavigationViewModelService topNavigationViewModelService)
        {
            _navigationService                = navigationService;
            _topNavigationViewModelService    = topNavigationViewModelService;
            _bottomNavigationViewModelService = bottomNavigationViewModelService;

            _authService = authService;
            _userDialogs = userDialogs;

            _validationHelper = new ValidationHelper(validator, this, Errors.Value, (propertyName) => { FocusName.Value = propertyName; });

            ValidateEmailCommand    = new MvxCommand(() => _validationHelper.Validate(() => Email));
            ValidatePasswordCommand = new MvxCommand(() => _validationHelper.Validate(() => Password));

            InitValidationCommand = new MvxCommand(() => {
                _validationHelper.ResetValidation();
            });

            LogInCommand = new MvxCommand(() =>
            {
                if (!IsTaskExecutedValueConverter.Convert(LogInTask.Value))
                {
                    LogInTask.Value = NotifyTaskCompletion.Create(AttemptLogInAsync);
                }
            });

            ShowRegistrationViewModelCommand = new MvxAsyncCommand(async() =>
            {
                await _navigationService.Navigate <RegistrationViewModel>();
            });
        }
        public async Task Test()
        {
            var   notifyTask = new NotifyTaskCompletion <bool>(async() => await Task.Run(() => true));
            await notifyTask;

            Assert.IsTrue(notifyTask);
        }
        public DashboardViewModel(IServiceFactory serviceFactory)
        {
            _serviceFactory = serviceFactory;
            RecalculateCostsForAssemblyCommand = new DelegateCommand<string>(OnRecalculateCostsForAssemblyCommand);
            RecalculateCommand = new DelegateCommand<string>(OnRecalculateCommand);

            LatestVersion = new NotifyTaskCompletion<string>(getLatestVersionNumberAsync("https://github.com/AlexZhidkov/BedfordHarbourBOM/releases/latest"));
        }
        protected override async Task OnLoadStateAsync(LoadStateEventArgs e, bool isFirstRun)
        {
            if(this.View != null)
                this.View.GotFocus += View_GotFocus;

            this.AppCacheTask = new NotifyTaskCompletion<string>(Platform.Current.Storage.GetAppDataCacheFolderSizeAsync());

            await base.OnLoadStateAsync(e, isFirstRun);
        }
Exemple #36
0
		public ViewModel (IFeeder feeder)
		{
			_feeder = feeder;

			ScheduleEntries = new NotifyTaskCompletion<ObservableCollection<ScheduleEntryViewModel>> (GetSchedule ());

			ScheduleEntries.PropertyChanged += (object sender, PropertyChangedEventArgs e) => 
			{
				if(e.PropertyName == "Result")
				{
					AddMealCommand = new RelayCommand (o => {
						ScheduleEntries.Result.Add (new ScheduleEntryViewModel ());
					});
	
					CommitScheduleCommand = new RelayCommand (async o => await SetSchedule (ScheduleEntries.Result));
				}
			};

			RunCommand = new RelayCommand (o => _feeder.Feed ());
		}
        public CategoriesListViewModel(IProductService service, IAppNavigation navi, IScanner scanner, LogOutCommand logOut)
        {
            _service = service;
            _navi = navi;
            _scanner = scanner;
            _logOut = logOut;

            MessagingCenter.Subscribe<Category>(this, Messages.NavigateTo, NavigateToCategory);

            _searchCommand = new Command(Search, () => !string.IsNullOrWhiteSpace(SearchTerm));
            ScanCommand = new Command(async () =>
            {
                var result = await _scanner.Scan();

                SearchTerm = result.Text;
                Search();
            });

            AboutCommand = new Command(async () => await _navi.ShowAbout());

            Categories = new NotifyTaskCompletion<List<CategoryViewModel>>(GetCategories());
        }
Exemple #38
0
        protected override async Task OnRefreshAsync(CancellationToken ct)
        {
            try
            {
                this.ShowBusyStatus(Strings.Resources.TextLoading, true);

                this.RecommendedItemsTask = new NotifyTaskCompletion<IEnumerable<ContentItemBase>>(DataSource.Current.GetRecommendedItemsAsync(ct));
                this.FriendsWatchedItemsTask = new NotifyTaskCompletion<IEnumerable<ContentItemBase>>(DataSource.Current.GetFriendsWatchedItemsAsync(ct));
                
                // Load queue data
                var list = new QueueCollection();
                list.AddRange(await DataSource.Current.GetQueueItemsAsync(Platform.Current.AuthManager.User?.ID, ct));
                this.Queue = list;

                ct.ThrowIfCancellationRequested();

                this.ShowBusyStatus("Updating tiles...");
                await Platform.Current.Notifications.CreateOrUpdateTileAsync(this);

                this.ClearStatus();
            }
            catch (OperationCanceledException)
            {
                this.ShowTimedStatus(Strings.Resources.TextCancellationRequested, 3000);
            }
            catch (Exception ex)
            {
                this.ShowTimedStatus(Strings.Resources.TextErrorGeneric);
                Platform.Current.Logger.LogError(ex, "Error during RefreshAsync");
            }
        }
        /// <summary>
        /// Calls the ILineService with submitted points.
        /// </summary>
        private async Task AddLine(Point startPoint, Point endPoint)
        {
            // Clear error message
            this.State = CanvasState.BusyState;
            this.ErrorMessage = null;
            this.TimeMessage = null;            

            // Query the ILineService with selected start and end points.
            this.AddLineTask = new NotifyTaskCompletion<LineQueryResult>(
                this.lineService.AddLineAsync(startPoint, endPoint, PathAlgorithm, cancelToken.Token));
            LineQueryResult result = await this.AddLineTask.Task;

            // Process the query result.
            if (this.AddLineTask.IsSuccessfullyCompleted && result.Success)
            {
                this.Lines.Add(result.Result);
                this.TimeMessage = result.Time + " MS";
                this.State = CanvasState.ReadyState;
            }
            else
            {
                this.ErrorMessage = result.Message;
                this.State = CanvasState.ErrorState;
            }
        }
 private void RefreshPurchaseCollection()
 {
     PurchaseTicketsTask
         = new NotifyTaskCompletion<ObservableCollection<PurchaseTicket>>
         (_customerOperationProvider.GetAllPurchaseTicketAsync());
 }
 public WelcomeViewModel(IAppNavigation navi)
 {
     _navi = navi;
     _slim = new SemaphoreSlim(0, 1);
     IsBusy = new NotifyTaskCompletion<int>(GoToFirstPage());
 }
Exemple #42
0
 public MainViewModel()
 {
     UrlByteCount = new NotifyTaskCompletion<int>(
       MyStaticService.CountBytesInUrlAsync("http://www.example.com"));
 }
 static BillHelper()
 {
     CateGoryItems = new NotifyTaskCompletion<ObservableCollection<BillCategoryItem>>(getCagegoryTask());
 }
        public InstagramExplorerViewModel(
            IViewModelNavigator navigator,
            InstagramExplorer instagramExplorer,
            SettingsProvider settings,
            ImagePrinter printer, PatternViewModelProvider patternVMProvider,
            ImageUtils imageUtils, IMappingEngine mappingEngine)
        {
            _navigator = navigator;
            _printer = printer;
            _patternVmProvider = patternVMProvider;
            _imageUtils = imageUtils;
            _mappingEngine = mappingEngine;
            _instagramExplorer = instagramExplorer;
            AppSettingsDto appSettings = settings.GetAppSettings();
            if (appSettings != null)
                _printerName = appSettings.PrinterName;

            IsHashTag = true;
            SearchAsyncOperation= new NotifyTaskCompletion<ImageResponse>(Task.FromResult(default(ImageResponse)));
            _searchTokenSource= new CancellationTokenSource();
        }
        private void Search(string text)
        {
            if (!string.IsNullOrEmpty(_previousSearch))
            {
                if (string.Compare(text, _previousSearch, StringComparison.OrdinalIgnoreCase) != 0)
                {
                    _nextUrl = null;
                    Images.Clear();
                }
            }
            _previousSearch = text;
            SearchCommand.RaiseCanExecuteChanged();

            _searchTokenSource.Cancel();
            _searchTokenSource= new CancellationTokenSource();

            SearchAsyncOperation = new NotifyTaskCompletion<ImageResponse>(SearchUpdateImages(text, _searchTokenSource.Token));
        }
        public override async Task ExecuteAsync(object parameter)
        {
            if (!CanExecute(parameter))
            {
                return;
            }

            Execution = new NotifyTaskCompletion(_execute());
            RaiseCanExecuteChanged();

            await Execution.TaskCompletion;

            RaiseCanExecuteChanged();
        }
 private async Task ClearAppDataCacheAsync()
 {
     await Platform.Current.Storage.ClearAppDataCacheFolderAsync();
     this.AppCacheTask = new NotifyTaskCompletion<string>(Platform.Current.Storage.GetAppDataCacheFolderSizeAsync());
 }