public object Find(QDescriptor node, IQueryable query)
{
var provider = new ExpressionProvider(this.mapperConfiguration, query.Expression);
var epressionResult = provider.ConvertToExpression(node);
var data = query.Provider.CreateQuery(epressionResult.Expression);
if (epressionResult.HasProjection)
{
List <object> result = new List <object>();
IEnumerator enumerator = data.GetEnumerator();
while (enumerator.MoveNext())
{
result.Add(enumerator.Current);
}
return(result);
}
var target = this.mapperConfiguration.GetAllTypeMaps()
.FirstOrDefault(x => x.SourceType == query.ElementType)
.DestinationType;
var listType = typeof(IEnumerable <>);
var sourceType = listType.MakeGenericType(query.ElementType);
var targetType = listType.MakeGenericType(target);
return(this.mapperConfiguration.CreateMapper().Map(data, sourceType, targetType));
}
protected string GenSelectClauseForUSC(InternalBookmarkItem ibmItem, ref GenOsqlParamInfo paramInfo)
{
//1.Find USC bookmark in the list Conditions to get actual USC.
//2.Build SQl
string sqlClause = string.Empty;
string itemName = BaseMarkupUtilities.GetOriginalBizName(ibmItem.Key, ibmItem.BizName);
if (paramInfo.UscItems == null || paramInfo.UscItems.Count <= 0 || ibmItem.Key.EndsWith(BaseProntoMarkup.KeyEndIf))
{
return(sqlClause);
}
USCItem uscItem = null;
if (paramInfo.UscItems.Keys.Contains(itemName))
{
uscItem = paramInfo.UscItems[itemName];
}
//
Dictionary <string, DSTreeView> lowerFields = new Dictionary <string, DSTreeView>();
foreach (string key in paramInfo.DomainInfo.Fields.Keys)
{
lowerFields.Add(key.ToLower(), paramInfo.DomainInfo.Fields[key]);
}
//Validate and Build SQl
if (uscItem != null)
{
List <Token> lstTokens = new List <Token>();
string error = string.Empty;
ExpressionProvider expressProvider = new ExpressionProvider();
expressProvider.DoTokenize(uscItem.SQLExpression, ref lstTokens, ref error);
foreach (Token token in lstTokens)
{
string key = string.Empty;
if (token.Name.Contains("[") && token.Name.Contains("]"))
{
key = token.Name.Substring(1, token.Name.Length - 2).ToLower();
if (lowerFields.ContainsKey(key))
{
token.Name = lowerFields[key].TechName;
if (paramInfo.DSRelationRow == null)
{
paramInfo.DSRelationRow = lowerFields[key].Relation.Clone();
}
else
{
paramInfo.DSRelationRow.OrRow(lowerFields[key].Relation);
}
}
}
sqlClause += token.Name + " ";
}
}
return(sqlClause.Trim());
}
/// <summary>
/// find token in jtoken
/// </summary>
/// <param name="obj"></param>
/// <param name="key"></param>
/// <param name="objKey"></param>
/// <param name="ignoreCase"></param>
/// <returns></returns>
public static JToken FindToken(JToken obj, string key, string objKey, bool ignoreCase = true)
{
if (obj == null)
{
throw new ArgumentException($"trying to find {key} in {objKey}, but {objKey} is empty");
}
try
{
if (ignoreCase)
{
IDictionary <string, JToken> dic;
if (obj.Type == JTokenType.String)
{
dic = JsonConvert.DeserializeObject <IDictionary <string, JToken> >(obj.ToString());
}
else
{
dic = new Dictionary <string, JToken>(obj.ToObject <IDictionary <string, JToken> >());
}
var kvp = dic.FirstOrDefault(x => string.Equals(x.Key, key, StringComparison.CurrentCultureIgnoreCase));
if (!string.IsNullOrEmpty(kvp.Key))
{
// must use selectToken from obj to provide an token from this obj
return(obj.SelectToken(kvp.Key));
}
else
{
var keyExpressions = ExpressionProvider.GetExpressions("{{" + key + "}}");
if (keyExpressions?.Any() == true)
{
var keyExpression = keyExpressions?.FirstOrDefault();
if (keyExpression?.SubExpression != null)
{
var token = FindToken(obj, keyExpression?.CurrentKey, objKey, ignoreCase);
return(FindToken(token, keyExpression.SubExpression.Key, $"{objKey}.{keyExpression.CurrentKey}", ignoreCase));
}
}
return(obj.SelectToken(key));
}
}
else
{
return(obj.SelectToken(key));
}
}
catch
{
throw new System.ArgumentException($"Cannot find {key} in {objKey}");
}
}
public bool IsValid()
{
if (null == _expData)
{
_messageContent = MessageUtils.Expand(Properties.Resources.ipm_M001, Properties.Resources.ipe_M007);
return(false);
}
Stack <Token> suffixExpressionStack = new Stack <Token>();
ExpressionProvider expProvider = new ExpressionProvider();
ReturnCode retCode = expProvider.Parser(_expData, ref suffixExpressionStack, ref _messageContent);
if (ReturnCode.OK != retCode)
{
return(false);
}
// Check existing of operand
List <SqlVariableName> lstSqlFieldsAndParams = new List <SqlVariableName>();
lstSqlFieldsAndParams = expProvider.GetListFields();
// Set type for operand before validate
SetDataTypeForVarialbe(ref suffixExpressionStack);
if ((!CheckExistsField(lstSqlFieldsAndParams)))
{
return(false);
}
// Validate expression
retCode = expProvider.Validate(suffixExpressionStack, ref _messageContent);
if (ReturnCode.OK != retCode)
{
return(false);
}
// Expression must condition expression
if (SQLTypeName.BOOLEAN != expProvider.ReturnType.Name)
{
_messageContent = MessageUtils.Expand(Properties.Resources.ipm_M001, Properties.Resources.ipe_M008);
return(false);
}
return(true);
}
/// <summary>
/// Constructor for the delegate builder
/// </summary>
/// <param name="pro">Expression provider containing the actual logic to compile</param>
public ExpressionProviderActionDelegateBuilder(ExpressionProvider pro)
{
this.provider = pro;
}
