public void MatchToObject_ExplicitDefaultArgument_SetsDefaultArgument()
{
DefaultParameters result = MatchToObject(new[] { "-DefaultProperty1", "foo" });
result.DefaultProperty1.Should().Be("foo");
result.DefaultProperty2.Should().BeNull();
}
public DefaultParameters GetDefaultParameterRecord(string recid, string UserID, string UserSNo)
{
DefaultParameters defaults = new DefaultParameters();
try
{
DataSet ds = new DataSet();
SqlParameter[] Parameters = { new SqlParameter("@UserID", Convert.ToInt32(UserSNo)) };
string[] tableNames = null;
SqlHelper.FillDataset(ReadConnectionString.WebConfigConnectionString, CommandType.StoredProcedure, "GetListSystemSettings", ds, tableNames, Parameters);
if (ds.Tables[0].Rows.Count > 0)
{
defaults.DefaultProductSNo = Convert.ToString(ds.Tables[0].Rows[0]["DefaultProductSNo"]);
defaults.DefaultProductName = Convert.ToString(ds.Tables[0].Rows[0]["DefaultProductName"]);
defaults.DefaultAirportSNo = Convert.ToString(ds.Tables[0].Rows[0]["DefaultAirportSNo"]);
defaults.DefaultAirportName = Convert.ToString(ds.Tables[0].Rows[0]["DefaultAirportName"]);
defaults.FWBTransfer = Convert.ToString(ds.Tables[0].Rows[0]["FWB Transfer"]);
defaults.FWBAmendmentTime = Convert.ToString(ds.Tables[0].Rows[0]["FWBAmendmentTime"]);
defaults.BOEVerification = Convert.ToString(ds.Tables[0].Rows[0]["BOEVerification"]);
defaults.FC_AirlineName = Convert.ToString(ds.Tables[0].Rows[0]["FC_AirlineName"]);
defaults.FC_AllowedCity = Convert.ToString(ds.Tables[0].Rows[0]["FC_AllowedCity"]);
defaults.IsCheckFlightOverBooking = Convert.ToString(ds.Tables[0].Rows[0]["IsCheckFlightOverBooking"]) == "0";
defaults.DefaultAirportCode = Convert.ToString(ds.Tables[0].Rows[0]["DefaultAirportCode"]);
defaults.DomesticBookingPeriod = Convert.ToString(ds.Tables[0].Rows[0]["DomesticBookingPeriod"]);
defaults.CMSDivisor = Convert.ToString(ds.Tables[0].Rows[0]["CMSDivisor"]);
defaults.INHDivisor = Convert.ToString(ds.Tables[0].Rows[0]["INHDivisor"]);
defaults.InternationalBookingPeriod = Convert.ToString(ds.Tables[0].Rows[0]["InternationalBookingPeriod"]);
defaults.FWBOnExecution = Convert.ToString(ds.Tables[0].Rows[0]["FWBOnExecution"]) == "0";
}
}
catch (Exception ex)// (Exception ex)
{
}
return(defaults);
}
public void TestAmbiguous()
{
var def = new DefaultParameters();
def.Foo(1, 2);
def.Bar();
}
private UrlSegmentParamsValues GetUrlSegmentParamsValues(IRestRequest request)
{
var assembled = BaseUrl == null ? "" : request.Resource;
var baseUrl = BaseUrl ?? new Uri(request.Resource);
var hasResource = !assembled.IsEmpty();
var parameters = request.Parameters.Where(p => p.Type == ParameterType.UrlSegment).ToList();
parameters.AddRange(DefaultParameters.Where(p => p.Type == ParameterType.UrlSegment));
var builder = new UriBuilder(baseUrl);
foreach (var parameter in parameters)
{
var paramPlaceHolder = String.Format("{{{0}}}", parameter.Name);
var paramValue = Encode(parameter.Value.ToString());
if (hasResource)
{
assembled = assembled.Replace(paramPlaceHolder, paramValue);
}
builder.Path = builder.Path.UrlDecode().Replace(paramPlaceHolder, paramValue);
}
return(new UrlSegmentParamsValues(builder.Uri, assembled));
}
public void MatchToObject_NoParameterNames_SetsDefaultArgumentsInOrder1()
{
DefaultParameters result = MatchToObject(new[] { "foo", "bar" });
result.DefaultProperty1.Should().Be("foo");
result.DefaultProperty2.Should().Be("bar");
}
public void MatchToObject_MixingImplicitDefaultArgumentsWithExplicit_MatchesDefaultArgument1()
{
DefaultParameters result = MatchToObject(new[] { "foo", "-DefaultProperty2", "bar" });
result.DefaultProperty1.Should().Be("foo");
result.DefaultProperty2.Should().Be("bar");
}
public void Load(JToken token)
{
var namespaceAliases = new SortedDictionary <string, string>();
var defaultParameters = new SortedDictionary <string, JToken>();
var aliases = token["namespaceAliases"] as JArray;
if (aliases != null)
{
foreach (var alias in aliases)
{
var key = alias.Value <string>("alias");
var value = alias.Value <string>("namespace");
namespaceAliases.Add(key, value);
}
}
var types = token["defaultParameters"] as JArray;
if (types != null)
{
foreach (var type in types)
{
var key = type.Value <string>("type");
var value = type["parameters"];
defaultParameters.Add(key, value);
}
}
Updated = !NamespaceAliases.SequenceEqual(namespaceAliases) ||
!DefaultParameters.SequenceEqual(defaultParameters, new ParameterComparer());
NamespaceAliases = namespaceAliases;
DefaultParameters = defaultParameters;
}
static void Main(string[] args)
{
ILearn learn = new DefaultParameters();
learn.Learn();
Console.ReadLine();
}
protected override void Load()
{
try {
_parms = Serializer.Deserialize <DefaultParameters>(Strings.PARAMETERS_PATH);
}
catch (NotSavedException e) {
_parms = new DefaultParameters();
}
}
//---------------------------------------------------------------------------------------------------------------------
/// <summary>Resets this TaskTemplate instance and loads the template information from the specified XML Element.</summary>
/// <param name="templateElem">The XML element descriping the task template.</param>
public void LoadNewFromXml(XmlElement templateElem)
{
Name = null;
Description = null;
// maxPriority !!!
DefaultParameters.Clear();
FixedParameters.Clear();
LoadFromXml(templateElem);
}
/// <summary>
/// Removes a parameter from the default parameters that are used on every request made with this client instance
/// </summary>
/// <param name="restClient">The IRestClient instance</param>
/// <param name="name">The name of the parameter that needs to be removed</param>
/// <returns></returns>
public void RemoveDefaultParameter(string name)
{
var parameter = DefaultParameters.SingleOrDefault(p => p.Name.Equals(name, StringComparison.OrdinalIgnoreCase));
if (parameter != null)
{
DefaultParameters.Remove(parameter);
}
}
/// <summary>
/// Add a parameter to use on every request made with this client instance
/// </summary>
/// <param name="restClient">The IRestClient instance</param>
/// <param name="p">Parameter to add</param>
/// <returns></returns>
public void AddDefaultParameter(Parameter p)
{
if (p.Type == ParameterType.RequestBody)
{
throw new NotSupportedException(
"Cannot set request body from default headers. Use Request.AddBody() instead.");
}
DefaultParameters.Add(p);
}
private object GetRequestHeaders(IRestRequest request)
{
var requestParameters = request.Parameters.Where(p => p.Type == ParameterType.HttpHeader);
var clientParameters = DefaultParameters.Where(p => p.Type == ParameterType.HttpHeader);
var parameters = requestParameters.Union(clientParameters);
var grouped = parameters.GroupBy(r => r.Name);
return(grouped.ToDictionary(group => group.Key, group => string.Join(",", group.Select(r => r.Value))));
}
private IEnumerable <Parameter> GetDefaultQueryStringParameters(IRestRequest request)
{
return(request.Method != Method.POST && request.Method != Method.PUT && request.Method != Method.PATCH
? DefaultParameters
.Where(p => p.Type == ParameterType.GetOrPost ||
p.Type == ParameterType.QueryString ||
p.Type == ParameterType.QueryStringWithoutEncode)
: DefaultParameters
.Where(p => p.Type == ParameterType.QueryString ||
p.Type == ParameterType.QueryStringWithoutEncode));
}
public void TestAmbiguous()
{
var def = new DefaultParameters();
def.Foo(1, 2);
def.Bar();
using (Foo foo = new Foo())
{
Common.HasPointerParam(foo, 0);
Common.HasPointerParam(foo);
}
}
/// <summary> Turn an object into a JSON string </summary>
public static string Freeze(object obj)
{
if (IsAnonymousTypedObject(obj))
{ // If we are passed an anon type, turn off type information -- it will all be junk.
var jsonParameters = DefaultParameters.Clone();
jsonParameters.UseExtensions = false;
jsonParameters.UsingGlobalTypes = false;
jsonParameters.EnableAnonymousTypes = true;
return(Instance.ToJson(obj, jsonParameters));
}
return(Instance.ToJson(obj, DefaultParameters));
}
/// <summary>
/// Add overridable default parameters to the request
/// </summary>
/// <param name="request">The requests to add the default parameters to.</param>
private void AddDefaultParameters(IRestRequest request)
{
var comparer = new ParameterComparer(this, request);
var startIndex = 0;
foreach (var parameter in DefaultParameters.Where(x => x.Type != ParameterType.HttpHeader))
{
if (request.Parameters.Contains(parameter, comparer))
{
continue;
}
request.Parameters.Insert(startIndex++, parameter);
}
}
public void Apply(Schema schema, SchemaRegistry schemaRegistry, Type type)
{
if (type.IsArray && type.GetElementType() != typeof(byte))
{
return; // Special case
}
var nullableUnderlyingType = Nullable.GetUnderlyingType(type);
switch (type.Name)
{
case "Employee":
schema.example = (DefaultParameters.GetDefaultParam(type.Name)).ToCamelCaseObject();;
break;
}
schema.vendorExtensions.Add("x-type-dotnet", (nullableUnderlyingType ?? type).FullName);
schema.vendorExtensions.Add("x-nullable", nullableUnderlyingType != null || !type.IsValueType);
}
/// <summary> Write an object to a stream as a JSON string </summary>
public static void Freeze(object obj, Stream target, Encoding encoding = null)
{
if (encoding == null)
{
encoding = DefaultStreamEncoding;
}
if (IsAnonymousTypedObject(obj))
{ // If we are passed an anon type, turn off type information -- it will all be junk.
var jsonParameters = DefaultParameters.Clone();
jsonParameters.UseExtensions = false;
jsonParameters.UsingGlobalTypes = false;
jsonParameters.EnableAnonymousTypes = true;
Instance.ToJsonStream(obj, target, jsonParameters, encoding);
}
Instance.ToJsonStream(obj, target, DefaultParameters, encoding);
}
public async Task <IActionResult> BuscarTodos([FromQuery] DefaultParameters DefaultParameters, CancellationToken ct = default)
{
var clientes = await _clienteService.BuscarTodos(DefaultParameters, ct);
var metadata = new
{
clientes.TotalCount,
clientes.PageSize,
clientes.CurrentPage,
clientes.TotalPages,
clientes.HasNext,
clientes.HasPrevious
};
AddPaginateHeader(metadata);
return(CustomPaginateResponse(clientes));
}
public string Execute(DefaultParameters args)
{
return(args.DefaultProperty1 + " " + args.DefaultProperty2 + " DefaultCommand");
}
public virtual async Task <PagedList <TEntity> > FindAllAsync(DefaultParameters ownerParameters, CancellationToken ct = default)
{
return(PagedList <TEntity> .ToPagedList(await _dbSet.ToListAsync(ct),
ownerParameters.PageNumber,
ownerParameters.PageSize));
}
public void TestAmbiguous()
{
var def = new DefaultParameters();
def.Foo(1, 2);
def.Bar();
using (Foo foo = new Foo())
{
common.hasPointerParam(foo, 0);
common.hasPointerParam(foo);
}
}
public async Task <IActionResult> BuscarTodos([FromQuery] DefaultParameters defaultParameters, CancellationToken ct = default)
{
return(CustomResponse(await _clienteService.BuscarTodos(defaultParameters, ct)));
}
//---------------------------------------------------------------------------------------------------------------------
/// <summary>Loads the template information from the specified XML Element.</summary>
/// <param name="templateElem">The XML element descriping the task template.</param>
protected void LoadFromXml(XmlElement templateElem)
{
AllowPending = true;
if (!templateElem.HasAttribute("name"))
{
throw new Exception("Template without name found in configuration file");
}
Identifier = templateElem.Attributes["name"].Value;
Version = (templateElem.HasAttribute("version") ? templateElem.Attributes["version"].Value : "1.0.0");
Available = templateElem.HasAttribute("available") && (templateElem.Attributes["available"].Value == "true" || templateElem.Attributes["available"].Value == "yes");
ServiceIdentifier = (templateElem.HasAttribute("service") ? templateElem.Attributes["service"].Value : null);
if (templateElem.HasAttribute("files"))
{
ForceInputFilesParameter = (templateElem.Attributes["files"].Value == "force");
AllowInputFilesParameter = ForceInputFilesParameter || (templateElem.Attributes["files"].Value == "allow");
}
for (int i = 0; i < templateElem.ChildNodes.Count; i++)
{
XmlElement elem = templateElem.ChildNodes[i] as XmlElement;
if (elem == null)
{
continue;
}
switch (elem.Name)
{
case "caption":
case "title":
Name = elem.InnerXml;
break;
case "description":
case "abstract":
Description = elem.InnerXml;
break;
case "maxPriority":
//Description = elem.InnerXml;
break;
case "allowPending":
AllowPending = (elem.InnerXml == "true" || elem.InnerXml == "yes");
break;
case "default":
for (int j = 0; j < elem.ChildNodes.Count; j++)
{
XmlElement paramElem = elem.ChildNodes[j] as XmlElement;
if (paramElem == null)
{
continue;
}
DefaultParameters.Add(new RequestParameter(context, null, paramElem.Name, null, null, paramElem.InnerXml));
if (paramElem == null)
{
continue;
}
}
break;
case "fixed":
for (int j = 0; j < elem.ChildNodes.Count; j++)
{
XmlElement paramElem = elem.ChildNodes[j] as XmlElement;
if (paramElem == null)
{
continue;
}
FixedParameters.Add(new RequestParameter(context, null, paramElem.Name, null, null, paramElem.InnerXml));
if (paramElem == null)
{
continue;
}
}
break;
}
}
}
public void MatchToObject_BooleanDefaultArgument_SetsBooleanArgumentTrue()
{
DefaultParameters result = MatchToObject(new[] { "foo", "bar", "baz", "true" });
result.DefaultProperty4.Should().BeTrue();
}
protected override BAInput ReadInputData(string inputFilePath, DefaultParameters parameters)
{
return(DataLoader.ReadBAInstance(inputFilePath));
}
protected override LSTMInput ReadInputData(string inputFilePath, DefaultParameters parameters) => DataLoader.ReadLSTMInstance(inputFilePath);
public string Execute(DefaultParameters args)
{
return args.DefaultProperty1 + " " + args.DefaultProperty2 + " DefaultCommand";
}
public void MatchToObject_BooleanDefaultArgument_TreatsInvalidBooleanAsFalse()
{
DefaultParameters result = MatchToObject(new[] { "foo", "bar", "baz", "lkj" });
result.DefaultProperty4.Should().BeFalse();
}
public void MatchToObject_NoParameterName_SetsFirstDefaultArgumentValue()
{
DefaultParameters result = MatchToObject(new[] { "foo" });
result.DefaultProperty1.Should().Be("foo");
}
public void TestAmbiguous()
{
var def = new DefaultParameters();
def.Foo(1, 2);
def.Bar();
}
private void InitDefaults()
{
DefaultParameters = DefaultParameters.Load(new XmlReader(new ResourceStateLoader()));
}
