public void NiceLinq_nice()
{
var client = new NativeWifi.WlanClient();
System.Diagnostics.Debug.WriteLine("GetWifiInfo : " + client);
Assert.IsTrue(client.Interfaces.Count() > 0);
var things =
from wlanIface in client.Interfaces
from bssentry in wlanIface.GetNetworkBssList()
from network in wlanIface.GetAvailableNetworkList(NativeWifi.Wlan.WlanGetAvailableNetworkFlags.IncludeAllAdhocProfiles)
where InterfaceService.GetStringForSSID(network.dot11Ssid) == InterfaceService.GetStringForSSID(bssentry.dot11Ssid)
select new
{
bssentry = InterfaceService.GetStringForSSID(bssentry.dot11Ssid),
channel = Wifi.FrequencyChannelMap[bssentry.chCenterFrequency],
frequency = bssentry.chCenterFrequency,
strength = bssentry.rssi,
signalQuality = network.wlanSignalQuality,
WifiType = network.dot11BssType,
};
Assert.IsTrue(things.Count() > 0);
foreach (var item in things)
{
Console.WriteLine("bssentry {0} channel {1} freq {2} strength {4} wifitype {3}", item.bssentry,
item.channel,
item.frequency,
item.WifiType,
item.signalQuality
);
}
}
public static void CreerApplicationInterface(XmlDocument doc, XmlNamespaceManager nsmgr, string path, string nomProjet)
{
var subFolder = path + "\\" + "Application.Interface";
Directory.CreateDirectory(subFolder);
var objetPresentationFolder = subFolder + "\\" + "ObjetsPresentation";
Directory.CreateDirectory(objetPresentationFolder);
foreach (MethodeObjetPresentation o in ObjetPresentation.ObjetsPresentation(doc, nsmgr).Methodes)
{
string chemin = objetPresentationFolder + "\\" + o.Nom.Trim() + ".cs";
FileStream stream = new FileStream(chemin, FileMode.Append, FileAccess.Write);
StreamWriter writer = new StreamWriter(stream);
using (writer)
writer.WriteLine(" namespace" + " " + nomProjet + ".Application.Interface.ObjetsPresentation" + "\r\n" + "{");
writer.WriteLine(o.ToString());
writer.WriteLine("}");
writer.Close();
}
var interfaceServiceFolder = subFolder + "\\" + "InterfacesServices";
Directory.CreateDirectory(interfaceServiceFolder);
foreach (InterfaceService i in InterfaceService.InterfacesService(doc, nsmgr))
{
string chemin = interfaceServiceFolder + "\\" + i.Nom.Trim() + ".cs";
FileStream stream = new FileStream(chemin, FileMode.Append, FileAccess.Write);
StreamWriter writer = new StreamWriter(stream);
using (writer)
writer.WriteLine(" namespace" + " " + nomProjet + ".Application.Interface.InterfacesServices" + "\r\n" + "{");
writer.WriteLine(i.ToString());
writer.WriteLine("}");
writer.Close();
}
}
public TestResolveFromConstructor(
IEnumerable <ClassService> classServices,
InterfaceService interfaceService)
{
ClassServices = classServices;
InterfaceService = interfaceService;
}
public TestResolveFromConstructor(
IEnumerable <ClassService> classServices,
InterfaceService interfaceService,
bool testResolveFailed)
{
ClassServices = classServices;
InterfaceService = interfaceService;
TestResolveFailed = testResolveFailed;
}
private void Configure()
{
IWeaponController weaponController = InterfaceService.GetInterface <IWeaponController>();
ITargetController targetController = InterfaceService.GetInterface <ITargetController>();
IGameController gameController = InterfaceService.GetInterface <IGameController>();
IScoreUIController scoreUIController = InterfaceService.GetInterface <IScoreUIController>();
weaponController.Initialize(_gameControllerSettings.WeaponSettings, _weaponPoolService);
targetController.Initialize(_gameControllerSettings.TargetSettings);
scoreUIController.Initialize(_scoreUIControllerSettings, _uiPoolService);
gameController.Initialize(_gameControllerSettings);
}
public override bool Execute()
{
InitializeServices();
var apiControllers = TypeService.GetControllers(Config.WebApiModuleFileName);
var endpointBlock = EndpointsService.CreateEndpointBlock();
var serviceBlock = AngularEndpointsService.CreateServiceBlock();
StartAnalysis("controllers and actions");
foreach (var apiController in apiControllers)
{
var webApiController = new WebApiController(apiController);
EndpointsService.WriteEndpointClassToBlock(endpointBlock, webApiController);
AngularEndpointsService.WriteServiceObjectToBlock(serviceBlock.Children.First() as TypeScriptBlock, webApiController);
}
StopAnalysis();
CreateFileForBlock(endpointBlock, Config.EndpointsOutputDirectory, Config.EndpointsFileName);
CreateFileForBlock(serviceBlock, Config.ServiceOutputDirectory, Config.ServiceFileName);
var enumsBlock = EnumsService.CreateEnumsBlock();
var interfacesBlock = InterfaceService.CreateInterfacesBlock();
if (Config.GenerateInterfaces)
{
StartAnalysis("interfaces");
InterfaceService.AddMatchingInterfaces();
InterfaceService.WriteInterfacesToBlock(interfacesBlock);
StopAnalysis();
CreateFileForBlock(interfacesBlock, Config.InterfacesOutputDirectory, Config.InterfacesFileName);
}
if (Config.GenerateEnums)
{
StartAnalysis("enumerations");
EnumsService.WriteEnumsToBlock(enumsBlock);
StopAnalysis();
CreateFileForBlock(enumsBlock, Config.EnumsOutputDirectory, Config.EnumsFileName);
}
return(true);
}
private void InitializeServices()
{
Config = GetConfig(ConfigFilePath);
TypeService = new TypeService();
TypeService.LoadAllTypes(Config.WebApiModuleFileName);
EnumsService = new EnumsService();
InterfaceService = new InterfaceService();
EndpointsService = new EndpointsService();
AngularEndpointsService = new AngularEndpointsService();
}
private void InitializeServices()
{
Config = GetConfig(ConfigFilePath);
TypeService = new TypeService();
LoadAllTypes();
EnumsService = new EnumsService();
InterfaceService = new InterfaceService();
EndpointsService = new EndpointsService();
MobileEndpointsService = new MobileEndpointsService();
AngularEndpointsService = new AngularEndpointsService();
ViewsService = new ViewsService();
ResourceService = new ResourceService();
}
public TestResolveFromConstructor(
IEnumerable <ClassService> classServices,
Lazy <IEnumerable <ClassService> > classServicesLazy,
IList <ClassService> classServicesList,
InterfaceService interfaceService,
Lazy <InterfaceService> interfaceServiceLazy,
Func <InterfaceService> interfaceServiceFunc,
string testDefaultString = "default string",
int testDefaultInt = 123)
{
ClassServices = classServices;
ClassServicesLazy = classServicesLazy;
ClassServicesList = classServicesList;
InterfaceService = interfaceService;
InterfaceServiceLazy = interfaceServiceLazy;
InterfaceServiceFunc = interfaceServiceFunc;
TestDefaultString = testDefaultString;
TestDefaultInt = testDefaultInt;
}
static void Main(string[] args)
{
InterfaceData interfaceData = new InterfaceData("Pattern", "IBuilder");
Method m = new Method("string", "metoda");
Parameter p = new Parameter("string", "test");
m.Parameters.Add(p);
interfaceData.Methods.Add(m);
string resultText = InterfaceService.GenerateInterfaceCode(interfaceData);
Console.WriteLine(resultText);
Console.ReadKey();
ClassData classData = new ClassData("Pattern", "IBuilder", "baseClass");
Method mc = new Method("string", "metoda", "public");
Parameter pc = new Parameter("string", "test", "public");
mc.Parameters.Add(pc);
classData.Methods.Add(mc);
classData.Parameters.Add(pc);
classData.Parameters.Add(pc);
string resultTextc = ClassService.GenerateClassCode(classData);
}
public override bool Execute()
{
InitializeServices();
var apiControllers = Config.WebApiModuleFileNames
.SelectMany(f => TypeService.GetControllers(f))
.ToArray();
if (Config.GenerateViews)
{
StartAnalysis("views");
foreach (var viewsBlock in ViewsService.GetBlocksForViews())
{
CreateFileForBlock(viewsBlock.TypeScriptBlock, Config.ViewsOutputDirectory, viewsBlock.Filename);
}
StopAnalysis();
}
if (Config.GenerateResources)
{
StartAnalysis("resources");
foreach (var resourceBlock in ResourceService.GetBlocksForResources())
{
CreateFileForBlock(resourceBlock.TypeScriptBlock, Config.ResourcesOutputDirectory, resourceBlock.Filename);
}
StopAnalysis();
}
if (Config.GenerateEndpoints || Config.GenerateService)
{
StartAnalysis("controllers and actions");
var endpointBlock = EndpointsService.CreateEndpointBlock();
var mobileEndpointBlock = MobileEndpointsService.CreateEndpointBlock();
var serviceBlock = AngularEndpointsService.CreateServiceBlock();
foreach (var apiController in apiControllers)
{
var webApiController = new WebApiController(apiController);
if (Config.GenerateEndpoints || Config.GenerateService)
{
EndpointsService.WriteEndpointClassToBlock(endpointBlock, webApiController);
}
if (Config.GenerateMobileEndpoints && webApiController.Actions.Any(a => a.IsMobileAction))
{
MobileEndpointsService.WriteEndpointClassToBlock(mobileEndpointBlock, webApiController);
}
if (Config.GenerateService)
{
var classBlock = serviceBlock.Children
.OfType <TypeScriptBlock>()
.First();
AngularEndpointsService.WriteServiceObjectToBlock(classBlock, webApiController);
}
}
if (Config.GenerateEndpoints || Config.GenerateService)
{
CreateFileForBlock(endpointBlock, Config.EndpointsOutputDirectory, Config.EndpointsFileName);
}
if (Config.GenerateMobileEndpoints)
{
CreateFileForBlock(mobileEndpointBlock, Config.MobileEndpointsOutputDirectory, Config.MobileEndpointsFileName);
}
if (Config.GenerateService)
{
CreateFileForBlock(serviceBlock, Config.ServiceOutputDirectory, Config.ServiceFileName);
}
StopAnalysis();
}
if (Config.GenerateInterfaces)
{
StartAnalysis("interfaces");
var interfacesBlock = InterfaceService.CreateInterfacesBlock();
InterfaceService.AddMatchingInterfaces();
InterfaceService.WriteInterfacesToBlock(interfacesBlock);
StopAnalysis();
CreateFileForBlock(interfacesBlock, Config.InterfacesOutputDirectory, Config.InterfacesFileName);
}
if (Config.GenerateEnums)
{
StartAnalysis("enumerations");
var enumsBlock = EnumsService.CreateEnumsBlock();
EnumsService.AddMatchingEnums();
EnumsService.WriteEnumsToBlock(enumsBlock);
StopAnalysis();
CreateFileForBlock(enumsBlock, Config.EnumsOutputDirectory, Config.EnumsFileName);
}
WriteServiceLogMessages();
return(true);
}
public CowController()
{
interfaceService = new InterfaceService();
}
private void Awake()
{
_gameControllerSettings = InterfaceService.GetInterface <IGameController>().Settings;
}
protected override void Initialize(HttpControllerContext controllerContext)
{
service = InterfaceService.GetInstance(controllerContext.Request.Properties);
base.Initialize(controllerContext);
}
public TypeScriptType GetTypeScriptType(TypeReference cSharpType, string parameterName, Func <string, string, TypeMapping> getTypeMapping)
{
var result = new TypeScriptType();
var type = cSharpType;
var typeName = type.FullName;
var typeMapping = getTypeMapping(parameterName, cSharpType.FullName);
if (typeMapping != null)
{
var tsTypeName = typeMapping.TypeScriptTypeName;
result.TypeName = tsTypeName;
result.InterfaceName = tsTypeName;
result.IsPrimitive = TypeService.IsPrimitiveTypeScriptType(result.TypeName);
result.IsEnum = tsTypeName.StartsWith($"{Config.EnumsNamespace}") ||
result.IsPrimitive;
return(result);
}
typeName = TypeService.StripNullable(type) ?? typeName;
var collectionType = TypeService.StripCollection(type);
result.IsCollection = collectionType != null;
typeName = collectionType ?? typeName;
var typeDefinition = TypeService.GetTypeDefinition(typeName);
if (typeDefinition?.IsEnum ?? false)
{
if (!Config.GenerateEnums)
{
result.TypeName = "number";
result.InterfaceName = "number";
result.IsPrimitive = true;
}
else
{
EnumsService.AddEnum(typeDefinition);
result.TypeName = $"{Config.EnumsNamespace}.{typeDefinition.Name}";
result.InterfaceName = $"{Config.EnumsNamespace}.{typeDefinition.Name}";
result.IsPrimitive = false;
}
result.IsEnum = true;
return(result);
}
var primitiveType = TypeService.GetPrimitiveTypeScriptType(typeName);
if (!string.IsNullOrEmpty(primitiveType))
{
result.TypeName = primitiveType;
result.InterfaceName = primitiveType;
result.IsPrimitive = true;
return(result);
}
if (!typeDefinition?.IsValueType ?? false)
{
if (!Config.GenerateInterfaces)
{
result.TypeName = $"{WebApiToTypeScript.IHaveQueryParams}";
result.InterfaceName = "any";
}
else
{
InterfaceService.AddInterfaceNode(typeDefinition);
result.TypeName = $"{Config.InterfacesNamespace}.{typeDefinition.Name}";
result.InterfaceName = $"{Config.InterfacesNamespace}.I{typeDefinition.Name}";
}
return(result);
}
throw new NotSupportedException("Maybe it is a generic class, or a yet unsupported collection, or chain thereof?");
}
public HomeController()
{
interfaceService = new InterfaceService();
}
