public async Task <List <OrderDto> > Get() { _logger.LogInformation(this.User.Identity.Name); var response = await _queryDispatcher.QueryAsync(GetOrderAll.Instance); return(response); }
private async Task ReloadMonth() { if (Month != null) { IsLoading = true; Items.Clear(); IEnumerable<CategoryWithAmountModel> categories = await queryDispatcher.QueryAsync(new ListMonthCategoryWithOutcome(Month)); foreach (CategoryWithAmountModel category in categories) { Items.Add(new SummaryCategoryViewModel() { CategoryKey = category.Key, Name = category.Name, Color = category.Color, Amount = category.TotalAmount }); } TotalAmount = await queryDispatcher.QueryAsync(new GetTotalMonthOutcome(Month)); Items.Add(new SummaryTotalViewModel(TotalAmount)); IsLoading = false; } }
private async Task EnsureUserStorageAsync(IKey userKey) { if (!storage.TryGetValue(userKey, out UserModel model)) { storage[userKey] = model = new UserModel(); model.DefaultCurrencyUniqueCode = await queryDispatcher.QueryAsync(new GetCurrencyDefault() { UserKey = userKey }); IEnumerable <CurrencyModel> currencies = await queryDispatcher.QueryAsync(new ListAllCurrency() { UserKey = userKey }); foreach (CurrencyModel currency in currencies) { List <ExchangeRateModel> rates = await queryDispatcher.QueryAsync(new ListTargetCurrencyExchangeRates(currency.UniqueCode) { UserKey = userKey }); rates.Sort(exchangeRateComparer); model.Currencies[currency.UniqueCode] = rates; } } }
private async Task LoadMonthViewAsync(GroupViewModel viewModel, MonthModel prefered) { ViewModel.IsLoading = true; IEnumerable <MonthModel> months = await queryDispatcher.QueryAsync(new ListMonthWithOutcome()); int?preferedIndex = null; int index = 0; foreach (MonthModel month in months) { viewModel.Add(month.ToString(), month); if (prefered == month) { preferedIndex = index; } index++; } if (preferedIndex != null) { pvtGroups.SelectedIndex = preferedIndex.Value; } ViewModel.IsLoading = false; }
public async Task <TResult> QueryAsync <TResult>(IQuery <TResult> query) { if (query == null) { throw new ArgumentNullException(nameof(query)); } var queryCachingConfiguration = GetQueryCachingConfiguration(query.GetType()); if (queryCachingConfiguration == null) { return(await queryDispatcher.QueryAsync(query)); } var cachedResult = cachingConfiguration.Read(query); if (cachedResult != null) { return((TResult)cachedResult); } var result = await queryDispatcher.QueryAsync(query); var lifetime = queryCachingConfiguration.Lifetime ?? cachingConfiguration.DefaultLifetime; var priority = queryCachingConfiguration.Priority ?? cachingConfiguration.DefaultPriority; cachingConfiguration.Write(query, result, lifetime, priority); return(result); }
public async Task <CurrencyFormatter> CreateAsync() { var currencies = await queries.QueryAsync(new ListAllCurrency()); var decimalDigits = await queries.QueryAsync(new GetPriceDecimalDigitsProperty()); return(new CurrencyFormatter(currencies, decimalDigits)); }
public async Task <ActionResult <ProductDto> > GetAsync(Guid id) { var product = await queryDispatcher.QueryAsync(new GetProduct(id)); if (product is null) { return(NotFound()); } return(Ok(product)); }
public async Task InitializeAsync(IQueryDispatcher queryDispatcher) { defaultCurrencyUniqueCode = await queryDispatcher.QueryAsync(new GetCurrencyDefault()); IEnumerable <CurrencyModel> currencies = await queryDispatcher.QueryAsync(new ListAllCurrency()); foreach (CurrencyModel currency in currencies) { List <ExchangeRateModel> rates = await queryDispatcher.QueryAsync(new ListTargetCurrencyExchangeRates(currency.UniqueCode)); rates.Sort(exchangeRateComparer); this.currencies[currency.UniqueCode] = rates; } }
public async Task <ActionResult> GetGroups([FromQuery] IEnumerable <Guid> ids) { var query = new GetGroupsByIdQuery() { GroupIds = ids }; var result = await _queryDispatcher.QueryAsync <IEnumerable <ScheduledTrainingDto> >(query); if (result == null) { return(NotFound()); } return(Ok(result)); }
public async Task <ActionResult <PlayerDto> > GetPlayer([FromRoute] Guid playerId) { var query = new GetPlayerQuery() { PlayerId = playerId }; var result = await _queryDispatcher.QueryAsync <PlayerDto>(query); if (result == null) { return(NotFound()); } return(Ok(result)); }
public async Task ReplaceAsync(IList <SummaryCategoryViewModel> collection) { IEnumerable <CategoryWithAmountModel> categories = await queryDispatcher.QueryAsync(new ListMonthCategoryWithOutcome(month)); foreach (CategoryWithAmountModel category in categories) { collection.Add(new SummaryCategoryViewModel() { CategoryKey = category.Key, Name = category.Name, Color = category.Color, Amount = category.TotalAmount }); } }
private async void OnPriceChanged() { Price price = Price; if (price == null) { Content = null; return; } if (price.Currency != currency?.UniqueCode) { currency = currencyProvider.Get(price.Currency); string symbol = await queryDispatcher.QueryAsync(new GetCurrencySymbol(price.Currency)); if (symbol != currency.Symbol) { currency = currency.ForCustomSymbol(symbol); } } Content = new TextBlock() { Text = currency.Format(price.Value), FontSize = FontSize, Foreground = Foreground, }; }
private async void LoadExchangeRateList() { if (isExchangeRateListLoaded) { return; } if (queryDispatcher == null) { return; } List <ExchangeRateModel> exchangeRates = await queryDispatcher.QueryAsync(new ListTargetCurrencyExchangeRates(UniqueCode)); if (exchangeRates == null) { return; } ExchangeRates.AddRange(exchangeRates); ExchangeRates.SortDescending(e => e.ValidFrom); RaisePropertyChanged(nameof(ExchangeRates)); isExchangeRateListLoaded = true; }
protected override async void OnNavigatedTo(NavigationEventArgs e) { base.OnNavigatedTo(e); OutcomeViewModel viewModel = new OutcomeViewModel(navigator, domainFacade); OutcomeParameter parameter = e.Parameter as OutcomeParameter; if (parameter != null) { if (parameter.Amount != null) { viewModel.Amount = (float)parameter.Amount.Value; } if (parameter.Description != null) { viewModel.Description = parameter.Description; } if (!parameter.CategoryKey.IsEmpty) { viewModel.SelectedCategories.Add(parameter.CategoryKey); } } IEnumerable <CategoryModel> categories = await queryDispatcher.QueryAsync(new ListAllCategory()); viewModel.Categories.AddRange(categories); DataContext = viewModel; }
protected async override void OnNavigatedTo(NavigationEventArgs e) { base.OnNavigatedTo(e); CategoryListParameter parameter = e.GetParameterOrDefault <CategoryListParameter>(); ViewModel = new CategoryListViewModel(commandDispatcher, navigator); // Bind events. handlers.Add(eventHandlers.AddUiThread <CategoryCreated>(ViewModel, Dispatcher)); handlers.Add(eventHandlers.AddUiThread <CategoryRenamed>(ViewModel, Dispatcher)); handlers.Add(eventHandlers.AddUiThread <CategoryDescriptionChanged>(ViewModel, Dispatcher)); handlers.Add(eventHandlers.AddUiThread <CategoryColorChanged>(ViewModel, Dispatcher)); handlers.Add(eventHandlers.AddUiThread <CategoryIconChanged>(ViewModel, Dispatcher)); handlers.Add(eventHandlers.AddUiThread <CategoryDeleted>(ViewModel, Dispatcher)); // Just to show the loading wheel. await Task.Delay(100); IEnumerable <CategoryModel> models = await queryDispatcher.QueryAsync(new ListAllCategory()); foreach (CategoryModel model in models) { CategoryEditViewModel viewModel = new CategoryEditViewModel(commandDispatcher, navigator, model.Key, model.Name, model.Description, model.Color, model.Icon); if (parameter.Key.Equals(model.Key)) { viewModel.IsSelected = true; } ViewModel.Items.Add(viewModel); } UpdateSelectedItemView(); ContentLoaded?.Invoke(this, EventArgs.Empty); }
protected async override void OnNavigatedTo(NavigationEventArgs e) { base.OnNavigatedTo(e); eventHandlers .Add <CurrencyCreated>(this) .Add <CurrencyDefaultChanged>(this) .Add <CurrencyExchangeRateSet>(this) .Add <CurrencyExchangeRateRemoved>(this) .Add <CurrencySymbolChanged>(this) .Add <CurrencyDeleted>(this); CurrencyParameter parameter = (CurrencyParameter)e.Parameter; IEnumerable <CurrencyModel> models = await queryDispatcher.QueryAsync(new ListAllCurrency()); ViewModel = new CurrencyListViewModel(navigator); foreach (CurrencyModel model in models) { ViewModel.Items.Add(new CurrencyEditViewModel(navigator, commandDispatcher, messageBuilder, queryDispatcher, model.UniqueCode, model.Symbol)); } UpdateStandalone(); CurrencyModel defaultModel = models.FirstOrDefault(c => c.IsDefault); if (defaultModel != null) { UpdateDefaultCurrency(defaultModel.UniqueCode); } ContentLoaded?.Invoke(this, EventArgs.Empty); }
protected async override void OnNavigatedTo(NavigationEventArgs e) { base.OnNavigatedTo(e); CategoryListParameter parameter = (CategoryListParameter)e.Parameter; ViewModel = new CategoryListViewModel(domainFacade); // Just to show the loading wheel. await Task.Delay(100); IEnumerable <CategoryModel> models = await queryDispatcher.QueryAsync(new ListAllCategory()); foreach (CategoryModel model in models) { CategoryEditViewModel viewModel = new CategoryEditViewModel(domainFacade, model.Key, model.Name, model.Description, model.Color); if (parameter.Key.Equals(model.Key)) { viewModel.IsSelected = true; } ViewModel.Items.Add(viewModel); } UpdateSelectedItemView(); ContentLoaded?.Invoke(this, EventArgs.Empty); }
protected async override void OnNavigatedTo(NavigationEventArgs e) { base.OnNavigatedTo(e); OverviewParameter parameter = (OverviewParameter)e.Parameter; string categoryName = parameter.CategoryKey.IsEmpty ? "All" : await queryDispatcher.QueryAsync(new GetCategoryName(parameter.CategoryKey)); categoryKey = parameter.CategoryKey; object period = null; if (parameter.Month != null) { month = parameter.Month; period = parameter.Month; } if (parameter.Year != null) { year = parameter.Year; period = parameter.Year; } ViewModel = new OverviewViewModel(navigator, parameter.CategoryKey, categoryName, period); ViewModel.Reload += OnViewModelReload; handlers.Add(eventHandlers.AddUiThread <OutcomeCreated>(ViewModel, Dispatcher)); handlers.Add(eventHandlers.AddUiThread <OutcomeAmountChanged>(ViewModel, Dispatcher)); handlers.Add(eventHandlers.AddUiThread <OutcomeDescriptionChanged>(ViewModel, Dispatcher)); handlers.Add(eventHandlers.AddUiThread <OutcomeWhenChanged>(ViewModel, Dispatcher)); if (userPreferences.TryLoad("Overview.SortDescriptor", out SortDescriptor <OverviewSortType> sortDescriptor)) { SortDescriptor = sortDescriptor; } else { SortDescriptor = new SortDescriptor <OverviewSortType>(OverviewSortType.ByDate, SortDirection.Ascending); } await ReloadAsync(); ContentLoaded?.Invoke(this, EventArgs.Empty); }
public async Task <ActionResult> GetPlayerSchedule(Guid playerId) { var query = new PlayerScheduleQuery() { PlayerId = playerId }; var results = await _queryDispatcher.QueryAsync <IEnumerable <ScheduledTrainingDto> >(query); if (results == null) { return(NotFound()); } else { return(Ok(results)); } }
public async Task <ActionResult <IdentityDto> > GetMe() { var query = new GetIdentity { Username = User.Identity.Name }; var identity = await _queryDispatcher.QueryAsync(query); return(Ok(identity)); }
public async Task <TResult> QueryAsync <TResult>(IQuery <TResult> query) { if (query == null) { throw new ArgumentNullException(nameof(query)); } return(await queryDispatcher.QueryAsync(query)); }
public Task <TOutput> QueryAsync <TOutput>(IQuery <TOutput> query) { if (query is UserQuery userQuery) { userQuery.UserKey = userKeyGetter(); } return(inner.QueryAsync(query)); }
public async Task <ActionResult> GetPlayerAttendance(Guid playerId, [FromQuery] string dateFrom, [FromQuery] string dateTo) { var query = new PlayerAttendanceQuery() { PlayerId = playerId, DateFrom = dateFrom, DateTo = dateTo }; var results = await _queryDispatcher.QueryAsync <IEnumerable <PlayerAttendanceDto> >(query); if (results == null) { return(NotFound()); } else { return(Ok(results)); } }
private async void OnLoaded(object sender, RoutedEventArgs e) { models = (await queryDispatcher.QueryAsync(new ListAllCategory())).ToList(); gvwCategories.ItemsSource = models; if (!SelectedKey.IsEmpty) { OnSelectedKeyChanged(); } }
public async Task <ActionResult <OrderDto> > Get([FromRoute] GetOrder query) { var order = await _queryDispatcher.QueryAsync(query); if (order is null) { return(NotFound()); } return(order); }
public async Task InitializeAsync(IQueryDispatcher queryDispatcher) { List <CurrencyModel> models = await queryDispatcher.QueryAsync(new ListAllCurrency()); foreach (CurrencyModel model in models) { storage[model.UniqueCode] = new Model() { UniqueCode = model.UniqueCode, Symbol = model.Symbol }; } }
public Task <TOutput> QueryAsync <TOutput>(IQuery <TOutput> query) { if (query is UserQuery userQuery) { string userId = httpContext.User.FindFirstValue(ClaimTypes.NameIdentifier); if (!String.IsNullOrEmpty(userId)) { userQuery.UserKey = StringKey.Create(userId, "User"); } } return(inner.QueryAsync(query)); }
public async Task <ActionResult <IEnumerable <ChallengeDto> > > GetCHallenges([FromQuery] IEnumerable <Guid> Id) { var query = new GetChallengesQuery() { ChallengeId = Id }; var result = await _queryDispatcher.QueryAsync <IEnumerable <ChallengeDto> >(query); if (result == null) { return(NotFound()); } return(Ok(result)); }
public async Task ShowAsync(object parameter) { if (parameter is CategoryCreateParameter create) { key = KeyFactory.Empty(typeof(Category)); model = new CategoryNameDescriptionModel(null, null); } else if (parameter is CategoryRenameParameter rename) { key = rename.Key; model = await queryDispatcher.QueryAsync(new GetCategoryNameDescription(key)); Name = model.Name; Description = model.Description; } ContentDialogResult result = await ShowAsync(); if ((result == ContentDialogResult.Primary || IsEnterPressed) && (Name != model.Name || Description != model.Description)) { if (key.IsEmpty) { if (String.IsNullOrEmpty(Name)) { return; } Color color = ColorConverter.Map(Colors.Black); await commandDispatcher.HandleAsync(new CreateCategory(Name, Description, color)); Name = Name; } else { if (Name != model.Name) { await commandDispatcher.HandleAsync(new RenameCategory(key, Name)); Name = Name; } if (Description != model.Description) { await commandDispatcher.HandleAsync(new ChangeCategoryDescription(key, Description)); Description = Description; } } } }
public async Task <ActionResult <IReadOnlyList <AttendanceDto> > > BrowseAttendancesAsync(Guid conferenceId) { var attendances = await _queryDispatcher.QueryAsync(new BrowseAttendances { ConferenceId = conferenceId, UserId = _context.Identity.Id }); if (attendances is null) { return(NotFound()); } return(Ok(attendances)); }