/// <summary>
/// Binds the currencies list.
/// </summary>
private void BindCurrenciesList()
{
CurrencyDto dto = CatalogContext.Current.GetCurrencyDto();
CurrencyFilter.DataSource = dto.Currency;
CurrencyFilter.DataBind();
}
public async Task <int> Count(CurrencyFilter filter)
{
IQueryable <CurrencyDAO> Currencies = DataContext.Currency.AsNoTracking();
Currencies = DynamicFilter(Currencies, filter);
return(await Currencies.CountAsync());
}
private IQueryable <CurrencyDAO> OrFilter(IQueryable <CurrencyDAO> query, CurrencyFilter filter)
{
if (filter.OrFilter == null || filter.OrFilter.Count == 0)
{
return(query);
}
IQueryable <CurrencyDAO> initQuery = query.Where(q => false);
foreach (CurrencyFilter CurrencyFilter in filter.OrFilter)
{
IQueryable <CurrencyDAO> queryable = query;
if (CurrencyFilter.Id != null && CurrencyFilter.Id.HasValue)
{
queryable = queryable.Where(q => q.Id, CurrencyFilter.Id);
}
if (CurrencyFilter.Code != null && CurrencyFilter.Code.HasValue)
{
queryable = queryable.Where(q => q.Code, CurrencyFilter.Code);
}
if (CurrencyFilter.Name != null && CurrencyFilter.Name.HasValue)
{
queryable = queryable.Where(q => q.Name, CurrencyFilter.Name);
}
initQuery = initQuery.Union(queryable);
}
return(initQuery);
}
public async Task <ActionResult <List <Contract_CurrencyDTO> > > SingleListCurrency([FromBody] Contract_CurrencyFilterDTO Contract_CurrencyFilterDTO)
{
if (UnAuthorization)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
CurrencyFilter CurrencyFilter = new CurrencyFilter();
CurrencyFilter.Skip = 0;
CurrencyFilter.Take = 20;
CurrencyFilter.OrderBy = CurrencyOrder.Id;
CurrencyFilter.OrderType = OrderType.ASC;
CurrencyFilter.Selects = CurrencySelect.ALL;
CurrencyFilter.Id = Contract_CurrencyFilterDTO.Id;
CurrencyFilter.Code = Contract_CurrencyFilterDTO.Code;
CurrencyFilter.Name = Contract_CurrencyFilterDTO.Name;
List <Currency> Currencies = await CurrencyService.List(CurrencyFilter);
List <Contract_CurrencyDTO> Contract_CurrencyDTOs = Currencies
.Select(x => new Contract_CurrencyDTO(x)).ToList();
return(Contract_CurrencyDTOs);
}
public async Task <List <Store_CurrencyDTO> > SingleListCurrency([FromBody] Store_CurrencyFilterDTO Store_CurrencyFilterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
CurrencyFilter CurrencyFilter = new CurrencyFilter();
CurrencyFilter.Skip = 0;
CurrencyFilter.Take = 20;
CurrencyFilter.OrderBy = CurrencyOrder.Id;
CurrencyFilter.OrderType = OrderType.ASC;
CurrencyFilter.Selects = CurrencySelect.ALL;
CurrencyFilter.Id = Store_CurrencyFilterDTO.Id;
CurrencyFilter.Code = Store_CurrencyFilterDTO.Code;
CurrencyFilter.Name = Store_CurrencyFilterDTO.Name;
List <Currency> Currencies = await CurrencyService.List(CurrencyFilter);
List <Store_CurrencyDTO> Store_CurrencyDTOs = Currencies
.Select(x => new Store_CurrencyDTO(x)).ToList();
return(Store_CurrencyDTOs);
}
public void Get_Currencies_ArgumentExeption()
{
// arrage
var paging = new Paging();
var filter = new CurrencyFilter()
{
StartDate = new DateTime(2017, 4, 2), EndDate = new DateTime(2017, 4, 1)
};
// act & assert
Assert.ThrowsExceptionAsync <ArgumentException>(() => rateService.GetCurrenciesAsync(paging, filter));
}
public async Task <List <Currency> > List(CurrencyFilter CurrencyFilter)
{
try
{
List <Currency> Currencys = await UOW.CurrencyRepository.List(CurrencyFilter);
return(Currencys);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex, nameof(CurrencyService));
}
return(null);
}
public async Task <int> Count(CurrencyFilter CurrencyFilter)
{
try
{
int result = await UOW.CurrencyRepository.Count(CurrencyFilter);
return(result);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex, nameof(CurrencyService));
}
return(0);
}
public async Task <List <Currency> > List(CurrencyFilter filter)
{
if (filter == null)
{
return(new List <Currency>());
}
IQueryable <CurrencyDAO> CurrencyDAOs = DataContext.Currency.AsNoTracking();
CurrencyDAOs = DynamicFilter(CurrencyDAOs, filter);
CurrencyDAOs = DynamicOrder(CurrencyDAOs, filter);
List <Currency> Currencies = await DynamicSelect(CurrencyDAOs, filter);
return(Currencies);
}
public async Task <ProcessResult <int> > CountAsync(CurrencyFilter filter)
{
IQueryable <Currency> q = context.Currencies;
q = SetFilter(q, filter);
Func <Task <int> > action = async() =>
{
var countItems = await q.CountAsync();
return(countItems);
};
return(await Process.RunAsync(action));
}
private IQueryable <Currency> SetFilter(IQueryable <Currency> q, CurrencyFilter f)
{
if (f == null)
{
return(q);
}
if (!String.IsNullOrEmpty(f.searchString))
{
q = q.Where(s => (
s.Name.Contains(f.searchString) ||
s.Symbol.Contains(f.searchString)
));
}
return(q);
}
public async Task <IActionResult> Count(CurrencyFilter filter)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _CurrencyService.CountAsync(filter);
if (!result.Succeeded)
{
return(BadRequest(result.Errors));
}
return(Ok(result));
}
public virtual XElement GenerateQueryRq()
{
XElement xElement = new XElement(typeof(T).Name + "QueryRq");
xElement.Add(TxnID?.ToQBXML(nameof(TxnID)));
xElement.Add(RefNumber?.ToQBXML(nameof(RefNumber)));
xElement.Add(RefNumberCaseSensitive?.ToQBXML(nameof(RefNumberCaseSensitive)));
xElement.Add(MaxReturned?.ToQBXML(nameof(MaxReturned)));
xElement.Add(ModifiedDateRangeFilter?.ToQBXML(nameof(ModifiedDateRangeFilter)));
xElement.Add(TxnDateRangeFilter?.ToQBXML(nameof(TxnDateRangeFilter)));
xElement.Add(EntityFilter?.ToQBXML(nameof(EntityFilter)));
xElement.Add(AccountFilter?.ToQBXML(nameof(AccountFilter)));
xElement.Add(MatchFilter?.ToQBXML(nameof(MatchFilter)));
xElement.Add(MatchRangeFilter?.ToQBXML(nameof(MatchRangeFilter)));
xElement.Add(CurrencyFilter?.ToQBXML(nameof(CurrencyFilter)));
xElement.Add(OwnerID?.ToQBXML(nameof(OwnerID)));
return(xElement);
}
public async Task <bool> ValidateId(Currency Currency)
{
CurrencyFilter CurrencyFilter = new CurrencyFilter
{
Skip = 0,
Take = 10,
Id = new IdFilter {
Equal = Currency.Id
},
Selects = CurrencySelect.Id
};
int count = await UOW.CurrencyRepository.Count(CurrencyFilter);
if (count == 0)
{
Currency.AddError(nameof(CurrencyValidator), nameof(Currency.Id), ErrorCode.IdNotExisted);
}
return(count == 1);
}
public IEnumerable <Currency> GetCurrencies(Paging paging, CurrencyFilter filter)
{
if (filter != null && filter.StartDate != null && filter.EndDate != null && filter.StartDate > filter.EndDate)
{
throw new ArgumentException("Start date must be less than end date");
}
Func <IQueryable <Currency>, IQueryable <Currency> > query = q =>
{
if (filter?.Name != null)
{
q = q.Where(x => x.Name.Contains(filter.Name));
}
if (filter?.StartDate != null)
{
q = q.Where(x => x.DateCreate >= filter.StartDate);
}
if (filter?.EndDate != null)
{
q = q.Where(x => x.DateCreate <= filter.EndDate);
}
if (filter?.OrderBy != null)
{
q = q.OrderBy(x => x.PropValue <Currency>(filter.OrderBy));
}
if (paging?.Take > 0)
{
q = q.Skip(paging.Skip).Take(paging.Take);
}
return(q);
};
return(currencyRepository.Get(query));
}
public async Task <IActionResult> Get(Paging paging, CurrencyFilter filter)
{
try
{
var currencies = await rateService.GetCurrenciesAsync(paging, filter);
if (!currencies.Any())
{
return(StatusCode(204));
}
var result = mapper.Map <IEnumerable <Currency>, IEnumerable <CurrencyViewModel> >(currencies);
return(Ok(result));
}
// If start date > end date
catch (ArgumentException ex)
{
return(BadRequest(new ErrorResponse {
Message = ex.Message
}));
}
}
private async Task <List <Currency> > DynamicSelect(IQueryable <CurrencyDAO> query, CurrencyFilter filter)
{
List <Currency> Currencies = await query.Select(q => new Currency()
{
Id = filter.Selects.Contains(CurrencySelect.Id) ? q.Id : default(long),
Code = filter.Selects.Contains(CurrencySelect.Code) ? q.Code : default(string),
Name = filter.Selects.Contains(CurrencySelect.Name) ? q.Name : default(string),
}).ToListAsync();
return(Currencies);
}
private IQueryable <CurrencyDAO> DynamicFilter(IQueryable <CurrencyDAO> query, CurrencyFilter filter)
{
if (filter == null)
{
return(query.Where(q => false));
}
if (filter.Id != null && filter.Id.HasValue)
{
query = query.Where(q => q.Id, filter.Id);
}
if (filter.Code != null && filter.Code.HasValue)
{
query = query.Where(q => q.Code, filter.Code);
}
if (filter.Name != null && filter.Name.HasValue)
{
query = query.Where(q => q.Name, filter.Name);
}
query = OrFilter(query, filter);
return(query);
}
private IQueryable <CurrencyDAO> DynamicOrder(IQueryable <CurrencyDAO> query, CurrencyFilter filter)
{
switch (filter.OrderType)
{
case OrderType.ASC:
switch (filter.OrderBy)
{
case CurrencyOrder.Id:
query = query.OrderBy(q => q.Id);
break;
case CurrencyOrder.Code:
query = query.OrderBy(q => q.Code);
break;
case CurrencyOrder.Name:
query = query.OrderBy(q => q.Name);
break;
}
break;
case OrderType.DESC:
switch (filter.OrderBy)
{
case CurrencyOrder.Id:
query = query.OrderByDescending(q => q.Id);
break;
case CurrencyOrder.Code:
query = query.OrderByDescending(q => q.Code);
break;
case CurrencyOrder.Name:
query = query.OrderByDescending(q => q.Name);
break;
}
break;
}
query = query.Skip(filter.Skip).Take(filter.Take);
return(query);
}
static void GetCurrencies()
{
var currencies = new List <Currency>();
var paging = new Paging();
#region paging set
Console.WriteLine();
Console.ForegroundColor = ConsoleColor.Blue;
Console.Write("new ");
Console.ForegroundColor = ConsoleColor.DarkGreen;
Console.Write("Paging");
Console.WriteLine();
Console.ForegroundColor = ConsoleColor.White;
Console.Write("\tTake");
Console.ForegroundColor = ConsoleColor.Blue;
Console.Write(" int");
Console.ForegroundColor = ConsoleColor.White;
Console.Write(" = ");
try
{
paging.Take = int.Parse(Console.ReadLine());
}
catch { }
Console.ForegroundColor = ConsoleColor.White;
Console.Write("\tSkip");
Console.ForegroundColor = ConsoleColor.Blue;
Console.Write(" int");
Console.ForegroundColor = ConsoleColor.White;
Console.Write(" = ");
try
{
paging.Skip = int.Parse(Console.ReadLine());
}
catch { }
#endregion
var filter = new CurrencyFilter();
#region filter set
Console.WriteLine();
Console.ForegroundColor = ConsoleColor.Blue;
Console.Write("new ");
Console.ForegroundColor = ConsoleColor.DarkGreen;
Console.Write("CurrencyFilter");
Console.WriteLine();
Console.ForegroundColor = ConsoleColor.White;
Console.Write("\tName");
Console.ForegroundColor = ConsoleColor.Blue;
Console.Write(" string(nullable)");
Console.ForegroundColor = ConsoleColor.White;
Console.Write(" = ");
try
{
var name = Console.ReadLine();
if (!string.IsNullOrEmpty(name))
{
filter.Name = name;
}
}
catch { }
Console.ForegroundColor = ConsoleColor.White;
Console.Write("\tOrderBy");
Console.ForegroundColor = ConsoleColor.Blue;
Console.Write(" string(nullable)");
Console.ForegroundColor = ConsoleColor.White;
Console.Write(" = ");
try
{
var orderBy = Console.ReadLine();
if (!string.IsNullOrEmpty(orderBy))
{
filter.OrderBy = orderBy;
}
}
catch { }
Console.ForegroundColor = ConsoleColor.White;
Console.Write("\tStartDate");
Console.ForegroundColor = ConsoleColor.Blue;
Console.Write(" DateTime(nullable)");
Console.ForegroundColor = ConsoleColor.DarkRed;
Console.Write(" format:yyyy-MM-dd");
Console.ForegroundColor = ConsoleColor.White;
Console.Write(" = ");
try
{
filter.StartDate = DateTime.Parse(Console.ReadLine());
}
catch { }
Console.ForegroundColor = ConsoleColor.White;
Console.Write("\tEndDate");
Console.ForegroundColor = ConsoleColor.Blue;
Console.Write(" DateTime(nullable)");
Console.ForegroundColor = ConsoleColor.DarkRed;
Console.Write(" format:yyyy-MM-dd");
Console.ForegroundColor = ConsoleColor.White;
Console.Write(" = ");
try
{
filter.EndDate = DateTime.Parse(Console.ReadLine());
}
catch { }
#endregion
using (var client = new RateServiceClient())
{
Task.Run(async() =>
{
var result = await client.GetCurrenciesAsync(paging, filter);
currencies = result.ToList();
}).GetAwaiter().GetResult();
}
foreach (var item in currencies)
{
Console.WriteLine("Currency name: {0}\t| Selling price: {1}\t| Purchase price: {2}\t| Date: {3}", item.Name, item.SellingPrice, item.PurchasePrice, item.DateCreate);
}
}
public void Get_Currencies()
{
// arrage
var paging = new Paging();
var filter = new CurrencyFilter {
StartDate = new DateTime(2016, 1, 1), EndDate = new DateTime(2016, 4, 2)
};
var currencies = new[] {
new Currency {
Id = 1, Name = "EUR", PurchasePrice = 10, SellingPrice = 11, DateCreate = new DateTime(2015, 1, 1)
},
new Currency {
Id = 2, Name = "USD", PurchasePrice = 9, SellingPrice = 10, DateCreate = new DateTime(2016, 2, 1)
},
new Currency {
Id = 3, Name = "USD", PurchasePrice = 9.1m, SellingPrice = 10.2m, DateCreate = new DateTime(2016, 3, 1)
},
new Currency {
Id = 4, Name = "EUR", PurchasePrice = 10.3m, SellingPrice = 11.6m, DateCreate = new DateTime(2016, 4, 1)
},
new Currency {
Id = 5, Name = "EUR", PurchasePrice = 9.9m, SellingPrice = 10.9m, DateCreate = new DateTime(2016, 5, 1)
}
}.AsQueryable();
Func <IQueryable <Currency>, IQueryable <Currency> > query = q =>
{
if (filter?.Name != null)
{
q = q.Where(x => x.Name.Contains(filter.Name));
}
if (filter?.StartDate != null)
{
q = q.Where(x => x.DateCreate >= filter.StartDate);
}
if (filter?.EndDate != null)
{
q = q.Where(x => x.DateCreate <= filter.EndDate);
}
if (filter?.OrderBy != null)
{
q = q.OrderBy(x => x.PropValue <Currency>(filter.OrderBy));
}
q = q.Skip(paging.Skip).Take(paging.Take);
return(q);
};
var resultCurrencies = query(currencies).ToList();
currencyRepository.Setup(x => x.GetAsync(It.IsAny <Func <IQueryable <Currency>, IQueryable <Currency> > >()))
.ReturnsAsync(resultCurrencies);
// act
var taskResult = rateService.GetCurrenciesAsync(paging, filter);
// assert
Assert.IsTrue(taskResult.IsCompleted);
var model = taskResult.Result;
Assert.IsInstanceOfType(model, typeof(IEnumerable <Currency>));
Assert.AreEqual(resultCurrencies.Count(), model.Count());
}
