public ControllerTypeInformations ParseMethodTypeInformations(Type controller)
{
ControllerTypeInformations controllerInfo = new ControllerTypeInformations();
controllerInfo.Controller = controller;
//Alle Methoden im Controller ermitteln über dem unser Attribut "AngularCreateProxy" gesetzt ist.
//Für jede einzelne Methode müssen die passenden Werte für die MethodenInformationen ermittelt werden
//mit denen dann später der Proxy gebaut wird.
foreach (MethodInfo info in GetControllerMethodsWithCreateProxyAttribute(controller))
{
MethodTypeInformations methodTypeInformations = new MethodTypeInformations();
methodTypeInformations.Controller = controller;
//die Methodeninformationen ermitteln
methodTypeInformations.MethodInfo = info;
//Den aktuellen Methodennamen ermitteln
methodTypeInformations.MethodName = info.Name;
methodTypeInformations.Namespace = string.Empty;
methodTypeInformations.MethodNameWithNamespace = string.Empty;
if (info.DeclaringType != null)
{
methodTypeInformations.Namespace = info.DeclaringType.FullName;
methodTypeInformations.MethodNameWithNamespace = string.Format("{0}.{1}", methodTypeInformations.Namespace, info.Name);
}
//Die Parameter für die aktuelle Methode ermitteln und die einzelnen Parameter auswerten.
methodTypeInformations.ProxyParameterInfos = GetMethodParameterInfos(info);
//In unserem Attribut kann man ebenfalls den ReturnType angeben - dieser wird hier ermittelt.
methodTypeInformations.ReturnType = GetAngularCreateProxyReturnType(info);
controllerInfo.MethodTypeInformations.Add(methodTypeInformations);
}
return(controllerInfo);
}
/// <summary>
/// Zusammenbauen/erstellen des JavaScripProxies
/// </summary>
private void BuildJavaScriptProxyFiles(ControllerTypeInformations controllerInfo, IProxyWriter proxyWriter)
{
//Wenn keine Methoden übergeben wurden, kann auch keine Proxyklasse erstellt werden
if (!controllerInfo.MethodTypeInformations.Any())
{
return;
}
//Den Funktionsnamen/Modulnamen für unser Modul ermitteln, z.B. "HomePSrv"
string javaScriptSrvName = BuildHelper.GetJavaScriptModuleName(controllerInfo.Controller);
//Wenn angegeben, den ersten Buchstaben der funktion kleinschreiben
if (LowerFirstCharInFunctionName)
{
javaScriptSrvName = BuildHelper.LowerFirstCharName(javaScriptSrvName);
}
StringBuilder builder = new StringBuilder();
//Beschriftung einfügen das es sich um ein automatisch generiertes Dokument handelt.
builder.Append(string.Format(AngularProxyJsTemplates.AutomaticlyCreated, DateTime.Now.ToShortDateString(), DateTime.Now.ToLongTimeString(), Environment.UserName));
builder.Append(Environment.NewLine).Append(Environment.NewLine);
//unsere Funktionsdefinition zusammenbauen und einfüge, z.B. "function HomePSrv($http, $log) { ..."
builder.Append(string.Format(AngularProxyJsTemplates.ServerFunctionDefinition, javaScriptSrvName));
builder.Append(Environment.NewLine).Append(Environment.NewLine);
//Alle Methoden durchgehen und die entsprechenden Parameter ermitteln und den passenden
//POST bzw. GET Aufruf zusammenbauen als Prototypefunktion für unsere Funktion.
foreach (MethodTypeInformations info in controllerInfo.MethodTypeInformations)
{
string methodName = info.MethodInfo.Name;
//Wenn angegeben, den ersten Buchstaben der funktion kleinschreiben
if (LowerFirstCharInFunctionName)
{
methodName = BuildHelper.LowerFirstCharName(methodName);
}
string functionParameters = BuildHelper.GetFunctionParameters(info.MethodInfo);
string methodCall = BuildHelper.BuildHttpCall(info, HasSiteRootDefinition);
//Unseren jeweiligen Methodenaufruf zusammenbauen ob POST oder GET
string fctCall = string.Format(AngularProxyJsTemplates.BasicSuccessServerCall,
javaScriptSrvName, methodName, functionParameters, methodCall);
builder.Append(fctCall).Append(Environment.NewLine).Append(Environment.NewLine);
}
//Unsere ModulDefinition hinzufügen, z.B. 'angular.module("app.HomePSrv", []).service("HomePSrv", HomePSrv);'
builder.Append(string.Format(AngularProxyJsTemplates.ModuleDefinition, javaScriptSrvName));
string proxy = builder.ToString();
//Die Proxy Dateien ins Dateisystem schreiben
proxyWriter.SaveProxyContent(proxy, string.Format(@"{0}.js", javaScriptSrvName));
}
/// <summary>
/// Die Passenden Funktionsdefinitionen für unseren TypeScript Service zusammenbauen.
/// </summary>
private string BuildfunctionDefinitions(ControllerTypeInformations controllerInfo)
{
StringBuilder functionDefionition = new StringBuilder();
//Das folgende Template mit Daten füllen:
//{0}({1}) : ng.IPromise<{2}> {{
// return this.$http.{3}.then((response: ng.IHttpPromiseCallbackArg<{2}>) : {2}
// => {{ return response.data; }} );
//}}
//Template Variablen:
//{0} --> Der Name der Service Funktion
//{1} --> Die Parameter der Service Funktion
//{2} --> Der RückgabeTyp der Funktion
//{3} --> Der Get bzw. Post Call an unseren Service
//Alle Methoden durchgehen und die entsprechenden Parameter ermitteln und den passenden
//POST bzw. GET Aufruf zusammenbauen als Prototypefunktion für unsere Funktion.
foreach (MethodTypeInformations info in controllerInfo.MethodTypeInformations)
{
string methodName = info.MethodName;
//Wenn angegeben, den ersten Buchstaben der funktion kleinschreiben
if (LowerFirstCharInFunctionName)
{
methodName = BuildHelper.LowerFirstCharName(methodName);
}
string functionParameters = BuildHelper.GetFunctionParametersWithType(info.MethodInfo);
string methodCall = BuildHelper.BuildHttpCall(info, HasSiteRootDefinition);
//Prüfen ob der HTTP Call auch einen Rückgabewert erwartet.
if (info.ReturnType != null)
{
//Unseren jeweiligen Methodenaufruf zusammenbauen ob POST oder GET
string fctCall = string.Format(AngularJsProxyTsTemplates.FunctionDefnitionWithReturnType,
methodName,
functionParameters,
BuildHelper.AddInterfacePrefixToFullName(info.ReturnType.FullName),
methodCall);
functionDefionition.Append(fctCall).Append(Environment.NewLine);
}
else
{
//Es gibt keinen Rückgabewert, sondern nur ein Einfacher Call der eine Funktion auslösen soll.
string fctCall = string.Format(AngularJsProxyTsTemplates.FunctionDefnitionNoReturnType,
methodName,
functionParameters,
methodCall);
functionDefionition.Append(fctCall).Append(Environment.NewLine);
}
functionDefionition.Append(Environment.NewLine);
}
return(functionDefionition.ToString());
}
/// <summary>
/// Erstellen der passenden Proxy Klassen für die Controller
/// </summary>
/// <param name="controller">Liste mit Controllern für die Proxy Klassen erstellt werden sollen</param>
public void StartBuildProcess(List <Type> controller)
{
//Alle übergebene Typen durchgehen
foreach (Type type in controller)
{
//Prüfen ob der Controller direkt von Controller ableitet oder eine andere Basisklasse hat, die von Controller ableitet.
if (type.IsSubclassOf(typeof(Controller)) || type == typeof(Controller))
{
//Alle Methoden ermitteln für die ein Proxy erstellt werden soll.
ControllerTypeInformations controllerInfo = MethodTypeInformationParser.ParseMethodTypeInformations(type);
//Für den jeweiligen Controller dann den JavaScriptProxy erstellen.
BuilderFor.BuildProxyFile(controllerInfo, ProxyWriter);
}
}
}
/// <summary>
/// Zusammenbauen/erstellen des JavaScripProxies
/// </summary>
private void BuildJavaScriptProxyFiles(ControllerTypeInformations controllerInfo, IProxyWriter proxyWriter)
{
//Wenn keine Methoden übergeben wurden, kann auch keine Proxyklasse erstellt werden
if (!controllerInfo.MethodTypeInformations.Any())
{
return;
}
//Den Funktionsnamen/Modulnamen für unser Modul ermitteln, z.B. "HomePSrv"
string javaScriptSrvName = BuildHelper.GetJavaScriptModuleName(controllerInfo.Controller);
string controllerName = BuildHelper.GetClearControllerName(controllerInfo.Controller).Trim() + "PService";
//Wenn angegeben, den ersten Buchstaben der funktion kleinschreiben
if (LowerFirstCharInFunctionName)
{
javaScriptSrvName = BuildHelper.LowerFirstCharName(javaScriptSrvName);
}
StringBuilder builder = new StringBuilder();
//Beschriftung einfügen das es sich um ein automatisch generiertes Dokument handelt.
builder.Append(string.Format(AngularJsProxyTsTemplates.AutomaticlyCreated, DateTime.Now.ToShortDateString(), DateTime.Now.ToLongTimeString(), Environment.UserName));
builder.Append(Environment.NewLine).Append(Environment.NewLine);
//Unser GesamtTemplate entsprechend ausfüllen. Beschreibung der Templatewerte:
//{0} --> Der Name der Klasse
//{1} --> Auflistung der Interface Funktionen für unsere Klasse
//{2} --> Auflistung der Service Funktionen die über das Interface eingebunden wurden
//{3} --> der Name des Service Moduls nach "außen"
string fct = string.Format(AngularJsProxyTsTemplates.ModuleTemplate,
controllerName,
BuildInterfaceDifinitions(controllerInfo),
BuildfunctionDefinitions(controllerInfo),
javaScriptSrvName);
builder.Append(fct);
builder.Append(Environment.NewLine).Append(Environment.NewLine);
string proxy = builder.ToString();
//Die Proxy Datei ins Dateisystem schreiben *.ts -> TypeScript
proxyWriter.SaveProxyContent(proxy, string.Format(@"{0}.ts", javaScriptSrvName));
}
/// <summary>
/// Die Definition für unsere Interface Übersicht zusammenbauen.
/// </summary>
private string BuildInterfaceDifinitions(ControllerTypeInformations controllerInfo)
{
StringBuilder interfaceDefinitions = new StringBuilder();
//die Interface definition für unsere Klasse zusammenbauen.
//Template:
// {0}({1}) : ng.IPromise<{2}>;
//Beschreibung der Templatewerte
//{0} --> Der Name der Servicefuntkion
//{1} --> Die Parameterliste und Typen der ServiceFunktion
//{2} --> ReturnValue unseres Interfaces
foreach (MethodTypeInformations info in controllerInfo.MethodTypeInformations)
{
string methodName = info.MethodName;
//Wenn angegeben, den ersten Buchstaben der funktion kleinschreiben
if (LowerFirstCharInFunctionName)
{
methodName = BuildHelper.LowerFirstCharName(methodName);
}
//Prüfen ob es einen Rückgabewert gibt und dann das Interface entsprechend zusammenbauen.
if (info.ReturnType == null)
{
interfaceDefinitions.Append(String.Format("{0}({1}): void;", methodName, BuildHelper.GetFunctionParametersWithType(info.MethodInfo)));
}
else
{
interfaceDefinitions.Append(String.Format("{0}({1}) : ng.IPromise<{2}>;", methodName,
BuildHelper.GetFunctionParametersWithType(info.MethodInfo),
BuildHelper.AddInterfacePrefixToFullName(info.ReturnType.FullName)));
}
interfaceDefinitions.Append(Environment.NewLine);
}
return(interfaceDefinitions.ToString());
}
public void BuildProxyFile(ControllerTypeInformations informations, IProxyWriter proxyWriter)
{
BuildJavaScriptProxyFiles(informations, proxyWriter);
}
