public override string Parse(string query, Gale.REST.Queryable.Primitive.Reflected.Model model)
{
if (String.IsNullOrWhiteSpace(query) || String.IsNullOrEmpty(query))
{
return "SYSDATETIME() desc \n\n";
}
else
{
String[] values = query.Split(' ');
String fieldName = values[0].ToLower();
String order = values[1].Trim().ToLower();
Gale.REST.Queryable.Primitive.Reflected.Field _field = model.Fields.FirstOrDefault((field) =>
{
return field.Name == fieldName;
});
if (_field == null)
{
throw new Exception.GaleException("API015", fieldName);
}
return String.Format("{0} {1} \n\n", _field.Key, values[1]);
}
}
public override string Parse(string query, Gale.REST.Queryable.Primitive.Reflected.Model model)
{
//FROM PARSER QUERY
System.Text.StringBuilder builder = new StringBuilder();
List<String> SelectAppends = new List<string>();
//Add Primary Table (First Position)
SelectAppends.Add(String.Format(" FROM {0} T1 \n\n", model.Tables[0].Key));
model.Constraints.ForEach((constraint) =>
{
SelectAppends.Insert(0, String.Concat(", ", constraint.Table.Key, ".* "));
//LEFT JOIN TABLE
builder.Append(String.Format(" LEFT JOIN {0} ON T1.{1} = {0}.{2} \n\n",
constraint.Table.Key,
constraint.ThisField.Key,
constraint.OtherField.Key
));
});
return String.Concat(String.Join("", SelectAppends), builder.ToString());
}
public JsonResult(Gale.REST.Queryable.Primitive.Result response, int offset, int limit)
{
List<object> _items = new List<object>();
foreach (var data in response.data)
{
int ordinal = 0;
var plainObject = new System.Dynamic.ExpandoObject();
var groupedFields = new SortedList<string, KeyValuePair<Gale.REST.Queryable.Primitive.Reflected.Field, Object>>();
foreach (var field in response.fields)
{
if (field.Name.IndexOf("_") > 0)
{
groupedFields.Add(field.Name, new KeyValuePair<Gale.REST.Queryable.Primitive.Reflected.Field, object>(field, data[ordinal]));
}
else
{
//Add Direct Property
((IDictionary<String, Object>)plainObject).Add(field.Name, data[ordinal]);
}
ordinal++;
}
//Order the Grouped Fields
var grouped = groupedFields.GroupBy((field) =>
{
return field.Key.Substring(0, field.Key.IndexOf("_")); ;
});
foreach (var group in grouped)
{
var diggedObject = new System.Dynamic.ExpandoObject();
foreach (var field in group)
{
var columnKey = field.Key.Substring(field.Key.IndexOf("_") + 1);
((IDictionary<String, Object>)diggedObject).Add(columnKey, field.Value.Value);
}
//Add Digged Object
((IDictionary<String, Object>)plainObject).Add(group.Key, diggedObject);
}
_items.Add(plainObject);
ordinal = 0;
}
//Set Values into the Base Response
base.offset = offset;
base.limit = limit;
base.total = response.total;
base.items = _items;
base.elapsedTime = response.elapsedTime.ToString("t");
}
public override string Parse(string query, Gale.REST.Queryable.Primitive.Reflected.Model model)
{
if (String.IsNullOrWhiteSpace(query) || String.IsNullOrEmpty(query))
{
return "";
}
String[] filters = query.Trim().Split(',');
if (filters.Length > 0)
{
//WHERE PARSER QUERY
List<String> builder = new List<string>();
filters.ToList().ForEach((filter) =>
{
//FK Constraint's Filter [ format: fk:(fk_column operator values) ]
if (filter.IndexOf(":(") > 0)
{
var foreignFieldMatch = String.Format("{0})", filter.Substring(0, filter.IndexOf(" ")));
var filteredField = (from field in model.Fields where field.Name == foreignFieldMatch select field).FirstOrDefault();
if (filteredField == null)
{
throw new Exception.GaleException("API009", foreignFieldMatch);
}
//replace the first space with ")", so the format be "foreign:(foreignField) operator value"
String innerFilter = filter.Insert(filter.IndexOf(" "), ")").Substring(0, filter.Length);
String[] values = innerFilter.Trim().Split(' ');
if (values.Length != 3)
{
throw new Exception.GaleException("API010", filter);
}
string _filter = String.Concat(
filteredField.Table.Key,
".",
CallOperator(innerFilter, model)
);
builder.Add(_filter);
}
else
{
//Normal operator [ format: column operator values }
builder.Add(CallOperator(filter));
}
});
return String.Join(" AND ", builder);
}
else
{
return "";
}
}
public override string Parse(Gale.REST.Queryable.Primitive.Reflected.Field field, string value)
{
if (field.Type == typeof(String) || field.Type == typeof(Int32) || field.Type == typeof(System.Guid))
{
List<String> values = value.Split('|').ToList();
String in_values = string.Join("','", values);
return String.Format("{0} IN ('{1}')", field.Key, in_values);
}
else
{
throw new Exception.GaleException("API018");
}
}
public override string Parse(Gale.REST.Queryable.Primitive.Reflected.Field field, string value)
{
String format = "{0} >= {1}";
if (field.Type== typeof(String))
{
format = "LEN({0}) >= {1}";
}
if (field.Type == typeof(DateTime) || field.Type == typeof(DateTime?))
{
format = "{0} >= '{1}'";
}
return String.Format(format, field.Key, value);
}
public override string Parse(Gale.REST.Queryable.Primitive.Reflected.Field field, string value)
{
if (field.Type == typeof(String) || field.Type == typeof(System.Guid))
{
return String.Format("{0} like '%{1}%'", field.Key, value);
}
else if (field.Type == typeof(Int32))
{
//convert(varchar(10),StandardCost)
return String.Format("CONVERT(VARCHAR(8000), {0}) like '%{1}%'", field.Key, value);
}
else
{
throw new Exception.GaleException("API018");
}
}
public ExecutedParserEventArgs(Gale.REST.Queryable.Primitive.Parser parser, String queryFragment)
{
this._parser = parser;
this._resultQueryFragment = queryFragment;
}
public DataService(string command, Gale.Db.Collections.DataParameterCollection parameters)
{
_command = command;
_parameters = parameters;
}
public abstract string Parse(Gale.REST.Queryable.Primitive.Reflected.Field field, string value);
public void _SetBuilder(Gale.REST.Queryable.Primitive.AbstractQueryBuilder builder)
{
this._builder = builder;
}
public override string Parse(string query, Gale.REST.Queryable.Primitive.Reflected.Model model)
{
//SELECT PARSER QUERY
List<String> builder = new List<string>();
if (query.Trim().Length == 0)
{
query = "*";
}
String[] selectedFields = query.ToLower().Split(',');
//---- SELECT FIELD
Action<Gale.REST.Queryable.Primitive.Reflected.Field> SelectField = new Action<Gale.REST.Queryable.Primitive.Reflected.Field>((field) =>
{
//The Main Primary Key , dont'need to add to the selection
if (field.Specification == Gale.REST.Queryable.Primitive.Reflected.Field.SpecificationEnum.Pk)
{
return;
}
//Only if, his, from the primary Table, add to selection,
//because all Foreign key Table, are Getting from the source (ForeignTable.*)
if (field.Table.IsForeign == false)
{
builder.Add(field.Key);
}
field.Select();
});
//---------------------------------
//--- FIRST ADD THE PK
builder.Insert(0, model.Tables.First().PrimaryKey.Key);
//---
foreach (var fieldName in selectedFields)
{
string _fieldName = fieldName.Trim();
//---[ Get all field from all tables :P
if (_fieldName == "*.*")
{
model.Fields.ForEach((f) =>
{
SelectField(f);
});
break;
}
//If query is * , bring all field's
if (_fieldName.Contains("*"))
{
Type searchedTable = null;
//Get all field from the Primary Table
if (_fieldName == "*")
{
searchedTable = model.Tables.First().Type; //Main Table
}
else
{
//try to get all field from a foreign table
if (!_fieldName.Contains(":("))
{
throw new Exception.GaleException("API012", _fieldName);
}
_fieldName = _fieldName.Substring(0, _fieldName.IndexOf(":("));
var fk = model.Constraints.FirstOrDefault(constraint => constraint.ThisField.Name == _fieldName);
if (fk == null)
{
throw new Exception.GaleException("API013", _fieldName);
}
searchedTable = fk.Table.Type;
}
model.Fields.ForEach((f) =>
{
if (f.Table.Type == searchedTable)
{
SelectField(f);
}
});
continue;
}
//Check if field exist's
Gale.REST.Queryable.Primitive.Reflected.Field field = model.Fields.FirstOrDefault((f) =>
{
return f.Name == _fieldName;
});
//If field is not exists, throw exception
if (field == null)
{
throw new Exception.GaleException("API013", _fieldName);
}
//
if (field.Specification == Gale.REST.Queryable.Primitive.Reflected.Field.SpecificationEnum.Pk)
{
throw new Exception.GaleException("API014", _fieldName);
}
//Select Field
SelectField(field);
}
return String.Join(",", builder);
}
