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));
}
