public static NetworkNodeAddress CreateAsRoot(string scheme, NetworkNodeAddress modelAddress, bool exposeAsNonComplexAddress) { var upperLayerUri = StringUriUtils.Combine(modelAddress.InnerUri, modelAddress.AbsolutePath); var address = new NetworkNodeAddress(scheme, modelAddress.UserName, modelAddress.Password, modelAddress.ServerName, modelAddress.Port, upperLayerUri, "", "/", "", exposeAsNonComplexAddress); return(address); }
public override ServiceModel Reflect() { var descriptions = configuration.Services.GetApiExplorer().ApiDescriptions.AsEnumerable() .Where(c => !c.ActionDescriptor.GetCustomAttributes <FickleExcludeAttribute>().Any()) .ToList(); if (this.options.ControllersTypesToIgnore != null) { descriptions = descriptions.Where(x => !this.options.ControllersTypesToIgnore.Contains(x.ActionDescriptor.ControllerDescriptor.ControllerType)).ToList(); } bool secureByDefault = false; var enums = new List <ServiceEnum>(); var classes = new List <ServiceClass>(); var gateways = new List <ServiceGateway>(); var referencedTypes = GetReferencedTypes(descriptions).ToList(); var controllers = descriptions.Select(c => c.ActionDescriptor.ControllerDescriptor).ToHashSet(); var serviceModelInfo = new ServiceModelInfo(); foreach (var enumType in referencedTypes.Where(c => c.BaseType == typeof(Enum))) { var serviceEnum = new ServiceEnum { Name = GetTypeName(enumType), Values = Enum.GetNames(enumType).Select(c => new ServiceEnumValue { Name = c, Value = Convert.ToInt64(Enum.Parse(enumType, c)) }).ToList() }; enums.Add(serviceEnum); } foreach (var type in referencedTypes .Where(TypeSystem.IsNotPrimitiveType) .Where(c => c.BaseType != typeof(Enum)) .Where(c => !c.IsInterface) .Where(c => !typeof(IList <>).IsAssignableFromIgnoreGenericParameters(c))) { var baseTypeName = GetTypeName(type.BaseType); var properties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly) .Where(c => !c.GetCustomAttributes <FickleExcludeAttribute>().Any()) .Select(c => new ServiceProperty { Name = c.Name, TypeName = GetTypeName(c.PropertyType) }).ToList(); var serviceClass = new ServiceClass { Name = GetTypeName(type), BaseTypeName = baseTypeName, Properties = properties }; classes.Add(serviceClass); } var allowedMethods = new HashSet <string>(new[] { "GET", "POST" }, StringComparer.InvariantCultureIgnoreCase); foreach (var controller in controllers) { var methods = new List <ServiceMethod>(); secureByDefault = this.referencingAssembly.GetCustomAttributes <FickleSecureAttribute>()?.FirstOrDefault()?.Secure ?? false; var controllerSecureByDefault = controller.GetCustomAttributes <FickleSecureAttribute>(true)?.FirstOrDefault()?.Secure ?? secureByDefault; var serviceNameSuffix = "Service"; var attribute = this.referencingAssembly.GetCustomAttribute <FickleSdkInfoAttribute>(); if (attribute != null) { serviceNameSuffix = attribute.ServiceNameSuffix ?? serviceNameSuffix; serviceModelInfo.Name = attribute.Name ?? serviceModelInfo.Name; serviceModelInfo.Summary = attribute.Summary ?? serviceModelInfo.Summary; serviceModelInfo.Author = attribute.Author ?? serviceModelInfo.Author; serviceModelInfo.Version = attribute.Version ?? serviceModelInfo.Version; } foreach (var api in descriptions .Where(c => c.ActionDescriptor.ControllerDescriptor == controller && allowedMethods.Contains(c.HttpMethod.Method))) { var formatters = api.ActionDescriptor.ControllerDescriptor.Configuration.Formatters; var returnType = api.ResponseDescription.ResponseType ?? api.ResponseDescription.DeclaredType; if (!formatters.Any(c => c is JsonMediaTypeFormatter)) { returnType = typeof(string); } var parameters = api.ParameterDescriptions.Select(d => new ServiceParameter { Name = d.ParameterDescriptor.ParameterName, TypeName = GetTypeName(d.ParameterDescriptor.ParameterType) }).ToList(); ServiceParameter contentServiceParameter = null; var contentParameter = api.ParameterDescriptions.SingleOrDefault(c => c.Source == ApiParameterSource.FromBody); var uniqueNameMaker = new UniqueNameMaker(c => api.ParameterDescriptions.Any(d => d.Name.EqualsIgnoreCase(c))); if (contentParameter == null && api.HttpMethod.Method.EqualsIgnoreCaseInvariant("POST") && api.ActionDescriptor.GetCustomAttributes <NoBodyAttribute>().Count == 0) { contentServiceParameter = new ServiceParameter { Name = uniqueNameMaker.Make("content"), TypeName = GetTypeName(typeof(byte[])) }; parameters.Add(contentServiceParameter); } else if (contentParameter != null) { contentServiceParameter = new ServiceParameter { Name = contentParameter.Name, TypeName = GetTypeName(contentParameter.ParameterDescriptor.ParameterType) }; } var serviceMethod = new ServiceMethod { Authenticated = api.ActionDescriptor.GetCustomAttributes <AuthorizeAttribute>(true).Count > 0, Secure = api.ActionDescriptor.GetCustomAttributes <FickleSecureAttribute>(true)?.FirstOrDefault()?.Secure ?? controllerSecureByDefault, Name = api.ActionDescriptor.ActionName, Path = StringUriUtils.Combine(this.configuration.VirtualPathRoot, api.RelativePath), Returns = GetTypeName(returnType), ReturnFormat = "json", Method = api.HttpMethod.Method.ToLower(), Parameters = parameters }; if (contentServiceParameter != null) { serviceMethod.Content = contentServiceParameter.Name; serviceMethod.ContentServiceParameter = contentServiceParameter; } methods.Add(serviceMethod); } var serviceGateway = new ServiceGateway { BaseTypeName = null, Name = controller.ControllerName + serviceNameSuffix, Hostname = hostname, Methods = methods }; gateways.Add(serviceGateway); } return(new ServiceModel(serviceModelInfo, enums, classes, gateways)); }
public static LocalNodeAddress Parse(string uri) { Group group; Match match = null; string root, scheme, query; // Often Parse will be called with the exact same URI reference that was last passed // to CanParse. If this is the case then use the results cached by the last call to // CanParse from this thread. if ((object)uri == (object)lastCanParseUri) { match = lastCanParseMatch; } while (true) { if (match == null) { match = localFileNameRegEx.Match(uri); } if (!match.Success) { throw new MalformedUriException(uri); } bool schemeExplicitlyProvided; group = match.Groups["scheme"]; if (group.Value == "") { scheme = "file"; schemeExplicitlyProvided = false; } else { scheme = group.Value; schemeExplicitlyProvided = true; } group = match.Groups["uncserver"]; if (group.Success) { string path; Pair <string, string> result; path = match.Groups["path1"].Value; result = path.SplitAroundCharFromLeft(1, PredicateUtils.ObjectEqualsAny('\\', '/')); root = "//" + group.Value + result.Left.Replace('\\', '/'); path = "/" + result.Right; if (path == "") { path = "/"; } query = match.Groups["query"].Value; return(new LocalNodeAddress(scheme, root, true, StringUriUtils.NormalizePath(path), query)); } else { string path; group = match.Groups["root"]; if (group.Captures.Count > 0) { // // Windows path specification // root = group.Value; path = match.Groups["path2"].Value; if (path.Length == 0) { path = FileSystemManager.SeperatorString; } query = match.Groups["query"].Value; path = StringUriUtils.NormalizePath(path); if (schemeExplicitlyProvided) { // // Explicitly provided scheme means // special characters are hexcoded // path = TextConversion.FromEscapedHexString(path); query = TextConversion.FromEscapedHexString(query); } return(new LocalNodeAddress(scheme, root, true, path, query)); } else if (match.Groups["path3"].Value != "") { // // Unix path specification // path = match.Groups["path3"].Value; query = match.Groups["query"].Value; path = StringUriUtils.NormalizePath(path); if (schemeExplicitlyProvided) { // // Explicitly provided scheme means // special characters are hexcoded // path = TextConversion.FromEscapedHexString(path); query = TextConversion.FromEscapedHexString(query); } return(new LocalNodeAddress(scheme, "", true, path, query)); } else { // // Relative path specification // path = match.Groups["path4"].Value; query = match.Groups["query"].Value; path = StringUriUtils.Combine(Environment.CurrentDirectory, path); path = StringUriUtils.NormalizePath(path); if (!string.IsNullOrEmpty(query)) { query = "?" + query; } else { query = ""; } if (schemeExplicitlyProvided) { uri = scheme + "://" + path + "query"; } else { uri = path + query; } match = null; } } } }
protected Expression CreateGatewayCallMethod(MethodDefinitionExpression method, out ParameterExpression optionsParameter) { var methodName = method.Name.ToCamelCase(); methodCount++; var self = Expression.Variable(currentType, "self"); var hostname = Expression.Variable(typeof(string), "hostname"); var port = Expression.Variable(typeof(string), "port"); var protocol = Expression.Variable(typeof(string), "protocol"); var optionsParam = FickleExpression.Parameter("NSDictionary", "options"); var localOptions = FickleExpression.Variable("NSMutableDictionary", "localOptions"); var requestObject = FickleExpression.Variable("NSObject", "requestObject"); var requestObjectValue = (Expression)Expression.Constant(null, typeof(object)); var url = Expression.Variable(typeof(string), "url"); var responseType = ObjectiveBinderHelpers.GetWrappedResponseType(this.CodeGenerationContext, method.ReturnType); var variables = new [] { url, localOptions, protocol, hostname, requestObject, port }; var declaredHostname = currentTypeDefinitionExpression.Attributes["Hostname"]; var declaredPath = method.Attributes["Path"]; var path = StringUriUtils.Combine("%@://%@%@", declaredPath); var httpMethod = method.Attributes["Method"]; var declaredProtocol = Convert.ToBoolean(method.Attributes["Secure"]) ? "https" : "http"; var retryBlockVariable = Expression.Variable(new FickleDelegateType(typeof(void), new FickleParameterInfo(FickleType.Define("id"), "block")), "retryBlock"); var retryBlockParameter = Expression.Variable(FickleType.Define("id"), "block"); var parametersByName = method.Parameters.ToDictionary(c => ((ParameterExpression)c).Name, c => (ParameterExpression)c, StringComparer.InvariantCultureIgnoreCase); var formatInfo = ObjectiveStringFormatInfo.GetObjectiveStringFormatInfo(path, c => parametersByName[c]); var args = formatInfo.ValueExpressions; var parameters = formatInfo.ParameterExpressions; var parameterInfos = new List <FickleParameterInfo> { new ObjectiveParameterInfo(typeof(string), "s"), new ObjectiveParameterInfo(typeof(string), "protocol", true), new ObjectiveParameterInfo(typeof(string), "hostname", true), new ObjectiveParameterInfo(typeof(string), "port", true), }; parameterInfos.AddRange(parameters.Select(c => new ObjectiveParameterInfo(c.Type, c.Name, true))); var methodInfo = new FickleMethodInfo(typeof(string), typeof(string), "stringWithFormat", parameterInfos.ToArray(), true); args.InsertRange(0, new Expression[] { Expression.Constant(formatInfo.Format), protocol, hostname, port }); var newParameters = new List <Expression>(method.Parameters) { optionsParam }; var callback = Expression.Parameter(new FickleDelegateType(typeof(void), new FickleParameterInfo(responseType, "response")), "callback"); newParameters.Add(callback); Expression blockArg = Expression.Parameter(FickleType.Define("id"), "arg1"); var returnType = method.ReturnType; if (ObjectiveBinderHelpers.NeedsValueResponseWrapper(method.ReturnType)) { returnType = FickleType.Define(ObjectiveBinderHelpers.GetValueResponseWrapperTypeName(method.ReturnType)); } var responseFilter = FickleExpression.Property(self, "FKGatewayResponseFilter", "responseFilter"); var conversion = Expression.Convert(blockArg, returnType); var innerRetryBlockBody = FickleExpression.Block ( FickleExpression.Call(Expression.Convert(retryBlockParameter, retryBlockVariable.Type), typeof(void), "Invoke", new { block = retryBlockParameter }).ToStatement() ); var innerRetryBlock = (Expression)FickleExpression.SimpleLambda ( typeof(void), innerRetryBlockBody, new Expression[0] ); var body = FickleExpression.GroupedWide ( Expression.IfThen(Expression.NotEqual(responseFilter, Expression.Constant(null, responseFilter.Type)), Expression.Assign(blockArg, FickleExpression.Call(responseFilter, typeof(object), "gateway", new { value = self, receivedResponse = blockArg, fromRequestURL = url, withRequestObject = requestObject, retryBlock = innerRetryBlock, andOptions = localOptions })).ToStatementBlock()), Expression.IfThen ( Expression.AndAlso(Expression.NotEqual(blockArg, Expression.Constant(null, blockArg.Type)), Expression.NotEqual(callback, Expression.Constant(null, callback.Type))), FickleExpression.Call(callback, "Invoke", conversion).ToStatementBlock() ) ); var conversionBlock = FickleExpression.SimpleLambda(null, body, new Expression[0], blockArg); var error = FickleExpression.Variable("NSError", "error"); Expression parseResultBlock; var nsdataParam = Expression.Parameter(FickleType.Define("NSData"), "data"); var clientParam = Expression.Parameter(FickleType.Define("PKWebServiceClient"), "client"); var jsonObjectWithDataParameters = new[] { new FickleParameterInfo(FickleType.Define("NSDictionary"), "obj"), new FickleParameterInfo(typeof(int), "options"), new FickleParameterInfo(FickleType.Define("NSError", true), "error", true) }; var objectWithDataMethodInfo = new FickleMethodInfo(FickleType.Define("NSJSONSerialization"), FickleType.Define("NSData"), "JSONObjectWithData", jsonObjectWithDataParameters, true); var deserializedValue = Expression.Parameter(FickleType.Define("id"), "deserializedValue"); var parseErrorResult = FickleExpression.Call(self, "webServiceClient", new { clientParam, createErrorResponseWithErrorCode = "JsonDeserializationError", andMessage = FickleExpression.Call(error, "localizedDescription", null) }); if (method.ReturnType == typeof(void)) { var responseObject = FickleExpression.Variable(responseType, "responseObject"); parseResultBlock = FickleExpression.SimpleLambda ( FickleType.Define("id"), FickleExpression.GroupedWide ( Expression.Assign(responseObject, FickleExpression.New(responseType, "init", null)).ToStatement(), Expression.Assign(deserializedValue, Expression.Call(objectWithDataMethodInfo, nsdataParam, FickleExpression.Variable(typeof(int), "NSJSONReadingAllowFragments"), error)).ToStatement(), Expression.IfThen(Expression.Equal(deserializedValue, Expression.Constant(null)), FickleExpression.Return(parseErrorResult).ToStatementBlock()), FickleExpression.Return(responseObject).ToStatement() ), new Expression[] { deserializedValue, responseObject, error }, clientParam, nsdataParam ); } else if (TypeSystem.IsPrimitiveType(method.ReturnType) || method.ReturnType is FickleListType) { var responseObject = FickleExpression.Variable(responseType, "responseObject"); var needToBoxValue = ObjectiveBinderHelpers.ValueResponseValueNeedsBoxing(method.ReturnType); parseResultBlock = FickleExpression.SimpleLambda ( FickleType.Define("id"), FickleExpression.GroupedWide ( Expression.Assign(responseObject, FickleExpression.New(responseType, "init", null)).ToStatement(), Expression.Assign(deserializedValue, Expression.Call(objectWithDataMethodInfo, nsdataParam, FickleExpression.Variable(typeof(int), "NSJSONReadingAllowFragments"), error)).ToStatement(), Expression.IfThen(Expression.Equal(deserializedValue, Expression.Constant(null)), FickleExpression.Return(parseErrorResult).ToStatementBlock()), PropertiesFromDictionaryExpressonBinder.GetDeserializeExpressionProcessValueDeserializer(method.ReturnType, deserializedValue, c => FickleExpression.Call(responseObject, typeof(void), "setValue", needToBoxValue ? Expression.Convert(c, typeof(object)) : c).ToStatement()), FickleExpression.Return(responseObject).ToStatement() ), new Expression[] { deserializedValue, responseObject, error }, clientParam, nsdataParam ); } else { parseResultBlock = FickleExpression.SimpleLambda ( FickleType.Define("id"), FickleExpression.GroupedWide ( Expression.Assign(deserializedValue, Expression.Call(objectWithDataMethodInfo, nsdataParam, FickleExpression.Variable(typeof(int), "NSJSONReadingAllowFragments"), error)).ToStatement(), PropertiesFromDictionaryExpressonBinder.GetDeserializeExpressionProcessValueDeserializer(method.ReturnType, deserializedValue, c => FickleExpression.Return(c).ToStatement()), FickleExpression.Return(parseErrorResult).ToStatement() ), new Expression[] { deserializedValue, error }, clientParam, nsdataParam ); } var uniqueNameMaker = new UniqueNameMaker(c => newParameters.Cast <ParameterExpression>().Any(d => d.Name.EqualsIgnoreCaseInvariant(c))); var key = FickleExpression.Variable(typeof(string), uniqueNameMaker.Make("key")); var integrateOptions = FickleExpression.ForEach ( key, optionsParam, FickleExpression.Call(localOptions, typeof(void), "setObject", new { value = FickleExpression.Call(optionsParam, typeof(object), "objectForKey", key), forKey = key }).ToStatementBlock() ); parseResultBlock = FickleExpression.Call(parseResultBlock, parseResultBlock.Type, "copy", null); var client = Expression.Variable(FickleType.Define(this.CodeGenerationContext.Options.ServiceClientTypeName ?? "PKWebServiceClient"), "client"); Expression clientCallExpression; if (httpMethod.Equals("get", StringComparison.InvariantCultureIgnoreCase)) { clientCallExpression = FickleExpression.Call(client, "getWithCallback", conversionBlock); } else { var contentParameterName = method.Attributes["Content"]; var contentFormat = method.Attributes["ContentFormat"]; if (string.IsNullOrEmpty(contentParameterName)) { clientCallExpression = FickleExpression.Call(client, "postWithRequestObject", new { requestObject, andCallback = conversionBlock }); } else { var content = parametersByName[contentParameterName]; requestObjectValue = content.Type == typeof(byte[]) ? (Expression)content : FickleExpression.Call(self, typeof(object), this.GetNormalizeRequestMethodName(content.Type, contentFormat), new { serializeRequest = Expression.Convert(content, typeof(object)), paramName = Expression.Constant(contentParameterName) }); clientCallExpression = FickleExpression.Call(client, "postWithRequestObject", new { requestObject, andCallback = conversionBlock }); } } var retryBlock = (Expression)FickleExpression.SimpleLambda ( typeof(void), FickleExpression.StatementisedGroupedExpression ( Expression.Assign(client, FickleExpression.Call(Expression.Variable(currentType, "self"), "PKWebServiceClient", "createClientWithURL", new { url, options = localOptions })), Expression.Assign(FickleExpression.Property(client, currentType, "delegate"), self), clientCallExpression ), new Expression[] { client }, retryBlockParameter ); retryBlock = FickleExpression.Call(retryBlock, retryBlock.Type, "copy", null); var block = FickleExpression.Block ( variables.Concat(retryBlockVariable).ToArray(), Expression.Assign(requestObject, requestObjectValue), Expression.Assign(callback, FickleExpression.Call(callback, callback.Type, "copy", null)), Expression.Assign(localOptions, FickleExpression.Call(FickleExpression.Property(self, FickleType.Define("NSDictionary"), "options"), "NSMutableDictionary", "mutableCopyWithZone", new { zone = Expression.Constant(null, FickleType.Define("NSZone")) })), Expression.IfThen(Expression.NotEqual(requestObject, Expression.Constant(null)), FickleExpression.Call(localOptions, typeof(void), "setObject", new { value = requestObject, forKey = "$RequestObject" }).ToStatementBlock()), FickleExpression.Call(localOptions, typeof(void), "setObject", new { value = FickleExpression.StaticCall(responseType, "class", null), forKey = "$ResponseClass" }).ToStatement(), Expression.Assign(hostname, FickleExpression.Call(localOptions, typeof(string), "objectForKey", Expression.Constant("hostname"))), Expression.IfThen(Expression.Equal(hostname, Expression.Constant(null)), Expression.Assign(hostname, Expression.Constant(declaredHostname)).ToStatementBlock()), Expression.Assign(protocol, FickleExpression.Call(localOptions, typeof(string), "objectForKey", Expression.Constant("protocol"))), Expression.IfThen(Expression.Equal(protocol, Expression.Constant(null)), Expression.Assign(protocol, Expression.Constant(declaredProtocol)).ToStatementBlock()), Expression.Assign(port, FickleExpression.Call(FickleExpression.Call(localOptions, FickleType.Define("NSNumber"), "objectForKey", Expression.Constant("port")), typeof(string), "stringValue", null)), Expression.IfThenElse(Expression.Equal(port, Expression.Constant(null)), Expression.Assign(port, Expression.Constant("")).ToStatementBlock(), Expression.Assign(port, FickleExpression.Call(Expression.Constant(":"), typeof(string), "stringByAppendingString", port)).ToStatementBlock()), FickleExpression.Grouped ( FickleExpression.Call(localOptions, "setObject", new { obj = parseResultBlock, forKey = "$ParseResultBlock" }).ToStatement(), method.ReturnType.GetUnwrappedNullableType() == typeof(bool) ? FickleExpression.Call(localOptions, "setObject", new { obj = Expression.Convert(Expression.Constant(1), typeof(object)) }).ToStatement() : null ), Expression.Assign(url, Expression.Call(null, methodInfo, args)), FickleExpression.Call(localOptions, typeof(void), "setObject", new { value = url, forKey = "$RequestURL" }).ToStatement(), integrateOptions, Expression.Assign(retryBlockVariable, retryBlock), FickleExpression.Call(retryBlockVariable, typeof(void), "Invoke", retryBlockVariable).ToStatement() ); optionsParameter = optionsParam; return(new MethodDefinitionExpression(methodName, newParameters.ToReadOnlyCollection(), typeof(void), block, false, null)); }