public void GenerateControllers(IEnumerable <ControllerModel> controllers, ReflectionGeneratorBase reflectionGenerator, TypescriptModule targetModule)
{
var proxyClass = new ClassType("GeneratedProxy");
if (!String.IsNullOrEmpty(ProxyBaseName))
{
proxyClass.Extends = new TypescriptTypeReference(ProxyBaseName);
}
targetModule.Members.Add(new DeclarationModuleElement(proxyClass)
{
IsExporting = true
});
foreach (var controller in controllers)
{
var cls = new ClassType(controller.Name + "Proxy");
var proxyType = new TypescriptTypeReference(GeneratedClassName);
cls.Members.Add(new PropertyMember("_parent")
{
MemberType = proxyType,
Accessibility = AccessibilityEnum.Private
});
//cls.Members.Add(new RawStatements("constructor(parent: ", proxyType, ") {\n\tthis._parent = parent;\n}"));
cls.Members.Add(new FunctionMember("constructor", new RawStatements("this._parent = parent;"))
{
Accessibility = null,
Parameters = { new FunctionParameter("parent")
{
ParameterType = proxyType
} },
});
foreach (var am in controller.Actions)
{
cls.Members.Add(GenerateAction(am, reflectionGenerator));
}
targetModule.Members.Add(cls);
targetModule.Members.Last().Comment = controller.Comment;
proxyClass.Members.Add(new PropertyMember(controller.Name.Replace("Controller", ""))
{
MemberType = cls,
Accessibility = AccessibilityEnum.Public,
Initialization = new RawStatements("new ", cls, "(this)")
});
}
targetModule.Members.Add(new RawStatements("export var proxy = new ", proxyClass, "();"));
}
private FunctionMember GenerateAction(ActionModel action, ReflectionGeneratorBase reflectionGenerator)
{
var method = new FunctionMember(action.Name + "Async", null)
{
Accessibility = AccessibilityEnum.Public,
Comment = GenerateActionComment(action)
};
GenerateMethodParametersSignature(action, method, reflectionGenerator);
if (action.ResultType != null)
{
method.ResultType = new TypescriptTypeReference(PromiseTypeName)
{
GenericParameters = { reflectionGenerator.GenerateFromType(action.ResultType) }
};
}
else
{
method.ResultType = new TypescriptTypeReference(PromiseTypeName)
{
GenericParameters = { PrimitiveType.Void }
};
}
method.Body = new RawStatements();
method.Body.Statements.Add("return this._parent.call" + action.HttpMethod + "(");
GenerateUrlParametersValue(action, method);
method.Body.Statements.Add(", ");
GenerateNamedParametersValue(action, method);
var dataParam = action.Parameters.FirstOrDefault(p => p.IsData);
if (dataParam != null)
{
method.Body.Statements.Add(", " + dataParam.Name);
if (dataParam.IsData)
{
method.Body.Statements.Add("/* DATA */");
}
}
method.Body.Statements.Add(");");
return(method);
}
private static void GenerateMethodParametersSignature(ActionModel action, FunctionMember method, ReflectionGeneratorBase reflectionGenerator)
{
method.Parameters.AddRange(action.Parameters
.Where(p => !p.IsOptional)
.Select(p => new FunctionParameter(p.Name)
{
ParameterType = reflectionGenerator.GenerateFromType(p.Type),
IsOptional = false
}));
//consider:
// if there is only one optional parameter, or all opt. parameters are last (it must be in c# decl),
// we can generate myMethod(p1,p2,..., po1:string? = null, po2:number? = null)
// but, it is needed then to call it with positional params (TypeScript doesn't know named params)
// xxx.myMethod("asd","qwe",...,null, 42)
//compare to: call via optional properties of anonymous object
// xxx.myMethod("asd","qwe",..., { po2: 42} )
// BUT, it can be called with any object, because all positional parameters are optional, so any object will match
// xxx.myMethod("asd","qwe",..., "nonsense" )
// partially solved:
// positional parameters are unions of non-nullable parameter objects (see code)
// but this approach will still validate only one of parameters, others are than ignored (because at least one matched)
if (action.Parameters.Any(p => p.IsOptional))
{
var optParams = action.Parameters
.Where(p => p.IsOptional)
.Select(p => new RawStatements("{ ", p.Name, ": ", reflectionGenerator.GenerateFromType(p.Type), " }"))
.ToArray();
var raw = new RawStatements();
foreach (var item in optParams)
{
raw.Add(item);
if (item != optParams.Last())
{
raw.Add(" | ");
}
raw.Add(" ");
}
raw.Add(" = <any>{}");
method.Parameters.Add(new FunctionParameter("opt")
{
ParameterType = new TypescriptTypeReference(raw)
});
}
}
