public void Setup()
{
//Aus der Aktuellen Test DLL DEN Typen ermitteln in dem der Name "GetFunctionParametersOneParam" vorkommt, sollte nur einen Typen geben!
//Achtung Private "Sub" Klasse!
TestClassType = Assembly.GetExecutingAssembly().GetTypes().First(type => type.Name.Contains("HasAttributeOneParam"));
ProxyBuildHelper = new ProxyBuilderHelper(new ProxySettings());
}
private TypeInfo CreateUncachedProxyType(System.Type baseType, IReadOnlyCollection <System.Type> baseInterfaces)
{
AppDomain currentDomain = AppDomain.CurrentDomain;
string typeName = string.Format("{0}Proxy", baseType.Name);
string assemblyName = string.Format("{0}Assembly", typeName);
string moduleName = string.Format("{0}Module", typeName);
var name = new AssemblyName(assemblyName);
AssemblyBuilder assemblyBuilder = ProxyAssemblyBuilder.DefineDynamicAssembly(currentDomain, name);
ModuleBuilder moduleBuilder = ProxyAssemblyBuilder.DefineDynamicModule(assemblyBuilder, moduleName);
TypeAttributes typeAttributes = TypeAttributes.AutoClass | TypeAttributes.Class |
TypeAttributes.Public | TypeAttributes.BeforeFieldInit;
var interfaces = new HashSet <System.Type>();
interfaces.UnionWith(baseInterfaces);
interfaces.UnionWith(baseInterfaces.SelectMany(i => i.GetInterfaces()));
// Use the proxy dummy as the base type
// since we're not inheriting from any class type
System.Type parentType = baseType;
if (baseType.IsInterface)
{
parentType = typeof(ProxyDummy);
interfaces.Add(baseType);
interfaces.UnionWith(baseType.GetInterfaces());
}
// Add the ISerializable interface so that it can be implemented
interfaces.Add(typeof(ISerializable));
TypeBuilder typeBuilder = moduleBuilder.DefineType(typeName, typeAttributes, parentType, interfaces.ToArray());
ConstructorBuilder defaultConstructor = DefineConstructor(typeBuilder, parentType);
// Implement IProxy
var implementor = new ProxyImplementor();
implementor.ImplementProxy(typeBuilder);
FieldInfo interceptorField = implementor.InterceptorField;
// Provide a custom implementation of ISerializable
// instead of redirecting it back to the interceptor
foreach (MethodInfo method in ProxyBuilderHelper.GetProxiableMethods(baseType, interfaces).Where(method => method.DeclaringType != typeof(ISerializable)))
{
ProxyMethodBuilder.CreateProxiedMethod(interceptorField, method, typeBuilder);
}
// Make the proxy serializable
AddSerializationSupport(baseType, baseInterfaces, typeBuilder, interceptorField, defaultConstructor);
TypeInfo proxyType = typeBuilder.CreateTypeInfo();
ProxyAssemblyBuilder.Save(assemblyBuilder);
return(proxyType);
}
public void CreateProxiedMethod(FieldInfo field, MethodInfo method, TypeBuilder typeBuilder)
{
var callbackMethod = ProxyBuilderHelper.GenerateMethodSignature(method.Name + "_callback", method, typeBuilder);
var proxyMethod = ProxyBuilderHelper.GenerateMethodSignature(method.Name, method, typeBuilder);
MethodBodyEmitter.EmitMethodBody(proxyMethod, callbackMethod, method, field);
typeBuilder.DefineMethodOverride(proxyMethod, method);
}
public void ControllerName_Two_Letters()
{
//Arrange
var proxyBuilder = new ProxyBuilderHelper(new ProxySettings());
//Act
var name = proxyBuilder.GetProxyFileName("Ho", "PSrv", "js");
//Assert
Assert.AreEqual(name, "hoPSrv.js");
}
public void JavaScriptFile_Extensions()
{
//Arrange
var proxyBuilder = new ProxyBuilderHelper(new ProxySettings());
//Act
var name = proxyBuilder.GetProxyFileName("Home", "PSrv", "js");
//Assert
Assert.AreEqual(name, "homePSrv.js");
}
public void Suffix_Empty()
{
//Arrange
var proxyBuilder = new ProxyBuilderHelper(new ProxySettings());
//Act
var name = proxyBuilder.GetProxyFileName("home", string.Empty, "js");
//Assert
Assert.AreEqual(name, "home.js");
}
public void No_Controller_Suffix()
{
//Arrange
var testClassType = Assembly.GetExecutingAssembly().GetTypes().First(type => type.Name.Contains("MeinTestOhneCtrl"));
var proxyBuildHelper = new ProxyBuilderHelper(new ProxySettings());
//Act
var clearName = proxyBuildHelper.GetClearControllerName(testClassType);
//Assert
Assert.AreEqual(clearName, "MeinTestOhneCtrl");
}
public void LowerFirstChar_True()
{
//Arrange
var proxyBuilder = new ProxyBuilderHelper(new ProxySettings()
{
LowerFirstCharInFunctionName = true
});
//Act
var name = proxyBuilder.GetServiceName("Home", "PSrv", true);
//Assert
Assert.AreEqual(name, "homePSrv");
}
public void ControllerSuffix_Null_LowerFirstChar_True()
{
//Arrange
var proxyBuilder = new ProxyBuilderHelper(new ProxySettings()
{
LowerFirstCharInFunctionName = true
});
//Act
var name = proxyBuilder.GetServiceName("Ho", null, true);
//Assert
Assert.AreEqual(name, "ho");
}
public void LowerFirstChar_False()
{
//Arrange
var proxyBuilder = new ProxyBuilderHelper(new ProxySettings()
{
LowerFirstCharInFunctionName = false
});
//Act
var name = proxyBuilder.GetProxyFunctionName("GetMember");
//Assert
Assert.AreEqual(name, "GetMember");
}
public void ControllerName_Two_CharLength()
{
//Arrange
var proxyBuilder = new ProxyBuilderHelper(new ProxySettings()
{
LowerFirstCharInFunctionName = true
});
//Act
var name = proxyBuilder.GetServiceName("Ho", "PSrv", true);
//Assert
Assert.AreEqual(name, "hoPSrv");
}
public void ControllerName_One_CharLength_LowerFirstChar_False()
{
//Arrange
var proxyBuilder = new ProxyBuilderHelper(new ProxySettings()
{
LowerFirstCharInFunctionName = false
});
//Act
var name = proxyBuilder.GetServiceName("H", "PSrv", false);
//Assert
Assert.AreEqual(name, "HPSrv");
}
public void LowerFirstChar_True_Methodname_Two_CharLength()
{
//Arrange
var proxyBuilder = new ProxyBuilderHelper(new ProxySettings()
{
LowerFirstCharInFunctionName = true
});
//Act
var name = proxyBuilder.GetProxyFunctionName("Ge");
//Assert
Assert.AreEqual(name, "ge");
}
/// <summary>
/// Das passende HREF Template laden und die passenden TemplateString ersetzten.
/// </summary>
private string BuildHrefTemplate(ProxyMethodInfos methodInfos, ProxyControllerInfo controllerInfo, string suffix)
{
var functionTemplate = Factory.GetProxySettings().Templates.First(p => p.TemplateType == TemplateTypes.AngularJsWindowLocationHref).Template;
//Den Methodennamen ersetzen - Der Servicename der aufgerufen werden soll.
string functionCall = functionTemplate.Replace(ConstValuesTemplates.ControllerFunctionName, ProxyBuilderHelper.GetProxyFunctionName(methodInfos.MethodInfo.Name));
//Parameter des Funktionsaufrufs ersetzen.
functionCall = functionCall.Replace(ConstValuesTemplates.ServiceParamters, ProxyBuilderHelper.GetFunctionParameters(methodInfos.MethodInfo));
//Href Call zusammenbauen und Parameter ersetzen
functionCall = functionCall.Replace(ConstValuesTemplates.ServiceCallAndParameters, ProxyBuilderHttpCall.BuildHrefLink(methodInfos, ProxyBuilder.AngularJavaScript));
//Den Servicenamen vor dem Prototype ersetzen.
functionCall = functionCall.Replace(ConstValuesTemplates.ServiceName, ProxyBuilderHelper.GetServiceName(controllerInfo.ControllerNameWithoutSuffix, suffix, Factory.GetProxySettings().LowerFirstCharInFunctionName));
return(functionCall);
}
public List <GeneratedProxyEntry> BuildProxy(List <ProxyControllerInfo> proxyControllerInfos)
{
CheckRequirements();
List <GeneratedProxyEntry> generatedProxyEntries = new List <GeneratedProxyEntry>();
var suffix = Factory.GetProxySettings().Templates.First(p => p.TemplateType == TemplateTypes.AngularTsModule).TemplateSuffix;
#region Template Example
//TEMPLATE FÜR: "TemplateTypes.AngularTsModule":
// module App.Services {;
// export interface I#ServiceName# { #InterfaceDefinitions# };
// export class #ServiceName# implements I#ServiceName# {{;
// static $inject = ['$http'];
// constructor(private $http: ng.IHttpService) { };
//
// #ServiceFunctions#;
//
//#region Angular Module Definition
// private static _module: ng.IModule;
// public static get module(): ng.IModule {
// if (this._module) { return this._module; }
// this._module = angular.module('#ServiceName#', []);
// this._module.service('#ServiceName#', #ServiceName#);
// return this._module;}
//#endregion
//TEMPLATE FÜR: "TemplateTypes.AngularTsAjaxCallWithReturnType"
// #ControllerFunctionName#(#ServiceParamters#) : ng.IPromise<{#ControllerFunctionReturnType#}> {
// "#FunctionContent#"
// return this.$http.#ServiceCallAndParameters#.then(
// (response: ng.IHttpPromiseCallbackArg<{#ControllerFunctionReturnType#}>) : {#ControllerFunctionReturnType#} => { return response.data; } ); }
//TEMPLATE FÜR: "TemplateTypes.AngularTsAjaxCallNoReturnType"
// #ControllerFunctionName#(#ServiceParamters#) : void { \r\n this.$http.#ServiceCallAndParameters#;}
//TEMPLATE FÜR: Window.location.href
// public #ControllerFunctionName#(#ServiceParamters#) : void { \r\n window.location.href = #ServiceCallAndParameters#; };
#endregion
//Alle controller durchgehen die übergeben wurden und für jeden dann die entsprechenden Proxy Methoden erstellen
foreach (ProxyControllerInfo controllerInfo in proxyControllerInfos)
{
//Immer das passende Template ermitteln, da dieses bei jedem Durchgang ersetzt wird.
var angularTsModuleTemplate = Factory.GetProxySettings().Templates.First(p => p.TemplateType == TemplateTypes.AngularTsModule).Template;
var ajaxCalls = String.Empty;
var serviceInterfaceDefinitions = string.Empty;
//Alle Metohden im Controller durchgehen hier sind auch nur die Methoden enthalten die das Attribut für den aktuellen ProxyTyp gesetzt wurde.
foreach (ProxyMethodInfos methodInfos in controllerInfo.ProxyMethodInfos)
{
var functionTemplate = Factory.GetProxySettings().Templates.First(p => p.TemplateType == TemplateTypes.AngularTsAjaxCallNoReturnType).Template;
//Wenn es sich um eine Funktion mit HREF handelt, dann muss ein anderes Template geladen werden.
if (methodInfos.CreateWindowLocationHrefLink)
{
ajaxCalls += this.BuildHrefTemplate(methodInfos);
//Da ein HREF Link auch keinen Rückgabewert hat, diesen mit Void ersetzen und die passende Interface Definition erstellen.
serviceInterfaceDefinitions += String.Format(" {0}({1}): void;\r\n", ProxyBuilderHelper.GetProxyFunctionName(methodInfos.MethodInfo.Name),
ProxyBuilderTypeHelper.GetFunctionParametersWithType(methodInfos.MethodInfo));
continue;
}
if (ProxyBuilderTypeHelper.HasReturnType(methodInfos.ReturnType))
{
//sollte ein ReturnType verwendet werden, dann das andere Template laden mit ReturnType
functionTemplate = Factory.GetProxySettings().Templates.First(p => p.TemplateType == TemplateTypes.AngularTsAjaxCallWithReturnType).Template;
//Für Methoden mit ReturnType muss auch der passende ReturnType ersetzt werden
functionTemplate = functionTemplate.Replace(ConstValuesTemplates.ControllerFunctionReturnType, ProxyBuilderTypeHelper.GetTsType(methodInfos.ReturnType));
//Die Servicedefinition für jede Methode hinzufügen
serviceInterfaceDefinitions += String.Format(" {0}({1}) : ng.IPromise<{2}>;\r\n", ProxyBuilderHelper.GetProxyFunctionName(methodInfos.MethodInfo.Name),
ProxyBuilderTypeHelper.GetFunctionParametersWithType(methodInfos.MethodInfo),
ProxyBuilderTypeHelper.GetTsType(methodInfos.ReturnType));
//Wenn es sich um einen FileUpload handelt wird hier das passende FormData eingebaut.
functionTemplate = functionTemplate.Replace(ConstValuesTemplates.FunctionContent, ProxyBuilderHelper.GetFileUploadFormData(methodInfos));
}
else
{
//Für Funktionen Ohne Rückgabewert "void" setzten
serviceInterfaceDefinitions += String.Format(" {0}({1}): void;\r\n", ProxyBuilderHelper.GetProxyFunctionName(methodInfos.MethodInfo.Name),
ProxyBuilderTypeHelper.GetFunctionParametersWithType(methodInfos.MethodInfo));
functionTemplate = functionTemplate.Replace(ConstValuesTemplates.FunctionContent, ProxyBuilderHelper.GetFileUploadFormData(methodInfos));
}
//Den Methodennamen ersetzen - Der Servicename der aufgerufen werden soll.
string functionCall = functionTemplate.Replace(ConstValuesTemplates.ControllerFunctionName, ProxyBuilderHelper.GetProxyFunctionName(methodInfos.MethodInfo.Name));
//Parameter des Funktionsaufrufs ersetzen.
functionCall = functionCall.Replace(ConstValuesTemplates.ServiceParamters, ProxyBuilderTypeHelper.GetFunctionParametersWithType(methodInfos.MethodInfo));
//Service Call und Parameter ersetzen
functionCall = functionCall.Replace(ConstValuesTemplates.ServiceCallAndParameters, ProxyBuilderHttpCall.BuildHttpCall(methodInfos, ProxyBuilder.AngularTypeScript));
ajaxCalls += functionCall;
}
string moduleTemplate = angularTsModuleTemplate.Replace(ConstValuesTemplates.ServiceName, ProxyBuilderHelper.GetServiceName(controllerInfo.ControllerNameWithoutSuffix, suffix.TrimStart('.'), false));
moduleTemplate = moduleTemplate.Replace(ConstValuesTemplates.ServiceFunctions, ajaxCalls);
moduleTemplate = moduleTemplate.Replace(ConstValuesTemplates.InterfaceDefinitions, serviceInterfaceDefinitions);
GeneratedProxyEntry proxyEntry = new GeneratedProxyEntry();
proxyEntry.FileContent = moduleTemplate;
proxyEntry.FileName = ProxyBuilderHelper.GetProxyFileName(controllerInfo.ControllerNameWithoutSuffix, suffix, "ts");
proxyEntry.FilePath = SettingsManager.GetAlternateOutputpath(TemplateTypes.AngularTsModule);
generatedProxyEntries.Add(proxyEntry);
}
return(generatedProxyEntries);
}
/// <summary>
/// Das passende HREF Template laden und die passenden TemplateString ersetzten.
/// </summary>
private string BuildHrefTemplate(ProxyMethodInfos methodInfos)
{
var functionTemplate = Factory.GetProxySettings().Templates.First(p => p.TemplateType == TemplateTypes.Angular2TsWindowLocationHref).Template;
//Den Methodennamen ersetzen - Der Servicename der aufgerufen werden soll.
string functionCall = functionTemplate.Replace(ConstValuesTemplates.ControllerFunctionName, ProxyBuilderHelper.GetProxyFunctionName(methodInfos.MethodInfo.Name));
//Parameter des Funktionsaufrufs ersetzen.
functionCall = functionCall.Replace(ConstValuesTemplates.ServiceParamters, ProxyBuilderTypeHelper.GetFunctionParametersWithType(methodInfos.MethodInfo));
//Href Call zusammenbauen und Parameter ersetzen
functionCall = functionCall.Replace(ConstValuesTemplates.ServiceCallAndParameters, ProxyBuilderHttpCall.BuildHrefLink(methodInfos, ProxyBuilder.Angular2TypeScript));
return(functionCall);
}
/// <summary>
/// Den Proxy für AngularJs bauen. Hier wird eine Liste aus den Dateinamen (Controllern) und den enthaltenen Proxyfunktionen erstellt.
/// </summary>
public List <GeneratedProxyEntry> BuildProxy(List <ProxyControllerInfo> proxyControllerInfos)
{
CheckRequirements();
List <GeneratedProxyEntry> generatedProxyEntries = new List <GeneratedProxyEntry>();
var suffix = Factory.GetProxySettings().Templates.First(p => p.TemplateType == TemplateTypes.AngularJsModule).TemplateSuffix;
#region Template Example
//TEMPLATE FÜR: "TemplateTypes.AngularJsModule":
// function #ServiceName#($http) {{ this.http = $http; }}"
// #PrototypeServiceCalls#"
// angular.module('#ServiceName#', []) .service('#ServiceName#', ['$http', #ServiceName#])
//TEMPLATE FÜR: "TemplateTypes.AngularJsPrototype"
// #ServiceName#.prototype.#controllerFunctionName# = function (#serviceParamters#) {{
// return this.http.#ServiceCallAndParameters#.then(function (result) {{ return result.data; }});}}
//TEMPLATE FÜR: Window.location.href
// #ServiceName#.prototype.#ControllerFunctionName# = function (#ServiceParamters#) { \r\n window.location.href = #ServiceCallAndParameters# };
#endregion
//Alle controller durchgehen die übergeben wurden und für jeden dann die entsprechenden Proxy Methoden erstellen
foreach (ProxyControllerInfo controllerInfo in proxyControllerInfos)
{
//Immer das passende Template ermitteln, da dieses bei jedem Durchgang ersetzt wird.
var angularJsModuleTemplate = Factory.GetProxySettings().Templates.First(p => p.TemplateType == TemplateTypes.AngularJsModule).Template;
var prototypeFunctions = String.Empty;
//Alle Metohden im Controller durchgehen hier sind auch nur die Methoden enthalten die das Attribut für den aktuellen ProxyTyp gesetzt wurde.
foreach (ProxyMethodInfos methodInfos in controllerInfo.ProxyMethodInfos)
{
var angularJsPrototypeTemplate = Factory.GetProxySettings().Templates.First(p => p.TemplateType == TemplateTypes.AngularJsPrototype).Template;
//Wenn es sich um eine Funktion mit HREF handelt, dann muss ein anderes Template geladen werden.
if (methodInfos.CreateWindowLocationHrefLink)
{
prototypeFunctions += this.BuildHrefTemplate(methodInfos, controllerInfo, suffix);
continue;
}
//Den Servicenamen vor dem Prototype ersetzen.
string prototypeFunction = angularJsPrototypeTemplate.Replace(ConstValuesTemplates.ServiceName, ProxyBuilderHelper.GetServiceName(controllerInfo.ControllerNameWithoutSuffix, suffix, Factory.GetProxySettings().LowerFirstCharInFunctionName));
//Den Methodennamen ersetzen.
prototypeFunction = prototypeFunction.Replace(ConstValuesTemplates.ControllerFunctionName, ProxyBuilderHelper.GetProxyFunctionName(methodInfos.MethodInfo.Name));
//Parameter des Funktionsaufrufs ersetzen.
prototypeFunction = prototypeFunction.Replace(ConstValuesTemplates.ServiceParamters, ProxyBuilderHelper.GetFunctionParameters(methodInfos.MethodInfo));
//Wenn es sich um einen FileUpload handelt wird hier das passende FormData eingebaut.
prototypeFunction = prototypeFunction.Replace(ConstValuesTemplates.FunctionContent, ProxyBuilderHelper.GetFileUploadFormData(methodInfos));
//Service Call und Parameter ersetzen
prototypeFunction = prototypeFunction.Replace(ConstValuesTemplates.ServiceCallAndParameters, ProxyBuilderHttpCall.BuildHttpCall(methodInfos, ProxyBuilder.AngularJavaScript));
//Der Variablen für Alle Prototype functions die "neue" Funktion hinzufügen.
prototypeFunctions += prototypeFunction;
}
string moduleTemplate = angularJsModuleTemplate.Replace(ConstValuesTemplates.ServiceName, ProxyBuilderHelper.GetServiceName(controllerInfo.ControllerNameWithoutSuffix, suffix, true));
moduleTemplate = moduleTemplate.Replace(ConstValuesTemplates.PrototypeServiceCalls, prototypeFunctions);
GeneratedProxyEntry proxyEntry = new GeneratedProxyEntry();
proxyEntry.FileContent = moduleTemplate;
proxyEntry.FileName = ProxyBuilderHelper.GetProxyFileName(controllerInfo.ControllerNameWithoutSuffix, suffix, "js");
proxyEntry.FilePath = SettingsManager.GetAlternateOutputpath(TemplateTypes.AngularJsModule);
generatedProxyEntries.Add(proxyEntry);
}
return(generatedProxyEntries);
}
public List <GeneratedProxyEntry> BuildProxy(List <ProxyControllerInfo> proxyControllerInfos)
{
CheckRequirements();
List <GeneratedProxyEntry> generatedProxyEntries = new List <GeneratedProxyEntry>();
var suffix = Factory.GetProxySettings().Templates.First(p => p.TemplateType == TemplateTypes.Angular2TsModule).TemplateSuffix;
#region Template Example
//TEMPLATE FÜR: "TemplateTypes.Angular2TsModule":
//import {Injectable} from '@angular/core';\r\n
//import {Http, Response} from '@angular/http';\r\n
//import {Observable} from 'rxjs/observable';\r\n"
//import 'rxjs/add/operator/map';\r\n\r\n"
//
//@Injectable()\r\n
//export class #ServiceName# {
// constructor(private _http: Http) {\r\n\r\n
// #ServiceFunctions#
//\r\n }
//TEMPLATE FÜR: "TemplateTypes.Angular2TsModuleObservableWithReturnType"
//public #ControllerFunctionName#(#ServiceParamters#) : Observable<{#ControllerFunctionReturnType#}> { \r\n #FunctionContent#" +
// return this._http.#ServiceCallAndParameters#.map((response: Response) => <{#ControllerFunctionReturnType#}>response.json() as {#ControllerFunctionReturnType#});\r\n} \r\n\r\n";
//TEMPLATE FÜR: "TemplateTypes.Angular2TsModuleObservableNoReturnType"
// public #ControllerFunctionName#(#ServiceParamters#) : void { \r\n #FunctionContent# this._http.#ServiceCallAndParameters#; \r\n } \r\n\r\n";
//TEMPLATE FÜR: Window.location.href
// public #ControllerFunctionName#(#ServiceParamters#) : void { \r\n window.location.href = #ServiceCallAndParameters#; };
#endregion
//Alle controller durchgehen die übergeben wurden und für jeden dann die entsprechenden Proxy Methoden erstellen
foreach (ProxyControllerInfo controllerInfo in proxyControllerInfos)
{
//Immer das passende Template ermitteln, da dieses bei jedem Durchgang ersetzt wird.
var angularTsModuleTemplate = Factory.GetProxySettings().Templates.First(p => p.TemplateType == TemplateTypes.Angular2TsModule).Template;
var ajaxCalls = String.Empty;
//Alle Metohden im Controller durchgehen hier sind auch nur die Methoden enthalten die das Attribut für den aktuellen ProxyTyp gesetzt wurde.
foreach (ProxyMethodInfos methodInfos in controllerInfo.ProxyMethodInfos)
{
var functionTemplate = Factory.GetProxySettings().Templates.First(p => p.TemplateType == TemplateTypes.Angular2TsModuleObservableNoReturnType).Template;
//Wenn es sich um eine Funktion mit HREF handelt, dann muss ein anderes Template geladen werden.
if (methodInfos.CreateWindowLocationHrefLink)
{
ajaxCalls += this.BuildHrefTemplate(methodInfos);
//Da ein HREF Link auch keinen Rückgabewert hat, diesen mit Void ersetzen und die passende Interface Definition erstellen.
continue;
}
if (ProxyBuilderTypeHelper.HasReturnType(methodInfos.ReturnType))
{
//sollte ein ReturnType verwendet werden, dann das andere Template laden mit ReturnType
functionTemplate = Factory.GetProxySettings().Templates.First(p => p.TemplateType == TemplateTypes.Angular2TsModuleObservableWithReturnType).Template;
//Für Methoden mit ReturnType muss auch der passende ReturnType ersetzt werden
functionTemplate = functionTemplate.Replace(ConstValuesTemplates.ControllerFunctionReturnType, ProxyBuilderTypeHelper.GetTsType(methodInfos.ReturnType));
//Wenn es sich um einen FileUpload handelt wird hier das passende FormData eingebaut.
functionTemplate = functionTemplate.Replace(ConstValuesTemplates.FunctionContent, ProxyBuilderHelper.GetFileUploadFormData(methodInfos));
}
else
{
functionTemplate = functionTemplate.Replace(ConstValuesTemplates.FunctionContent, ProxyBuilderHelper.GetFileUploadFormData(methodInfos));
}
//Den Methodennamen ersetzen - Der Servicename der aufgerufen werden soll.
string functionCall = functionTemplate.Replace(ConstValuesTemplates.ControllerFunctionName, ProxyBuilderHelper.GetProxyFunctionName(methodInfos.MethodInfo.Name));
//Parameter des Funktionsaufrufs ersetzen.
functionCall = functionCall.Replace(ConstValuesTemplates.ServiceParamters, ProxyBuilderTypeHelper.GetFunctionParametersWithType(methodInfos.MethodInfo));
//Service Call und Parameter ersetzen
functionCall = functionCall.Replace(ConstValuesTemplates.ServiceCallAndParameters, ProxyBuilderHttpCall.BuildHttpCall(methodInfos, ProxyBuilder.Angular2TypeScript));
ajaxCalls += functionCall;
}
string moduleTemplate = angularTsModuleTemplate.Replace(ConstValuesTemplates.ServiceName, ProxyBuilderHelper.GetServiceName(controllerInfo.ControllerNameWithoutSuffix, suffix.TrimStart('.'), false));
moduleTemplate = moduleTemplate.Replace(ConstValuesTemplates.ServiceFunctions, ajaxCalls);
GeneratedProxyEntry proxyEntry = new GeneratedProxyEntry();
proxyEntry.FileContent = moduleTemplate;
proxyEntry.FileName = ProxyBuilderHelper.GetProxyFileName(controllerInfo.ControllerNameWithoutSuffix, suffix, "ts");
proxyEntry.FilePath = SettingsManager.GetAlternateOutputpath(TemplateTypes.Angular2TsModule);
generatedProxyEntries.Add(proxyEntry);
}
return(generatedProxyEntries);
}
public void Setup()
{
ProxyBuildHelper = new ProxyBuilderHelper(new ProxySettings());
}
