public ModelStateDictionary ValidatePositionFilterModel(PositionFilterDomainModel filterModel)
{
var errors = new ModelStateDictionary();
if (filterModel.Page < 1)
{
errors.AddModelError("Page", "The page number cannot be less than one.");
}
if (filterModel.PageSize < 1)
{
errors.AddModelError("PageSize", "The page size cannot be less than one.");
}
if (filterModel.PositionType.HasValue)
{
char inputPositionType = filterModel.PositionType.Value;
var validPositionTypes = new char[] { 'L', 'S' };
if (!validPositionTypes.Contains(inputPositionType))
{
errors.AddModelError("PositionType", "The transaction type must be a valid type: L - Long, S - Short.");
}
}
if (!string.IsNullOrEmpty(filterModel.OrderByField))
{
string inputOrderByField = filterModel.OrderByField;
var validOrderByFields = new string[]
{
"Symbol",
"Quantity"
};
if (!validOrderByFields.Select(x => x.ToLower())
.Contains(inputOrderByField.ToLower()))
{
errors.AddModelError("OrderByField", $"The order by field must be a valid field: {string.Join(", ", validOrderByFields)}.");
}
}
if (filterModel.OrderByDirection.HasValue)
{
char inputOrderByDirection = filterModel.OrderByDirection.Value;
var validOrderByDirections = new char[] { 'A', 'D' };
if (!validOrderByDirections.Contains(inputOrderByDirection))
{
errors.AddModelError("OrderByDirection", "The order by direction must be a valid direction: A - Ascending, D - Descending.");
}
}
return(errors);
}
public void ItWillInvalidatePositionFilterModel()
{
var filterModel = new PositionFilterDomainModel
{
Page = -1,
PageSize = -25,
PositionType = '0',
OrderByField = "FakeField",
OrderByDirection = '0'
};
using (var mock = AutoMock.GetLoose())
{
var service = mock.Create <PositionService>();
var result = service.ValidatePositionFilterModel(filterModel);
Assert.NotNull(result);
Assert.Equal(5, result.Count());
Assert.False(result.IsValid);
}
}
public void ItWillValidatePositionFilterModel()
{
var filterModel = new PositionFilterDomainModel
{
Page = 1,
PageSize = 25,
PositionType = 'L',
OrderByField = "Symbol",
OrderByDirection = 'A'
};
using (var mock = AutoMock.GetLoose())
{
var service = mock.Create <PositionService>();
var result = service.ValidatePositionFilterModel(filterModel);
Assert.NotNull(result);
Assert.Empty(result);
Assert.True(result.IsValid);
}
}
public async Task <PaginatedResult <PositionDomainModel> > GetFilteredAsync(PositionFilterDomainModel filterModel, string accessKey)
{
var filterEntityModel = _mapper.Map <PositionFilterEntityModel>(filterModel);
filterEntityModel.AccessKey = accessKey;
var parameters = CreateParametersForGetFilteredAsync(filterEntityModel);
using var connection = _connectionFactory.NewConnection();
await connection.OpenAsync();
var reader = await connection.QueryMultipleAsync(
"StoGetFilteredPositions",
parameters,
commandType : CommandType.StoredProcedure);
IEnumerable <PositionEntityModel> positions = reader.Read <PositionEntityModel>().ToList();
var totalRecordCount = reader.Read <int>().SingleOrDefault();
return(new PaginatedResult <PositionDomainModel>(
results: _mapper.Map <IEnumerable <PositionDomainModel> >(positions),
metadata: CreatePaginationMetadata(filterEntityModel, totalRecordCount)));
}
public async Task <PaginatedResult <PositionDomainModel> > GetFilteredPositions(PositionFilterDomainModel filterModel, string accessKey)
{
return(await _positionsRepository.GetFilteredAsync(filterModel, accessKey));
}
