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());
}
