private IQueryable <Owner> PagingRequired(IQueryable <Owner> query, OwnerQuery queryObject)
{
if (queryObject.Page != 0 || queryObject.PageSize != 0)
{
return(query.ApplyPaging(queryObject));
}
return(query);
}
public async Task <IActionResult> GetLatest()
{
await Db.Connection.OpenAsync();
var query = new OwnerQuery(Db);
var result = await query.GetAll();
return(new OkObjectResult(result));
}
public async Task <IActionResult> GetOne(int id)
{
await Db.Connection.OpenAsync();
var query = new OwnerQuery(Db);
var result = await query.GetOne(id);
if (result is null)
{
return(new NotFoundResult());
}
return(new OkObjectResult(result));
}
private IQueryable <Owner> SortByRequired(IQueryable <Owner> query, OwnerQuery queryObject)
{
if (!String.IsNullOrWhiteSpace(queryObject.SortBy))
{
var columnsMap = new Dictionary <string, Expression <Func <Owner, object> > >()
{
["name"] = tenant => tenant.Name,
["email"] = tenant => tenant.Email
};
return(query.ApplyOrdering(queryObject, columnsMap));
}
return(query);
}
public async Task <IActionResult> PutOne(int id, [FromBody] Owner body)
{
await Db.Connection.OpenAsync();
var query = new OwnerQuery(Db);
var result = await query.GetOne(id);
if (result is null)
{
return(new NotFoundResult());
}
result.firstName = body.firstName;
result.lastName = body.lastName;
await result.UpdateOne();
return(new OkObjectResult(result));
}
public async Task <QueryResult <Owner> > GetOwners(OwnerQuery queryObject = null)
{
var queryResult = new QueryResult <Owner>();
var query = context.Owners.AsQueryable();
queryResult.TotalItems = await query.CountAsync();
if (queryObject != null)
{
query = this.SortByRequired(query, queryObject);
queryResult.TotalItems = await query.CountAsync();
query = this.PagingRequired(query, queryObject);
}
queryResult.Items = await query.ToListAsync();
return(queryResult);
}
public async Task Save()
{
try
{
var result = await Client.ExecuteActionAsync("PersistentObject.Save", this).ConfigureAwait(false);
if (result == null)
{
return;
}
await RefreshFromResult(result).ConfigureAwait(false);
if (string.IsNullOrWhiteSpace(Notification) || NotificationType != NotificationType.Error)
{
IsDirty = false;
IsInEdit = StateBehavior.HasFlag(StateBehavior.StayInEdit);
if (OwnerAttributeWithReference != null)
{
if (OwnerAttributeWithReference.ObjectId != ObjectId)
{
OwnerAttributeWithReference.Parent.Edit();
var fakeSelectedItem = new JObject(new JProperty("id", ObjectId), new JProperty("values", new JArray()));
await OwnerAttributeWithReference.ChangeReference(new QueryResultItem(fakeSelectedItem, OwnerAttributeWithReference.Lookup)).ConfigureAwait(false);
}
}
else if (OwnerQuery != null)
{
await OwnerQuery.RefreshQueryAsync().ConfigureAwait(false);
if (OwnerQuery.SemanticZoomOwner != null)
{
await OwnerQuery.SemanticZoomOwner.RefreshQueryAsync().ConfigureAwait(false);
}
}
}
}
catch (Exception ex)
{
SetNotification(ex.Message);
}
}
public String WorkOrderGridQuery()
{
var owner = GetOwnerFromUser();
return(OwnerQuery.Fmt("workorder", owner));
}
public String SrGridQuery()
{
var owner = GetOwnerFromUser();
return(OwnerQuery.Fmt("SR", owner));
}
public async Task <QueryResult <IDictionary <string, object> > > QueryOwnerDynamic(
OwnerQueryProjection projection,
OwnerQueryOptions options,
OwnerQueryFilter filter = null,
OwnerQuerySort sort = null,
OwnerQueryPaging paging = null)
{
var conn = context.Database.GetDbConnection();
var openConn = conn.OpenAsync();
var query = OwnerQuery.CreateDynamicSql();
#region General
if (filter != null)
{
query = query.SqlFilter(filter);
}
query = query.SqlJoin(projection);
DynamicSql countQuery = null; int?totalCount = null; Task <int> countTask = null;
if (options.count_total)
{
countQuery = query.SqlCount("*");
}
query = query.SqlProjectFields(projection);
#endregion
await openConn;
if (!options.single_only)
{
#region List query
if (sort != null)
{
query = query.SqlSort(sort);
}
if (paging != null && (!options.load_all || !OwnerQueryOptions.IsLoadAllAllowed))
{
query = query.SqlSelectPage(paging.page, paging.limit);
}
#endregion
#region Count query
if (options.count_total)
{
countTask = conn.ExecuteScalarAsync <int>(
sql: countQuery.PreparedForm,
param: countQuery.DynamicParameters);
}
#endregion
}
var queryResult = await conn.QueryAsync(
sql : query.PreparedForm,
types : query.GetTypesArr(),
map : (objs) => ProcessMultiResults(query, objs),
splitOn : string.Join(',', query.GetSplitOns()),
param : query.DynamicParameters);
if (options.single_only)
{
var single = queryResult.FirstOrDefault();
if (single == null)
{
return(null);
}
var singleResult = GetOwnerDynamic(single, projection, options);
return(new QueryResult <IDictionary <string, object> >()
{
SingleResult = singleResult
});
}
if (options.count_total)
{
totalCount = await countTask;
}
var result = GetOwnerDynamic(queryResult, projection, options, totalCount);
return(result);
}
