public async Task <IActionResult> Post([FromBody] Orders body)
{
await Db.Connection.OpenAsync();
body.Db = Db;
var itemQuery = new ItemsQuery(Db);
for (int i = 0; i < body.OrdersD.Count; i++)
{
var itemId = body.OrdersD[i].IdItem;
var findItemID = itemQuery.FindOneAsync(itemId);
if (findItemID.Result == null)
{
FoundExceptions.NotFoundException(itemId);
}
}
var orderId = await body.InsertOrdersAsync();
await body.InsertOrderDetailAsync(body);
var orderQuery = new OrdersQuery(Db);
var result = await orderQuery.FindOneAsync(orderId);
return(new OkObjectResult(result[0]));
}
public async Task <QueryResult <Item> > GetFiltrated(ItemsQuery query)
{
var columnsMap = new Dictionary <string, Expression <Func <Item, object> > >()
{
["name"] = i => i.Name,
["price"] = i => i.Price,
["subcategory"] = i => i.SubcategoryId
};
var items = _context.Items
.Include(i => i.Subcategory)
.ThenInclude(s => s.Category)
.AsQueryable();
if (query.CategoryId.HasValue)
{
items = items.Where(i => i.Subcategory.CategoryId == query.CategoryId)
.AsQueryable();
}
var count = await items.CountAsync();
items = items.NullableOrderBy(columnsMap, query)
.ApplingPagination(query);
QueryResult <Item> result = new QueryResult <Item>()
{
Entities = await items.ToListAsync(),
Count = count
};
return(result);
}
public async Task <ActionResult> Get()
{
await Db.Connection.OpenAsync();
var query = new ItemsQuery(Db);
var result = await query.GetAllAsync();
return(new OkObjectResult(result));
}
//[Authorize(Roles = "admin")]
public async Task <IActionResult> Items([FromQuery] ItemsQuery itemsQuery)
{
FitemQueryOne fitemQueryOne = new FitemQueryOne();
fitemQueryOne.cItemClass = itemsQuery.cItemClass;
var fitem = _mediator.Send(fitemQueryOne);
if (fitem.Result == null)
{
return(NotFound());
}
return(Ok(await _mediator.Send(itemsQuery)));
}
public async Task <ActionResult> Get(int id)
{
await Db.Connection.OpenAsync();
var query = new ItemsQuery(Db);
var result = await query.FindOneAsync(id);
if (result is null)
{
return(new NotFoundResult());
}
return(new OkObjectResult(result));
}
public static IQueryable <T> ApplingPagination <T>(this IQueryable <T> data, ItemsQuery query)
{
if (query.Page <= 0)
{
query.Page = 1;
}
if (query.PageSize <= 0)
{
query.PageSize = 10;
}
return(data
.Skip((query.Page - 1) * query.PageSize)
.Take(query.PageSize));
}
public async Task <IActionResult> Put(int id, [FromBody] Items body)
{
await Db.Connection.OpenAsync();
var query = new ItemsQuery(Db);
var result = await query.FindOneAsync(id);
if (result is null)
{
return(new NotFoundResult());
}
result.Name = body.Name;
result.Description = body.Description;
await result.UpdateAsync();
return(new OkObjectResult(result));
}
private static async Task <List <Item> > GetItems(
IReadOnlyCollection <int> itemIds,
ItemsQuery itemsQuery,
ProgressTask progress
)
{
var items = new List <Item>(itemIds.Count);
progress.StartTask();
await foreach (var item in itemsQuery.GetItemsByIds(
itemIds,
progress: new Progress <ICollectionContext>(ctx => UpdateProgress(ctx, progress))
))
{
items.Add(item);
}
progress.StopTask();
return(items);
}
} // END GetCurrentItemsAsync
public async Task <IEnumerable <Item> > GetItemsAsync(HomeUser user, ItemsQuery query)
{
var qb = new StringBuilder(queryRepo.Get("ItemsHistoryQuery"));
var parms = new Dapper.DynamicParameters();
parms.Add("@HomeId", user.HomeId);
qb.Append("home_id = @HomeId");
if (!String.IsNullOrEmpty(query.Name))
{
parms.Add("@Name", query.Name);
qb.Append("AND name = @Name");
}
if (query.CreatedDate1.HasValue)
{
parms.Add("@CreatedDate1", query.CreatedDate1.Value);
qb.Append("AND created_at >= @CreatedDate1");
}
if (query.CreatedDate2.HasValue)
{
parms.Add("@CreatedDate2", query.CreatedDate2.Value);
qb.Append("AND created_at <= @CreatedDate2");
}
if (query.PurchasedDate1.HasValue)
{
parms.Add("@PurchasedDate1", query.PurchasedDate1.Value);
qb.Append("AND purchased_at >= @PurchasedDate1");
}
if (query.PurchasedDate2.HasValue)
{
parms.Add("@PurchasedDate2", query.PurchasedDate2.Value);
qb.Append("AND purchased_at <= @PurchasedDate2");
}
using (var conn = factory.Create(archive))
{
await conn.OpenAsync();
return(await conn.QueryAsync <PurchasedItem>(
qb.ToString(), parms));
}
} // END GetItemsAsync
public static IQueryable <T> NullableOrderBy <T>(this IQueryable <T> data, Dictionary <string, Expression <Func <T, object> > > columnsMap, ItemsQuery query)
{
if (String.IsNullOrWhiteSpace(query.SortBy) || !columnsMap.ContainsKey(query.SortBy))
{
return(data);
}
if (query.IfAscending)
{
return(data.OrderBy(columnsMap[query.SortBy]));
}
return(data.OrderByDescending(columnsMap[query.SortBy]));
}
