public void Add_AddAvailableValueShouldBeSuccessful() { var builder = new ParameterBuilder <Npgsql.NpgsqlParameter>(); builder.Add("@value", "value"); Assert.True(builder.Build().Count() == 1); Assert.Equal("@value", builder.Build().First().ParameterName); Assert.Equal("value", builder.Build().First().Value); }
public void Should_AbleToSetOneParameterWithBuilder() { var pBuilder = new ParameterBuilder().Name("name").In(ParameterIn.Query); var pathItem = new PathItemBuilder(HttpMethod.Get) .Parameter(pBuilder) .Build(); Assert.Single(pathItem.Parameters); Assert.Equal(pBuilder.Build().Name, pathItem.Parameters.FirstOrDefault().Name); Assert.Equal(pBuilder.Build().In, pathItem.Parameters.FirstOrDefault().In); }
public static void ProcessParameterizedHost(ServiceClient serviceClient, Settings settings) { if (serviceClient == null) { throw new ArgumentNullException("serviceClient"); } if (settings == null) { throw new ArgumentNullException("settings"); } if (serviceClient.Extensions.ContainsKey(ParameterizedHostExtension) && !hostChecked) { SwaggerModeler modeler = new SwaggerModeler(settings); modeler.Build(); var hostExtension = serviceClient.Extensions[ParameterizedHostExtension] as JObject; if (hostExtension != null) { var hostTemplate = (string)hostExtension["hostTemplate"]; var parametersJson = hostExtension["parameters"].ToString(); if (!string.IsNullOrEmpty(parametersJson)) { var jsonSettings = new JsonSerializerSettings { TypeNameHandling = TypeNameHandling.None, MetadataPropertyHandling = MetadataPropertyHandling.Ignore }; var swaggerParams = JsonConvert.DeserializeObject <List <SwaggerParameter> >(parametersJson, jsonSettings); foreach (var swaggerParameter in swaggerParams) { // Build parameter var parameterBuilder = new ParameterBuilder(swaggerParameter, modeler); var parameter = parameterBuilder.Build(); // check to see if the parameter exists in properties, and needs to have its name normalized if (serviceClient.Properties.Any(p => p.SerializedName.Equals(parameter.SerializedName))) { parameter.ClientProperty = serviceClient.Properties.Single(p => p.SerializedName.Equals(parameter.SerializedName)); } parameter.Extensions["hostParameter"] = true; foreach (var method in serviceClient.Methods) { method.Parameters.Add(parameter); } } serviceClient.BaseUrl = string.Format(CultureInfo.InvariantCulture, "{0}://{1}{2}", modeler.ServiceDefinition.Schemes[0].ToString().ToLowerInvariant(), hostTemplate, modeler.ServiceDefinition.BasePath); } } } hostChecked = true; }
/// <summary> /// Register parameter for the command /// </summary> /// <param name="buildParameter">Action to configure flag using builder</param> /// <returns>Self instance</returns> public CommandConfigurator RegisterParameter <T>(Action <ParameterBuilder <T> > buildParameter) { var parameterBuilder = new ParameterBuilder <T>(); buildParameter(parameterBuilder); return(RegisterParameterInstance <T>(parameterBuilder.Build())); }
public void Should_AbleToSetParameterWithBuilder() { var parameter = new ParameterBuilder().Name("para").In(ParameterIn.Query); var swaggerRoot = GetBasicSwaggerRootBuilder().Parameter(parameter).Build(); Assert.True(swaggerRoot.Parameters.ContainsKey(parameter.Build().Name)); }
public void TestWIthType() { var builder = new ParameterBuilder(); builder.WithType("FooBar"); var result = builder.Build(); Assert.AreEqual("FooBar", result.Type); }
public unsafe void UpdateNative(IntPtr env, IntPtr clazz) { UpdateSensors(); foreach (var pair in sensorObjects) { ParameterBuilder builder = new ParameterBuilder().AddFloat(pair.Value.Value.Value); // // Populate the sensor object JavaMethod setValueMethod = jvm.GetMethod(SENSOR_REQUEST_CLASS_PATH, SENSOR_REQUEST_SET_VALUE_FUNCTION, builder.GetParameterString()); jvm.CallVoidMethod(pair.Key, setValueMethod, builder.Build()); } }
public override object Execute(Expression expression) { Logger.Log($"Executing expression '{expression}'. Strict: {strict}"); var parameterBuilder = new ParameterBuilder <TObject>(queryHelper, strict); //Validate that every tree node is supported var supportedTree = SupportedExpressionValidator.Validate(expression); //Replace variable and method references with their calculated values var evaluatedTree = PartialEvaluate(supportedTree); //Replace all expressions that correspond to LINQ methods with LinqExpression objects var linqTree = LinqQueryBuilder <TObject> .Parse(evaluatedTree, strict); //Merge sequential method calls together into a single statement (e.g. Where(A).Where(B) => Where(A && B)) var mergedTree = LinqQueryMerger.Parse(linqTree, strict); //Extract the Parameter details from each LinqExpression, replacing processed expressions with their TSource var legalTree = parameterBuilder.Build(mergedTree); //Construct the parameter objects required to execute all of the required requests var parameterSets = GetParameters(parameterBuilder); //Filter out server side only expressions so we don't execute them twice (such as Skip) var clientTree = ClientTreeBuilder.Parse(linqTree); //Convert the query to LINQ to Objects var enumerableTree = RewriteEnumerable(clientTree, parameterSets); var getResults = Expression.Lambda(enumerableTree).Compile(); if (getResults.Method.ReturnType.IsValueType) { try { return(getResults.DynamicInvoke()); } catch (TargetInvocationException ex) { throw ex.InnerException; } } return(((Func <object>)getResults)()); }
public static void ProcessParameterizedHost(CodeModel codeModel) { using (NewContext) { if (codeModel == null) { throw new ArgumentNullException("codeModel"); } if (codeModel.Extensions.ContainsKey(ParameterizedHostExtension) && !hostChecked) { SwaggerModeler modeler = new SwaggerModeler(); modeler.Build(); var hostExtension = codeModel.Extensions[ParameterizedHostExtension] as JObject; if (hostExtension != null) { var hostTemplate = (string)hostExtension["hostTemplate"]; var parametersJson = hostExtension["parameters"].ToString(); var useSchemePrefix = true; if (hostExtension[UseSchemePrefix] != null) { useSchemePrefix = bool.Parse(hostExtension[UseSchemePrefix].ToString()); } var position = "first"; if (hostExtension[PositionInOperation] != null) { var pat = "^(fir|la)st$"; Regex r = new Regex(pat, RegexOptions.IgnoreCase); var text = hostExtension[PositionInOperation].ToString(); Match m = r.Match(text); if (!m.Success) { throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, Resources.InvalidExtensionProperty, text, PositionInOperation, ParameterizedHostExtension, "first, last")); } position = text; } if (!string.IsNullOrEmpty(parametersJson)) { var jsonSettings = new JsonSerializerSettings { TypeNameHandling = TypeNameHandling.None, MetadataPropertyHandling = MetadataPropertyHandling.Ignore }; var swaggerParams = JsonConvert.DeserializeObject <List <SwaggerParameter> >(parametersJson, jsonSettings); List <Parameter> hostParamList = new List <Parameter>(); foreach (var swaggerParameter in swaggerParams) { // Build parameter var parameterBuilder = new ParameterBuilder(swaggerParameter, modeler); var parameter = parameterBuilder.Build(); // check to see if the parameter exists in properties, and needs to have its name normalized if (codeModel.Properties.Any(p => p.SerializedName.EqualsIgnoreCase(parameter.SerializedName))) { parameter.ClientProperty = codeModel.Properties.Single( p => p.SerializedName.Equals(parameter.SerializedName)); } parameter.Extensions["hostParameter"] = true; hostParamList.Add(parameter); } foreach (var method in codeModel.Methods) { if (position.EqualsIgnoreCase("first")) { method.InsertRange(((IEnumerable <Parameter>)hostParamList).Reverse()); } else { method.AddRange(hostParamList); } } if (useSchemePrefix) { codeModel.BaseUrl = string.Format(CultureInfo.InvariantCulture, "{0}://{1}{2}", modeler.ServiceDefinition.Schemes[0].ToString().ToLowerInvariant(), hostTemplate, modeler.ServiceDefinition.BasePath); } else { codeModel.BaseUrl = string.Format(CultureInfo.InvariantCulture, "{0}{1}", hostTemplate, modeler.ServiceDefinition.BasePath); } } } } } hostChecked = true; }
/// <summary> /// Add a parameter for this operation /// </summary> /// <param name="parameter"> /// The parameter. /// </param> /// <returns> /// The <see cref="PathItemBuilder"/>. /// </returns> public PathItemBuilder Parameter(ParameterBuilder parameter) { return this.Parameter(parameter.Build()); }
public unsafe void NativeAddSensors(IntPtr env, IntPtr clazz) { // Attach to the current thread in order to work correctly jvm.AttachCurrentThread(); for (int i = 0; i < computer.Hardware.Length; i++) { IHardware hardware = computer.Hardware[i]; for (int j = 0; j < hardware.Sensors.Length; j++) { ISensor sensor = hardware.Sensors[j]; ParameterBuilder builder = new ParameterBuilder().AddInt(idCount++).AddString(jvm, sensor.Name). AddFloat(sensor.Max.Value).AddByte(getSensorType(sensor)).AddString(jvm, sensor.Hardware.Name). AddFloat(sensor.Value.Value); // Construct sensor request object with parameters IntPtr sensorObjectParam = jvm.CreateObject(SENSOR_REQUEST_CLASS_PATH, builder.GetParameterString(), builder.Build()); sensorObjects.Add(sensorObjectParam, sensor); } } }
public void Should_ThrowRequiredFieldException_WhenNameIsNotSet() { Assert.Throws <RequiredFieldException>(() => builder.Build()); }
/// <summary> /// Add a parameter for this operation /// </summary> /// <param name="parameter"> /// The parameter. /// </param> /// <returns> /// The <see cref="OperationBuilder"/>. /// </returns> public OperationBuilder Parameter(Action<ParameterBuilder> parameter) { var builder = new ParameterBuilder(); parameter(builder); return this.Parameter(builder.Build()); }