public HasParametersController(IHasParameters obj)
{
this.obj = obj;
obj.PreRender += new EventHandler(obj_PreRender);
obj.ParametersHiddenField.ValueChanged += new EventHandler(ParametersHiddenField_ValueChanged);
}
public ParameterSegment(Expression value, IHasParameters target)
{
m_target = target;
m_paramName = $"@p{target.ParametersCount + 1}";
var val = ExpressionEvaluator.Eval(value);
m_target.AddParameter(m_paramName, val);
}
public static IParameter AddParameter(this IHasParameters parms, string name, string type,
ParamModifier?mod = null)
{
var parm = Noast.Create <IParameter>(name);
parm.Type = type;
parm.Modifier = mod.GetValueOrDefault();
parms.Parameters.Add(parm);
return(parm);
}
private void Validate(IHasParameters holder, IList <IParameter> parms)
{
var doubled = parms.GroupBy(p => p.Name).Where(g => g.Count() >= 2);
foreach (var pair in doubled)
{
var index = 0;
foreach (var parm in pair)
{
var newName = $"{pair.Key}{++index}";
parm.Rename(newName);
}
}
}
static void PatchTypes(IHasParameters parms, string nspName, IEnumerable <string> names)
{
foreach (var dparm in parms.Parameters)
{
var dparamNsp = dparm.Type.Substring(0, dparm.Type.LastIndexOf('.'));
if ((apiPrefix + dparamNsp) != nspName)
{
continue;
}
var dparamName = 'I' + dparm.Type.Substring(dparamNsp.Length).TrimStart('.');
if (!names.Contains(dparamName))
{
continue;
}
dparm.Type = $"{nspName}.{dparamName}";
}
}
private static void RewriteMethodBody <TParameter>(MethodBody body, IHasParameters <TParameter> parameters)
where TParameter : IParameter <AttributeGroup, TypeReference>, IHasModifier <ParameterModifier>
{
body.Instructions.Clear();
if (parameters != null)
{
foreach (TParameter parameter in parameters.Parameters)
{
if (parameter.Modifier == ParameterModifier.Out)
{
Statement statement = new Statement()
{
ExpressionStatement = new ExpressionStatement()
{
Expression = CreateExpressionForOutParameter(parameter)
}
};
body.Statements.Add(statement);
}
}
}
}
public static IEnumerable <SyntaxNode> GetParamNodes(this SyntaxGenerator gen, IHasParameters holder) => holder.Parameters.OfType <IHasSyntaxNodes>().SelectMany(n => n.GetNodes(gen));
private static string Serialize(string name, IHasParameters obj)
{
return(name + Common.FormatParameters(obj.GetParameters()) + ":" + obj.ToString());
}
public IQuerySegment Map(MethodCallExpression expression, ExpressionMapperBase <IQuerySegment> queryMapper, Type resultingTableType, IHasParameters p)
{
if (expression.Arguments.Count != 2)
{
throw new InvalidOperationException("Two arguments required");
}
var l = queryMapper.Map(expression.Arguments[0]);
var r = queryMapper.Map(expression.Arguments[1]);
return(new LikeSegment(l, r));
}
public static void ClearValues(this IHasParameters ihasPars)
{
ihasPars.Pars.ClearDataValues();
}
public static void AddWithValue(this IHasParameters ihasPars, string key, ulong value)
{
ihasPars.Pars.AddWithValue(key, value);
}
public static void AddWithValue(this IHasParameters ihasPars, string key, System.DateTime value)
{
ihasPars.Pars.AddWithValue(key, value);
}
public IQuerySegment Map(MethodCallExpression expression, ExpressionMapperBase <IQuerySegment> queryMapper, Type resultingTableType, IHasParameters paramTarget)
{
var operand = queryMapper.Map(expression.Arguments[0]);
var builtSubquery = ExpressionEvaluator.Eval(expression.Arguments[1]) as ITransformedQuery;
return(new InSubquerySegment(operand, builtSubquery.GetQuery(queryMapper, paramTarget)));
}
public IQuerySegment ToSegment(ExpressionMapperBase <IQuerySegment> queryMapper, IHasParameters paramsTarget)
{
var model = Build();
var queryText = m_owner.GetQueryText(model, this);
foreach (var p in m_parameters)
{
paramsTarget.AddParameter(p.Key, p.Value);
}
return(new SubquerySegment(queryText));
}
public IQuerySegment Map(MethodCallExpression expression, ExpressionMapperBase <IQuerySegment> queryMapper, Type resultingTableType, IHasParameters paramTarget)
{
var subject = queryMapper.Map(expression.Arguments[0]);
var itemsLst = ExpressionEvaluator.Eval(expression.Arguments[1]) as IEnumerable;
return(new InCsvSegment(subject, itemsLst));
}
private static void RewriteMethodBody <TParameter>(MethodBody body, TypeReference returnType, IHasParameters <TParameter> parameters)
where TParameter : IParameter <AttributeGroup, TypeReference>, IHasModifier <ParameterModifier>
{
RewriteMethodBody(body, parameters);
RewriteMethodBody(body, returnType);
}
public IQuerySegment GetQuery(ExpressionMapperBase <IQuerySegment> queryMapper, IHasParameters paramsTarget)
{
return(m_sourceBuilder.ToSegment(queryMapper, paramsTarget));
}
