/// <summary>
/// Load event.
/// </summary>
/// <param name="value"></param>
public void Load(string value)
{
if (string.IsNullOrEmpty(value))
{
return;
}
_initializationNotifier = NotifyTaskCompletion.Create(LoadDto(value), _loadCompleted);
}
private void OnAssistCommand(object param)
{
IDictionary <string, string> values = (Dictionary <string, string>)param;
string assistTableName = values.ContainsKey("AssistTable") ? values["AssistTable"] as string : null;
string assistQuery = values.ContainsKey("AssistQuery") ? values["AssistQuery"] as string : null;
this.AssistNotifierInitialized = NotifyTaskCompletion.Create <bool>(AssistQueryRequestHandler(assistTableName, assistQuery), AssistExecuted);
}
public DriversControlViewModel(IDataServices services, IRegionManager manager) : base(services)
{
_regionManager = manager;
_clientDataServices = DataServices.GetClientDataServices();
GoBackCommand = new DelegateCommand(GoBack);
GoForwardCommand = new DelegateCommand(GoForward);
_drivers = new IncrementalList <ClientSummaryExtended>(LoadMoreItems);
_notifyTaskCompletion = NotifyTaskCompletion.Create <IEnumerable <ClientSummaryExtended> >(_clientDataServices.GetPagedSummaryDoAsync(0, DefaultPageSize), PagingEvent);
}
/// The ctor has been initialized correctly.
/// <summary>
/// This execute the data payload received from the toolbar
/// </summary>
/// <param name="services">DataServices</param>
/// <param name="manager">Event manager for communicating between view model</param>
/// <param name="payLoad">DataPayload to be executed</param>
public override void ExecutePayload(IDataServices services, IEventManager manager, ref DataPayLoad payLoad)
{
_clientDataServices = services.GetClientDataServices();
_payload = payLoad;
EventManager = manager;
DataServices = services;
// FIXME: move to the parent class.
_initializationNotifier = NotifyTaskCompletion.Create <DataPayLoad>(HandleSaveOrUpdate(payLoad), ExecutedPayloadHandler);
}
/// <summary>
/// Execute the payload when the user press to save and it notifies the
/// </summary>
/// <param name="services">Data services are used to store the data.</param>
/// <param name="manager">Event manager is used to notify the caller and refresh data.</param>
/// <param name="payLoad">Payload to be updated</param>
public override void ExecutePayload(IDataServices services, IEventManager manager, ref DataPayLoad payLoad)
{
CurrentEventManager = manager;
CurrentPayload = payLoad;
DataServices = services ?? throw new ArgumentNullException($"Cannot save without DataServices");
ToolbarInitializationNotifier =
NotifyTaskCompletion.Create <DataPayLoad>(HandleSaveOrUpdate(payLoad), ExecutedPayloadHandler);
_invoiceDataServices = services.GetInvoiceDataServices();
}
void SelectedFormChanged(object sender, SelectedItemChangedEventArgs <ModelNameBase> e)
{
CurrentForm = null;
if (e.NewItem != null)
{
_cachedFormId = e.NewItem.Id;
CurrentForm = NotifyTaskCompletion.Create <PokemonForm>(LoadFormByIdAsync(e.NewItem.Id));
}
}
public DealsPageViewModel(CheapSharkAPI api, INavigationService navigation)
{
API = api;
Navigation = navigation;
Deals = NotifyTaskCompletion.Create <ObservableCollection <Deal> > (GetDeals());
Title = "Deals";
IsBusy = true;
Messenger.Default.Register <RefreshDealsPageMessage> (this, RefreshPage);
}
public override async Task ExecuteAsync(object parameter)
{
if (CanExecute(parameter))
{
Execution = NotifyTaskCompletion.Create(execute((TParameter)parameter));
RaiseCanExecuteChanged();
await Execution.Task;
RaiseCanExecuteChanged();
}
}
public void StartAndNotify()
{
NotifyTaskCompletion.Create <IEnumerable <CompanySummaryDto> >(_companyDataServices.GetPagedSummaryDoAsync(1, DefaultPageSize), (sender, ev) =>
{
OnNotifyIncrementalList <CompanySummaryDto>(sender, ev);
});
MessageHandlerMailBox += MessageHandler;
EventManager.RegisterMailBox(EventSubsystem.CompanySummaryVm, MessageHandlerMailBox);
ActiveSubSystem();
}
public override async Task ExecuteAsync(object parameter)
{
Execution = NotifyTaskCompletion.Create(_command(_cancelCommand.Token));
RaiseCanExecuteChanged();
await Execution.TaskCompleted;
_cancelCommand.NotifyCommandFinished();
RaiseCanExecuteChanged();
}
void SelectedAbilityChanged(object sender, SelectedItemChangedEventArgs <ModelNameBase> e)
{
CurrentAbility = null;
PokemonList = null;
if (e.NewItem != null)
{
CurrentAbility = NotifyTaskCompletion.Create(LoadAbilityByIdAsync(e.NewItem.Id));
PokemonList = NotifyTaskCompletionCollection <PokemonAbility> .Create(LoadPokemonByAbilityAsync(e.NewItem.Id));
}
}
private void RemovePrereqProc()
{
var result = MessageBox.Show("Are you sure you want to remove selected prerquisite?", "Prerequisite",
MessageBoxButton.YesNo);
if (result == MessageBoxResult.Yes)
{
NotifyTaskCompletion.Create(RemovePrereqAsync);
}
}
public void Should_LoadAndNotify_CommissionAgent()
{
var notifyTable = NotifyTaskCompletion.Create <ICommissionAgent>(TestLoadDataValueNotify(),
(sender, ev) =>
{
if (sender is INotifyTaskCompletion <ICommissionAgent> task)
{
Assert.True(task.IsSuccessfullyCompleted);
}
});
}
private void SaveCourseProc()
{
if (NewCourse == null)
{
return;
}
if (!NewCourse.HasChanges)
{
return;
}
NotifyTaskCompletion.Create(SaveAddCourseAsync);
}
public ChangeAlbumViewModel(IMvxNavigationService navigationService, IUserDialogs userDialogs, IValidator validator, ISongService songService, IGenreService genreService, IArtistService artistService, IAlbumService albumService, IBottomNavigationViewModelService bottomNavigationViewModelService, ITopNavigationViewModelService topNavigationViewModelService)
{
_navigationService = navigationService;
_topNavigationViewModelService = topNavigationViewModelService;
_bottomNavigationViewModelService = bottomNavigationViewModelService;
_userDialogs = userDialogs;
_validationHelper = new ValidationHelper(validator, this, Errors.Value, (propertyName) => { FocusName.Value = propertyName; });
_songService = songService;
_genreService = genreService;
_artistService = artistService;
_albumService = albumService;
ValidateNameCommand = new MvxCommand(() => _validationHelper.Validate(() => Name));
ValidateGenresCommand = new MvxCommand(() => _validationHelper.Validate(() => Genres));
ValidateArtistsCommand = new MvxCommand(() => _validationHelper.Validate(() => Artists));
ValidateSongsCommand = new MvxCommand(() => _validationHelper.Validate(() => Songs));
InitValidationCommand = new MvxCommand(() => {
_validationHelper.ResetValidation();
});
ChangeCommand = new MvxCommand(() =>
{
if (!IsTaskExecutedValueConverter.Convert(ChangeTask.Value))
{
ChangeTask.Value = NotifyTaskCompletion.Create(AttemptChangeAsync);
}
});
_genresTokenParentObject = new TokenParentHelper(new MvxCommand <TokenViewModel>((_) =>
{
Genres.Value?.Remove(_ as TokenViewModel <GenreModel>);
ValidateGenresCommand.Execute(null);
}));
_artistsTokenParentObject = new TokenParentHelper(new MvxCommand <TokenViewModel>((_) =>
{
Artists.Value?.Remove(_ as TokenViewModel <ArtistModel>);
ValidateArtistsCommand.Execute(null);
}));
_songsTokenParentObject = new TokenParentHelper(new MvxCommand <TokenViewModel>((_) =>
{
Songs.Value?.Remove(_ as TokenViewModel <SongModel>);
ValidateSongsCommand.Execute(null);
}));
}
private void StartAndNotify()
{
NotifyTaskCompletion.Create <IEnumerable <LanguageViewObject> >(_helperDataServices.GetMappedAllAsyncHelper <LanguageViewObject, IDIOMAS>(), (task, ev) => {
if (ev is INotifyTaskCompletion <IEnumerable <LanguageViewObject> > languageList)
{
if (languageList.IsSuccessfullyCompleted)
{
LanguageDto = languageList.Result;
}
}
});
}
private void SaveEditProc()
{
if (EditModel == null)
{
return;
}
if (!EditModel.HasChanges)
{
return;
}
NotifyTaskCompletion.Create(SaveEditOpeningAsync);
}
void Forms_SelectedItemChanged(object sender, SelectedItemChangedEventArgs <PokemonForm> e)
{
CurrentForm = null;
CurrentMoveSet = null;
CurrentStats = null;
if (e.NewItem != null)
{
CurrentForm = NotifyTaskCompletion.Create(LoadFormAsync(e.NewItem.Id, Versions.SelectedItem, _currentLanguage));
CurrentMoveSet = NotifyTaskCompletion.Create(LoadMoveSetAsync(e.NewItem.Id, Versions.SelectedItem, _currentLanguage));
CurrentStats = NotifyTaskCompletion.Create(LoadStatsAsync(e.NewItem.Id, Versions.SelectedItem, _currentLanguage));
}
}
public override async Task ExecuteAsync(object parameter)
{
if (CanExecute(parameter))
{
cancelCommand.NotifyCommandStarting();
Execution = NotifyTaskCompletion.Create(execute((TParameter)parameter, cancelCommand.Token));
RaiseCanExecuteChanged();
await Execution.Task;
RaiseCanExecuteChanged();
cancelCommand.NotifyCommandFinished();
}
}
private void SaveCandidateProc()
{
if (NewCandidate == null)
{
return;
}
if (!NewCandidate.HasChanges)
{
return;
}
NotifyTaskCompletion.Create(SaveCandidateAsync);
}
public object Convert(object value, Type targetType, object parameter, string language)
{
try
{
Contact c = value as Contact;
return(NotifyTaskCompletion.Create <BitmapImage>(GetImage(c)));
}
catch (Exception ex)
{
Debug.WriteLine("Picture - " + ex.Message);
return(null);
}
}
public AddItemViewModel(IOfflineTaskService offlineTaskService, ILoggingService loggingService, SQLiteConnection database, INavigationService navigationService)
{
_offlineTaskService = offlineTaskService;
_loggingService = loggingService;
_database = database;
_navigationService = navigationService;
TagViewModel = new EditTagsViewModel(offlineTaskService, loggingService, database, navigationService);
NotifyTaskCompletion.Create(() => TagViewModel.ActivateAsync(null, null, NavigationMode.New));
AddCommand = new RelayCommand(() => AddingTask = NotifyTaskCompletion.Create(AddAsync));
CancelCommand = new RelayCommand(() => Cancel());
}
private void SaveCompanyProc()
{
if (NewCompany == null)
{
return;
}
if (!NewCompany.HasChanges)
{
return;
}
NotifyTaskCompletion.Create(() => SaveAddCompanyAsync());
_AddCompanyWindow.Close();
}
private void SaveQualificationProc()
{
if (NewQualification == null)
{
return;
}
if (!NewQualification.HasChanges)
{
return;
}
NotifyTaskCompletion.Create(() => SaveAddQualificationAsync());
_AddQualificationWindow.Close();
}
/// <summary>
/// Initialize the office visible.
/// </summary>
private void InitVisibleOffice()
{
NotifyTaskCompletion.Create <bool>(authService.IsLoginAuth(), (task, ev) =>
{
if (task is INotifyTaskCompletion <bool> taskCompletion)
{
if (taskCompletion.IsSuccessfullyCompleted)
{
this.IsVisibleOffice = taskCompletion.Result;
}
}
});
}
void SpeciesList_SelectedItemChanged(object sender, SelectedItemChangedEventArgs <SpeciesName> e)
{
Forms = null;
CurrentEvolutions = null;
CurrentLocations = null;
if (e.NewItem != null)
{
Forms = NotifyTaskCompletionCollection <PokemonForm> .Create(LoadFormsAsync(e.NewItem, Versions.SelectedItem, _currentLanguage));
CurrentEvolutions = NotifyTaskCompletion.Create(LoadEvolutionsAsync(e.NewItem.Id, Versions.SelectedItem, _currentLanguage));
CurrentLocations = NotifyTaskCompletion.Create(LoadLocationsAsync(e.NewItem.Id, Versions.SelectedItem, _currentLanguage));
_cachedSpeciesId = e.NewItem.Id;
}
}
private void LoadMoreDrivers(uint arg1, int index)
{
NotifyTaskCompletion.Create <IEnumerable <ClientSummaryExtended> >(_clientDataServices.GetPagedSummaryDoAsync(index, DefaultPageSize), (sender, ev) =>
{
if (sender is INotifyTaskCompletion <IEnumerable <ClientSummaryExtended> > value)
{
if (value.IsSuccessfullyCompleted)
{
var result = value.Task.Result.Except(DriversList);
DriversList.LoadItems(result);
}
}
});
}
// Variant 2: with cancellable async command.
private async Task GetCurrentWeatherCommandExecuteAsync(CancellationToken token)
{
CurrentWeather = NotifyTaskCompletion.Create(
() => GetCurrentWeatherAsync(token));
try
{
await CurrentWeather.Task;
}
catch
{
// Do nothing. Errors are handled in other place.
}
}
public object Convert(object value, Type targetType, object parameter, string language)
{
try
{
var id = (string)value;
return(NotifyTaskCompletion.Create <Contact>(GetContactForId(id)));
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return(null);
}
}
/// <summary>
/// Execute async
/// </summary>
/// <param name="parameter">Parameter</param>
/// <returns>Task</returns>
public override async Task ExecuteAsync(object parameter)
{
_cancelCommand.NotifyCommandStarting();
Execution = NotifyTaskCompletion.Create(_command(parameter, _cancelCommand.Token));
Execution.PropertyChanged += ExecutionPropertyChanged;
RaiseCanExecuteChanged();
await Execution.TaskCompleted;
_cancelCommand.NotifyCommandFinished();
RaiseCanExecuteChanged();
}
