public async Task <CollectionResult <BookDto> > SearchBooks(BookSearchDto model)
{
var result = new CollectionResult <BookDto>();
var entities = _bookRepository
.Get()
.WhereIf(model.Genre != null, item => item.Genre == model.Genre)
.WhereIf(model.Condition != null, item => item.Condition == model.Condition)
.WhereIf(!string.IsNullOrEmpty(model.SearchString),
x => x.Name.ToLower().Contains(model.SearchString.ToLower()) ||
x.Author.ToLower().Contains(model.SearchString.ToLower()))
.AsQueryable();
var searchResult = await entities.ToListAsyncSafe();
if (searchResult != null)
{
result.Items = _mapper.Map <List <Book>, List <BookDto> >(searchResult);
result.IsSuccessful = true;
}
return(result);
}
public HttpResponseMessage RuletaApuestaInsertar(PostRuletaApuestaParameters data)
{
if (data.UsuarioCreditos <= 0 && data.Cantidad <= 10000)
{
CollectionResult <CRUD_RuletaApuesta_Result> service = CallService <CRUD_RuletaApuesta_Result>("RuletaApuesta/RuletaApuestaInsertar", data, delegate()
{
return(db.CRUD_RuletaApuesta(data.CodigoApuesta, data.NumeroID, data.ColorID, data.Cantidad, data.UsuarioID));
});
if (service.result == ServiceResult.Success)
{
return(Request.CreateResponse(HttpStatusCode.OK, service));
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, service.stackError));
}
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, service.stackError));
}
}
public void Handle_ValidInput_OrderedResultsByFirstName()
{
// Arrange
PeopleQuery request = new PeopleQuery {
OrderBy = "FirstName"
};
PersonViewModel person = new PersonViewModel {
FirstName = "f1", Surname = "s1", Score = 0
};
PersonViewModel person2 = new PersonViewModel {
FirstName = "f2", Surname = "s2", Score = 76
};
PersonViewModel person3 = new PersonViewModel {
FirstName = "f3", Surname = "s3", Score = 23
};
PersonViewModel person4 = new PersonViewModel {
FirstName = "f4", Surname = "s4", Score = 1
};
var result = new CollectionResult <PersonViewModel>();
result.IsSuccessful = true;
result.SetResults((new List <PersonViewModel> {
person, person2, person3, person4
}).OrderBy(x => x.FirstName));
service.Setup(x => x.GetAll(new string[] { request.OrderBy })).ReturnsAsync(result);
// Act
handler.Handle(request);
// Assert
Assert.IsTrue(request.Result.IsSuccessful);
IEnumerable <PersonViewModel> results = request.Result.GetResults();
Assert.AreEqual(4, results.ToList().Count());
Assert.AreEqual(new string[] { "f1", "f2", "f3", "f4" }, results.Select(x => x.FirstName));
service.VerifyAll();
}
protected Collection FindCollection(string CollectionName)
{
CollectionResult response = null;
response = CallClient(() => Client.Collections.Get(CollectionName), Client.Collections);
if (response != null)
{
if (response.Collection == null)
{
ErrorRecord er = RemoteAppCollectionErrorState.CreateErrorRecordFromString(
String.Format("Collection {0} does not exist",
CollectionName),
String.Empty,
Client.Collections,
ErrorCategory.ObjectNotFound
);
WriteError(er);
}
}
return(response.Collection);
}
public async Task <CollectionResult <RobotType> > GetTypesByFilterParamsAsync(RobotTypeFilterParams filterParams, CancellationToken ct = default)
{
IQueryable <RobotType> query = DbContext.RobotTypes.AsQueryable();
FillFilterExpression(filterParams);
query = query.Where(filterParams.Expression);
int totalCount = query.Count();
List <RobotType> items = await query
.OrderBy(x => x.Name)
.WithPagination(filterParams.Skip, filterParams.Take)
.AsNoTracking()
.ToListAsync(ct);
CollectionResult <RobotType> result = new CollectionResult <RobotType>
{
Collection = items,
TotalCount = totalCount
};
return(result);
}
public CollectionResult <User> GetCustomers(UsersFilterParams filterParams)
{
var users = GetAllUsers();
FillUsersQueryParams(filterParams);
users = users.Where(filterParams.Expression);
var totalCount = users.Count();
var result = users
.Skip(filterParams.Skip)
.Take(filterParams.Take)
.AsNoTracking()
.ToList();
var userResult = new CollectionResult <User>
{
Collection = result,
TotalCount = totalCount
};
return(userResult);
}
public CollectionResult <Rent> GetRentsByParams(RentsFilterParams filterParams)
{
var rents = GetAllRents();
FillRentQueryParams(filterParams);
rents = rents.Where(filterParams.Expression);
var totalCount = rents.Count();
var result = filterParams.IsCalendarView ? rents.ToList() : rents
.Skip(filterParams.Skip)
.Take(filterParams.Take)
.AsNoTracking()
.ToList();
var rentResult = new CollectionResult <Rent>
{
Collection = result,
TotalCount = totalCount
};
return(rentResult);
}
public async Task <CollectionResult <NewsShortModel> > GetNews(int page = 1, int count = 10)
{
if (page <= 0)
{
throw new ArgumentOutOfRangeException(nameof(page));
}
if (count < 0)
{
throw new ArgumentOutOfRangeException(nameof(count));
}
CollectionResult <News> result = await _newsDataSource.FindAsync((page - 1) *count, count);
return(new CollectionResult <NewsShortModel>(result.TotalCount, result.Data.Select(convert)));
NewsShortModel convert(News news) => new NewsShortModel
{
Id = news.Id,
Title = news.Title,
Description = news.Description,
PublicationDate = news.PublicationDate,
ImageId = news.ImagesIds?.FirstOrDefault()
};
}
public CollectionResult <Facility> GetFacilitiesByParams(FacilitiesFilterParams filterParams)
{
var facilities = GetAllFacilities();
FillFacilitiesQueryParams(filterParams);
facilities = facilities.Where(filterParams.Expression);
var totalCount = facilities.Count();
var result = facilities
.Skip(filterParams.Skip)
.Take(filterParams.Take)
.AsNoTracking()
.ToList();
var airTaxiResult = new CollectionResult <Facility>
{
Collection = result,
TotalCount = totalCount
};
return(airTaxiResult);
}
protected Collection FindCollection(string CollectionName)
{
CollectionResult response = null;
response = CallClient(() => Client.Collections.Get(CollectionName), Client.Collections);
if (response != null)
{
if (response.Collection == null)
{
ErrorRecord er = RemoteAppCollectionErrorState.CreateErrorRecordFromString(
String.Format("Collection {0} does not exist",
CollectionName),
String.Empty,
Client.Principals,
ErrorCategory.ObjectNotFound
);
WriteError(er);
}
else if (!String.Equals(response.Collection.Status, "Active", StringComparison.OrdinalIgnoreCase))
{
ErrorRecord er = RemoteAppCollectionErrorState.CreateErrorRecordFromString(
String.Format("Collection {0} is not in the Active state",
response.Collection.Name),
String.Empty,
Client.Principals,
ErrorCategory.InvalidOperation
);
WriteError(er);
}
}
return(response.Collection);
}
public CollectionResult <AirTaxi> GetAirTaxiesByParams(TaxiesFilterParams filterParams)
{
var airTaxies = GetAllAirTaxies();
FillAirTaxiQueryParams(filterParams);
airTaxies = airTaxies.Where(filterParams.Expression);
var totalCount = airTaxies.Count();
var result = airTaxies
.Skip(filterParams.Skip)
.Take(filterParams.Take)
.AsNoTracking()
.ToList();
var airTaxiResult = new CollectionResult <AirTaxi>
{
Collection = result,
TotalCount = totalCount
};
return(airTaxiResult);
}
public IActionResult GetItemsUsingStoredProcedures([FromQuery] FilterParams filterParams)
{
CollectionResult <GameModel> items = _gameRepository.GetGamesUsingStoredProcedure(filterParams);
return(Ok(items));
}
public async Task <IActionResult> GetItemsAsync([FromQuery] FilterParams filterParams)
{
CollectionResult <Game> items = await _gameRepository.GetGamesAsync(filterParams);
return(Ok(_mapper.Map <CollectionResult <GetGameDto> >(items)));
}
public IActionResult CollectionRequest([FromBody]CollectionResult collectionResult) {
if (collectionResult == null) throw new ArgumentNullException("collectionResult");
processor.Process(collectionResult);
return new OkResult();
}
private SelectList GetWageSchemas( CollectionResult<WageSchema> result)
{
return null;
{
}
}
public abstract void Save(CollectionResult result);
