public static object CreateAnonymous(this DbDataReader reader, Type type, QueryMap queryMap)
{
var ctor = type.GetConstructors()[0];
var pp = ctor.GetParameters();
var args = new object[pp.Length];
QueryMap map2 = null;
for (var i = 0; i < args.Length; i++)
{
var name = pp[i].Name;
var map = queryMap.FirstOrDefault(_ => _.MemberPath.Sections[0] == name);
if (map.MemberPath.Length == 1)
{
args[i] = reader[map.ColumnAlias];
}
else
{
if (map2 == null)
{
map2 = queryMap.LeftShift(1);
}
args[i] = Create(reader, pp[i].ParameterType, map2);
}
}
return ctor.Invoke(args.ToArray());
}
/// <summary>
/// Adds the given query (new format) to the list of queries to be
/// evaluated.
/// </summary>
/// <param name="id">
/// The unique id of the query
/// </param>
/// <param name="query">
/// The query function to be evaluated
/// </param>
public void AddQuery(string id, Query query)
{
if (QueryMap.ContainsKey(id))
{
throw new Exception("A query with id '" + id + "' already exists");
}
QueryMap.Add(id, query);
}
public static object Create(this DbDataReader reader, Type type, QueryMap queryMap)
{
var result =
type.IsSimple()
? reader[0]
: type.IsAnonymousType()
? CreateAnonymous(reader, type, queryMap)
: CreateNotAnonymous(reader, type, queryMap);
return result;
}
public static object CreateNotAnonymous(this DbDataReader reader, Type type, QueryMap queryMap)
{
var result = Activator.CreateInstance(type);
foreach (var pi in type.GetProperties())
{
pi.SetValue(result, reader[pi.Name]);
}
return result;
}
public void ValueQuery(string name, double value, bool OverWriteIfExistent = false)
{
Query query = (app, t) => value;
if (QueryMap.ContainsKey(name))
{
if (!OverWriteIfExistent)
{
throw new Exception("A query with id '" + name + "' already exists");
}
else
{
QueryMap[name] = query;
}
}
else
{
QueryMap.Add(name, query);
}
}
// Utils
public static Task <List <T> > Find <T>(DbContext entityManager, Type resultClass, QueryMap fields, String[] orderBy, int?startPosition, int?maxResult) where T : class
{
return(Task.Run <List <T> >(() => {
var query = DbUtils.BuildQuery <T>(entityManager, resultClass, fields, orderBy);
if (startPosition != null)
{
// query.setFirstResult(startPosition);
}
if (maxResult != null)
{
// query.setMaxResults(maxResult);
}
return query.ToListAsync().ContinueWith(taskResult => taskResult.Result);
}));
}
public QueryMap GetForSelect()
{
var result = new QueryMap();
result.AddRange(KeyMap.Concat(ValueMap));
return result;
}
public GroupMap(QueryMap keysMap, QueryMap valuesMap)
{
KeyMap = keysMap.RightShift("Key");
ValueMap = valuesMap;
AddRange(KeyMap);
}
public Task <ActionResult> Remove()
{
Console.WriteLine("Dedicated implement of route {0}", this.RouteData.ToString());
// TODO : validar se entity.getState() é um State de status iniciais que permite exclusão.
String serviceName = "request";
return(RequestFilter.GetObject <AspNetCoreWebApi.Entity.Request>(this.User.Identity, this.Request, this.entityManager, serviceName).ContinueWith <ActionResult>(taskOldObj => {
var obj = taskOldObj.Result;
return RequestFilter.ProcessDelete <AspNetCoreWebApi.Entity.Request> (this.User.Identity, this.Request, this.entityManager, serviceName).ContinueWith <ActionResult> (taskResponse => {
ActionResult response = taskResponse.Result;
if (response is OkResult)
{
RequestState stateOld = RequestProductEndpoint.GetRequestState(this.entityManager, obj.State);
RequestState state = RequestProductEndpoint.GetRequestState(this.entityManager, obj.State);
List <RequestProduct> list = DbUtils.Find <RequestProduct> (this.entityManager, null, QueryMap.Create().AddNext("crudGroupOwner", obj.CrudGroupOwner).AddNext("request", obj.Id), null, null, null).Result;
foreach (RequestProduct requestProduct in list)
{
}
}
return response;
}).Result;
}));
}
public QueryMapWithLambdaParam(QueryMap queryMap, ParameterExpression lambdaParam)
{
this.lambdaParam = lambdaParam;
this.queryMap = queryMap;
}
private void Inspect(LambdaExpression keysExpression, LambdaExpression lambdaExpression)
{
keyMap = MapTransformer.Transform(keysExpression, queryBlock.QueryMap);
var queryMap = MapTransformer.Transform(lambdaExpression, queryBlock.QueryMap);
queryBlock.QueryMap = new GroupMap(keyMap, queryMap);
}
public ExprOp ParseQueryExpr(QueryLexerTokenKind tokContext, bool subExpression = false)
{
ExprOp limiter = null;
ExprOp next;
while ((next = ParseOrExpr(tokContext)) != null)
{
if (limiter == null)
{
limiter = next;
}
else
{
ExprOp prev = limiter;
limiter = new ExprOp(OpKindEnum.O_OR);
limiter.Left = prev;
limiter.Right = next;
}
}
if (!subExpression)
{
if (limiter != null)
{
QueryMap.Add(QueryKindEnum.QUERY_LIMIT, new Predicate(limiter, WhatToKeep).PrintToStr());
}
QueryLexerToken tok = Lexer.PeekToken(tokContext);
while (tok.Kind != QueryLexerTokenKind.END_REACHED)
{
switch (tok.Kind)
{
case QueryLexerTokenKind.TOK_SHOW:
case QueryLexerTokenKind.TOK_ONLY:
case QueryLexerTokenKind.TOK_BOLD:
{
Lexer.NextToken(tokContext);
QueryKindEnum kind;
switch (tok.Kind)
{
case QueryLexerTokenKind.TOK_SHOW:
kind = QueryKindEnum.QUERY_SHOW;
break;
case QueryLexerTokenKind.TOK_ONLY:
kind = QueryKindEnum.QUERY_ONLY;
break;
case QueryLexerTokenKind.TOK_BOLD:
kind = QueryKindEnum.QUERY_BOLD;
break;
default:
throw new InvalidOperationException("To avoid using unassigned QueryKindEnum kind...");
}
ExprOp node = next = null;
while ((next = ParseOrExpr(tokContext)) != null)
{
if (node == null)
{
node = next;
}
else
{
ExprOp prev = node;
node = new ExprOp(OpKindEnum.O_OR);
node.Left = prev;
node.Right = next;
}
}
if (node != null)
{
QueryMap.Add(kind, new Predicate(node, WhatToKeep).PrintToStr());
}
break;
}
case QueryLexerTokenKind.TOK_FOR:
case QueryLexerTokenKind.TOK_SINCE:
case QueryLexerTokenKind.TOK_UNTIL:
{
tok = Lexer.NextToken(tokContext);
string forString = string.Empty;
if (tok.Kind == QueryLexerTokenKind.TOK_SINCE)
{
forString = "since";
}
else if (tok.Kind == QueryLexerTokenKind.TOK_UNTIL)
{
forString = "until";
}
Lexer.ConsumeNextArg = true;
tok = Lexer.PeekToken(tokContext);
while (tok.Kind != QueryLexerTokenKind.END_REACHED)
{
tok = Lexer.NextToken(tokContext);
if (tok.Kind != QueryLexerTokenKind.TERM)
{
throw new InvalidOperationException();
}
if (tok.Value == "show" || tok.Value == "bold" || tok.Value == "for" || tok.Value == "since" || tok.Value == "until")
{
Lexer.SetPrev();
Lexer.ConsumeNextArg = false;
break;
}
if (!String.IsNullOrEmpty(forString))
{
forString += " ";
}
forString += tok.Value;
Lexer.ConsumeNextArg = true;
tok = Lexer.PeekToken(tokContext);
}
if (!String.IsNullOrEmpty(forString))
{
QueryMap.Add(QueryKindEnum.QUERY_FOR, forString);
}
break;
}
default:
goto done;
}
tok = Lexer.PeekToken(tokContext);
}
done :;
}
return(limiter);
}
public QueryMap Transform(Expression expression)
{
var result = new QueryMap();
TransformInternal(result, expression);
return result;
}
public static QueryMap Transform(LambdaExpression lambda, QueryMap fromMap)
{
var p = new QueryMapWithLambdaParam(fromMap, lambda.Parameters[0]);
return new MapTransformer(p).Transform(lambda.Body);
}
private void TransformInternal(QueryMap result, Expression expression)
{
switch (expression.NodeType)
{
case ExpressionType.New:
result.AddRange(ComputeColumnMaps((NewExpression)expression));
break;
default:
result.AddRange(ComputeColumnMaps(expression));
break;
}
}
// Utils
public static Task <T> FindOne <T> (DbContext entityManager, Type resultClass, QueryMap fields) where T : class
{
return(BuildQuery <T> (entityManager, resultClass, fields, null).SingleAsync());
}
// Utils
static IQueryable <T> BuildQuery <T> (DbContext entityManager, Type resultClass, QueryMap fields, String [] orderBy) where T : class
{
String className;
if (resultClass != null)
{
className = resultClass.Name;
}
else
{
className = typeof(T).Name;
}
StringBuilder sql = new StringBuilder(1024);
sql.Append("SELECT * FROM " + CaseConvert.CamelToUnderscore(className) + " o");
List <DbParameter> parameters = new List <DbParameter> (256);
if (fields.Count > 0)
{
sql.Append(" WHERE ");
foreach (var item in fields)
{
if ((item.Value is IList) || (item.Value is Array))
{
sql.Append(String.Format("o.{0} = ANY (@{1}) and ", item.Key, item.Key));
}
else
{
sql.Append(String.Format("o.{0} = @{1} and ", item.Key, item.Key));
}
parameters.Add(new NpgsqlParameter(item.Key, item.Value));
}
sql.Length = sql.Length - 5;
}
if (orderBy != null && orderBy.Length > 0)
{
sql.Append(" order by ");
foreach (String field in orderBy)
{
sql.Append("o." + field + ",");
}
sql.Length = sql.Length - 1;
}
IQueryable <T> query;
if (resultClass != null)
{
query = Set <T>(entityManager, resultClass).FromSql(sql.ToString(), parameters.ToArray());
}
else
{
query = entityManager.Set <T>().FromSql(sql.ToString(), parameters.ToArray());
}
return(query);
}
public Task <ActionResult> Update([FromBody] AspNetCoreWebApi.Entity.Request newObj)
{
Console.WriteLine("Dedicated implement of route {0}", this.RouteData.ToString());
String serviceName = CaseConvert.UnderscoreToCamel(newObj.GetType().Name, false);
// TODO : validar se entity.getState() é um State com antecessor e precedente validos.
return(RequestFilter.GetObject <AspNetCoreWebApi.Entity.Request>(this.User.Identity, this.Request, this.entityManager, serviceName).ContinueWith <ActionResult>(taskOldObj => {
return RequestFilter.ProcessUpdate(this.User.Identity, this.Request, this.entityManager, serviceName, newObj).ContinueWith <ActionResult>(taskResponse => {
ActionResult response = taskResponse.Result;
if (response is OkResult)
{
RequestState stateOld = RequestProductEndpoint.GetRequestState(this.entityManager, taskOldObj.Result.State);
RequestState state = RequestProductEndpoint.GetRequestState(this.entityManager, newObj.State);
List <RequestProduct> list = DbUtils.Find <RequestProduct>(this.entityManager, null, QueryMap.Create().AddNext("crudGroupOwner", newObj.CrudGroupOwner).AddNext("request", newObj.Id), null, null, null).Result;
foreach (RequestProduct requestProduct in list)
{
}
}
return response;
}).Result;
}));
}
