public void SetGetProperties()
{
SelectParameter parameter = new SelectParameter();
Assert.AreEqual(typeof(string), parameter.DataType, "DataType does not match");
parameter.IsRequired = false;
Assert.AreEqual(false, parameter.IsRequired, "IsRequired does not match");
parameter.IsRequired = true;
Assert.AreEqual(true, parameter.IsRequired, "IsRequired does not match");
parameter.DataValues = new NameValuePair[] {
new NameValuePair(string.Empty, "Dev"),
new NameValuePair("Test", "Test"),
new NameValuePair(null, "Prod")
};
Assert.AreEqual(3, parameter.AllowedValues.Length, "AllowedValues does not match");
parameter.Description = "Some description goes here";
Assert.AreEqual("Some description goes here", parameter.Description, "Description does not match");
parameter.Name = "Some name";
Assert.AreEqual("Some name", parameter.Name, "Name does not match");
Assert.AreEqual("Some name", parameter.DisplayName, "DisplayName does not match");
parameter.DisplayName = "Another name";
Assert.AreEqual("Another name", parameter.DisplayName, "DisplayName does not match");
var defaultValue = "daDefault";
var clientValue = "daDefaultForDaClient";
parameter.DefaultValue = defaultValue;
Assert.AreEqual(defaultValue, parameter.DefaultValue);
Assert.AreEqual(defaultValue, parameter.ClientDefaultValue);
parameter.ClientDefaultValue = clientValue;
Assert.AreEqual(clientValue, parameter.ClientDefaultValue);
}
public override bool Parse(ActionBuilder.ActionParameter parameter)
{
base.Parse(parameter);
SelectParameter sp = parameter as SelectParameter;
ByValue = sp.ByValue;
var selectedElement = parameter.Element as IHTMLSelectElement;
if (selectedElement == null)
{
return(false);
}
//var optionElements = selectedElement.options as mshtml.HTMLSelectElementClass;
//if (optionElements == null) return false;
//foreach (IHTMLOptionElement option in selectedElement)
for (int i = 0; i < selectedElement.length; i++)
{
IHTMLOptionElement option = selectedElement.item(i, i) as IHTMLOptionElement;
if (option.selected)
{
SelectedValue = option.value;
SelectedText = option.text;
break;
}
}
return(true);
}
/// <summary>
/// Write a node.
/// </summary>
/// <param name="writer"></param>
/// <param name="target"></param>
public override void Write(XmlWriter writer, object target)
{
if (isList)
{
var list = target as IEnumerable <NameValuePair>;
if (list == null)
{
SelectParameter parameter = target as SelectParameter;
if (parameter != null)
{
list = parameter.DataValues;
}
}
if (list != null)
{
writer.WriteStartElement(base.Attribute.Name);
foreach (var value in list)
{
WriteValue(writer, value, "value");
}
writer.WriteEndElement();
}
}
else
{
var value = (target as NameValuePair);
if (value != null)
{
WriteValue(writer, value, base.Attribute.Name);
}
}
}
public async Task <ActionResult <IEnumerable <Account> > > Get(
AccountTypeParameter type,
ContractKindParameter kind,
SelectParameter select,
SortParameter sort,
OffsetParameter offset,
[Range(0, 10000)] int limit = 100)
{
#region validate
if (sort != null && !sort.Validate("id", "balance", "firstActivity", "lastActivity", "numTransactions", "numContracts"))
{
return(new BadRequest($"{nameof(sort)}", "Sorting by the specified field is not allowed."));
}
#endregion
#region optimize
if (kind?.Eq != null && type == null)
{
type = new AccountTypeParameter {
Eq = 2
}
}
;
#endregion
if (select == null)
{
return(Ok(await Accounts.Get(type, kind, sort, offset, limit)));
}
if (select.Values != null)
{
if (select.Values.Length == 1)
{
return(Ok(await Accounts.Get(type, kind, sort, offset, limit, select.Values[0])));
}
else
{
return(Ok(await Accounts.Get(type, kind, sort, offset, limit, select.Values)));
}
}
else
{
if (select.Fields.Length == 1)
{
return(Ok(await Accounts.Get(type, kind, sort, offset, limit, select.Fields[0])));
}
else
{
return(Ok(new SelectionResponse
{
Cols = select.Fields,
Rows = await Accounts.Get(type, kind, sort, offset, limit, select.Fields)
}));
}
}
}
public void IsRequiredWithBlank()
{
SelectParameter parameter = new SelectParameter();
parameter.Name = "Test";
parameter.IsRequired = true;
Exception[] results = parameter.Validate(string.Empty);
Assert.AreEqual(1, results.Length, "Number of exceptions does not match");
Assert.AreEqual("Value of 'Test' is required", results[0].Message, "Exception message does not match");
}
public void DefaultValueChecksAllowedValues()
{
var parameter = new SelectParameter();
parameter.DataValues = new NameValuePair[]
{
new NameValuePair("name1", "value1"),
new NameValuePair("name2", "value2")
};
parameter.DefaultValue = "value2";
Assert.AreEqual("name2", parameter.ClientDefaultValue);
}
public async Task <ActionResult <IEnumerable <Constant> > > Get(
ExpressionParameter address,
Int32Parameter creationLevel,
TimestampParameter creationTime,
AccountParameter creator,
Int32Parameter refs,
Int32Parameter size,
SelectParameter select,
SortParameter sort,
OffsetParameter offset,
[Range(0, 10000)] int limit = 100,
[Range(0, 2)] int format = 0)
{
#region validate
if (sort != null && !sort.Validate("creationLevel", "size", "refs"))
{
return(new BadRequest($"{nameof(sort)}", "Sorting by the specified field is not allowed."));
}
#endregion
if (select == null)
{
return(Ok(await Constants.Get(address, creationLevel, creationTime, creator, refs, size, sort, offset, limit, format)));
}
if (select.Values != null)
{
if (select.Values.Length == 1)
{
return(Ok(await Constants.Get(address, creationLevel, creationTime, creator, refs, size, sort, offset, limit, select.Values[0], format)));
}
else
{
return(Ok(await Constants.Get(address, creationLevel, creationTime, creator, refs, size, sort, offset, limit, select.Values, format)));
}
}
else
{
if (select.Fields.Length == 1)
{
return(Ok(await Constants.Get(address, creationLevel, creationTime, creator, refs, size, sort, offset, limit, select.Fields[0], format)));
}
else
{
return(Ok(new SelectionResponse
{
Cols = select.Fields,
Rows = await Constants.Get(address, creationLevel, creationTime, creator, refs, size, sort, offset, limit, select.Fields, format)
}));
}
}
}
public async Task <ActionResult <IEnumerable <BakingRight> > > Get(
BakingRightTypeParameter type,
AccountParameter baker,
Int32Parameter cycle,
Int32Parameter level,
Int32NullParameter slots,
Int32NullParameter priority,
BakingRightStatusParameter status,
SelectParameter select,
SortParameter sort,
OffsetParameter offset,
[Range(0, 10000)] int limit = 100)
{
#region validate
if (sort != null && !sort.Validate("level"))
{
return(new BadRequest($"{nameof(sort)}", "Sorting by the specified field is not allowed."));
}
#endregion
if (select == null)
{
return(Ok(await BakingRights.Get(type, baker, cycle, level, slots, priority, status, sort, offset, limit)));
}
if (select.Values != null)
{
if (select.Values.Length == 1)
{
return(Ok(await BakingRights.Get(type, baker, cycle, level, slots, priority, status, sort, offset, limit, select.Values[0])));
}
else
{
return(Ok(await BakingRights.Get(type, baker, cycle, level, slots, priority, status, sort, offset, limit, select.Values)));
}
}
else
{
if (select.Fields.Length == 1)
{
return(Ok(await BakingRights.Get(type, baker, cycle, level, slots, priority, status, sort, offset, limit, select.Fields[0])));
}
else
{
return(Ok(new SelectionResponse
{
Cols = select.Fields,
Rows = await BakingRights.Get(type, baker, cycle, level, slots, priority, status, sort, offset, limit, select.Fields)
}));
}
}
}
public void ConvertReturnsOriginalIfNameNotFound()
{
var parameter = new SelectParameter();
parameter.DataValues = new NameValuePair[]
{
new NameValuePair("name1", "value1"),
new NameValuePair("name2", "value2")
};
var value = parameter.Convert("notFound");
Assert.AreEqual("notFound", value);
}
public void ConvertReturnsValueForName()
{
var parameter = new SelectParameter();
parameter.DataValues = new NameValuePair[]
{
new NameValuePair("name1", "value1"),
new NameValuePair("name2", "value2")
};
var value = parameter.Convert("name1");
Assert.AreEqual("value1", value);
}
public void CanGetSetDataValues()
{
var parameter = new SelectParameter();
var dataValues = new NameValuePair[]
{
new NameValuePair("one", "1"),
new NameValuePair("two", "2"),
new NameValuePair("three", "3")
};
parameter.DataValues = dataValues;
Assert.AreSame(dataValues, parameter.DataValues);
}
public void IsAllowedValue()
{
SelectParameter parameter = new SelectParameter();
parameter.Name = "Test";
parameter.DataValues = new NameValuePair[] {
new NameValuePair(string.Empty, "Dev"),
new NameValuePair("Test", "Test"),
new NameValuePair(null, "Prod")
};
Exception[] results = parameter.Validate("Dev");
Assert.AreEqual(0, results.Length, "Number of exceptions does not match");
}
public async Task <ActionResult <IEnumerable <BigMapKeyHistorical> > > GetHistoricalKeys(
[Min(0)] int id,
[Min(0)] int level,
bool?active,
JsonParameter key,
JsonParameter value,
SelectParameter select,
SortParameter sort,
OffsetParameter offset,
[Range(0, 10000)] int limit = 100,
MichelineFormat micheline = MichelineFormat.Json)
{
#region validate
if (sort != null && !sort.Validate("id"))
{
return(new BadRequest(nameof(sort), "Sorting by the specified field is not allowed."));
}
#endregion
if (select == null)
{
return(Ok(await BigMaps.GetHistoricalKeys(id, level, active, key, value, sort, offset, limit, micheline)));
}
if (select.Values != null)
{
if (select.Values.Length == 1)
{
return(Ok(await BigMaps.GetHistoricalKeys(id, level, active, key, value, sort, offset, limit, select.Values[0], micheline)));
}
else
{
return(Ok(await BigMaps.GetHistoricalKeys(id, level, active, key, value, sort, offset, limit, select.Values, micheline)));
}
}
else
{
if (select.Fields.Length == 1)
{
return(Ok(await BigMaps.GetHistoricalKeys(id, level, active, key, value, sort, offset, limit, select.Fields[0], micheline)));
}
else
{
return(Ok(new SelectionResponse
{
Cols = select.Fields,
Rows = await BigMaps.GetHistoricalKeys(id, level, active, key, value, sort, offset, limit, select.Fields, micheline)
}));
}
}
}
public async Task <ActionResult <IEnumerable <BigMap> > > GetBigMaps(
AccountParameter contract,
StringParameter path,
BigMapTagsParameter tags,
bool?active,
Int32Parameter lastLevel,
SelectParameter select,
SortParameter sort,
OffsetParameter offset,
[Range(0, 10000)] int limit = 100,
MichelineFormat micheline = MichelineFormat.Json)
{
#region validate
if (sort != null && !sort.Validate("id", "ptr", "firstLevel", "lastLevel", "totalKeys", "activeKeys", "updates"))
{
return(new BadRequest($"{nameof(sort)}", "Sorting by the specified field is not allowed."));
}
#endregion
if (select == null)
{
return(Ok(await BigMaps.Get(contract, path, tags, active, lastLevel, sort, offset, limit, micheline)));
}
if (select.Values != null)
{
if (select.Values.Length == 1)
{
return(Ok(await BigMaps.Get(contract, path, tags, active, lastLevel, sort, offset, limit, select.Values[0], micheline)));
}
else
{
return(Ok(await BigMaps.Get(contract, path, tags, active, lastLevel, sort, offset, limit, select.Values, micheline)));
}
}
else
{
if (select.Fields.Length == 1)
{
return(Ok(await BigMaps.Get(contract, path, tags, active, lastLevel, sort, offset, limit, select.Fields[0], micheline)));
}
else
{
return(Ok(new SelectionResponse
{
Cols = select.Fields,
Rows = await BigMaps.Get(contract, path, tags, active, lastLevel, sort, offset, limit, select.Fields, micheline)
}));
}
}
}
public void IsNotAllowedValue()
{
SelectParameter parameter = new SelectParameter();
parameter.Name = "Test";
parameter.DataValues = new NameValuePair[] {
new NameValuePair(string.Empty, "Dev"),
new NameValuePair("Test", "Test"),
new NameValuePair(null, "Prod")
};
Exception[] results = parameter.Validate("QA");
Assert.AreEqual(1, results.Length, "Number of exceptions does not match");
Assert.AreEqual("Value of 'Test' is not an allowed value", results[0].Message, "Exception message does not match");
}
public async Task <ActionResult <IEnumerable <Commitment> > > Get(
bool?activated,
Int32NullParameter activationLevel,
Int64Parameter balance,
SelectParameter select,
SortParameter sort,
OffsetParameter offset,
[Range(0, 10000)] int limit = 100)
{
#region validate
if (sort != null && !sort.Validate("activationLevel", "balance"))
{
return(new BadRequest($"{nameof(sort)}", "Sorting by the specified field is not allowed."));
}
#endregion
if (select == null)
{
return(Ok(await Commitments.Get(activated, activationLevel, balance, sort, offset, limit)));
}
if (select.Values != null)
{
if (select.Values.Length == 1)
{
return(Ok(await Commitments.Get(activated, activationLevel, balance, sort, offset, limit, select.Values[0])));
}
else
{
return(Ok(await Commitments.Get(activated, activationLevel, balance, sort, offset, limit, select.Values)));
}
}
else
{
if (select.Fields.Length == 1)
{
return(Ok(await Commitments.Get(activated, activationLevel, balance, sort, offset, limit, select.Fields[0])));
}
else
{
return(Ok(new SelectionResponse
{
Cols = select.Fields,
Rows = await Commitments.Get(activated, activationLevel, balance, sort, offset, limit, select.Fields)
}));
}
}
}
public async Task <ActionResult <IEnumerable <Statistics> > > Get(
Int32Parameter level,
TimestampParameter timestamp,
SelectParameter select,
SortParameter sort,
OffsetParameter offset,
[Range(0, 10000)] int limit = 100,
Symbols quote = Symbols.None)
{
#region validate
if (sort != null && !sort.Validate("id", "level", "cycle", "date"))
{
return(new BadRequest($"{nameof(sort)}", "Sorting by the specified field is not allowed."));
}
#endregion
if (select == null)
{
return(Ok(await Statistics.Get(StatisticsPeriod.None, null, level, timestamp, null, sort, offset, limit, quote)));
}
if (select.Values != null)
{
if (select.Values.Length == 1)
{
return(Ok(await Statistics.Get(StatisticsPeriod.None, null, level, timestamp, null, sort, offset, limit, select.Values[0], quote)));
}
else
{
return(Ok(await Statistics.Get(StatisticsPeriod.None, null, level, timestamp, null, sort, offset, limit, select.Values, quote)));
}
}
else
{
if (select.Fields.Length == 1)
{
return(Ok(await Statistics.Get(StatisticsPeriod.None, null, level, timestamp, null, sort, offset, limit, select.Fields[0], quote)));
}
else
{
return(Ok(new SelectionResponse
{
Cols = select.Fields,
Rows = await Statistics.Get(StatisticsPeriod.None, null, level, timestamp, null, sort, offset, limit, select.Fields, quote)
}));
}
}
}
public async Task <ActionResult <IEnumerable <HistoricalBalance> > > GetBalanceHistory(
[Required][Address] string address,
[Min(1)] int?step,
SelectParameter select,
SortParameter sort,
[Min(0)] int offset = 0,
[Range(0, 10000)] int limit = 100,
Symbols quote = Symbols.None)
{
#region validate
if (sort != null && !sort.Validate("level"))
{
return(new BadRequest($"{nameof(sort)}", "Sorting by the specified field is not allowed."));
}
#endregion
if (select == null)
{
return(Ok(await History.Get(address, step ?? 1, sort, offset, limit, quote)));
}
if (select.Values != null)
{
if (select.Values.Length == 1)
{
return(Ok(await History.Get(address, step ?? 1, sort, offset, limit, select.Values[0], quote)));
}
else
{
return(Ok(await History.Get(address, step ?? 1, sort, offset, limit, select.Values, quote)));
}
}
else
{
if (select.Fields.Length == 1)
{
return(Ok(await History.Get(address, step ?? 1, sort, offset, limit, select.Fields[0], quote)));
}
else
{
return(Ok(new SelectionResponse
{
Cols = select.Fields,
Rows = await History.Get(address, step ?? 1, sort, offset, limit, select.Fields, quote)
}));
}
}
}
public async Task <ActionResult <IEnumerable <BakerRewards> > > GetBakerRewards(
[Required][TzAddress] string address,
Int32Parameter cycle,
SelectParameter select,
SortParameter sort,
OffsetParameter offset,
[Range(0, 10000)] int limit = 100,
Symbols quote = Symbols.None)
{
#region validate
if (sort != null && !sort.Validate("cycle"))
{
return(new BadRequest($"{nameof(sort)}", "Sorting by the specified field is not allowed."));
}
#endregion
if (select == null)
{
return(Ok(await Rewards.GetBakerRewards(address, cycle, sort, offset, limit, quote)));
}
if (select.Values != null)
{
if (select.Values.Length == 1)
{
return(Ok(await Rewards.GetBakerRewards(address, cycle, sort, offset, limit, select.Values[0], quote)));
}
else
{
return(Ok(await Rewards.GetBakerRewards(address, cycle, sort, offset, limit, select.Values, quote)));
}
}
else
{
if (select.Fields.Length == 1)
{
return(Ok(await Rewards.GetBakerRewards(address, cycle, sort, offset, limit, select.Fields[0], quote)));
}
else
{
return(Ok(new SelectionResponse
{
Cols = select.Fields,
Rows = await Rewards.GetBakerRewards(address, cycle, sort, offset, limit, select.Fields, quote)
}));
}
}
}
public async Task <ActionResult <IEnumerable <Proposal> > > GetProposals(
ProtocolParameter hash,
Int32Parameter epoch,
SelectParameter select,
SortParameter sort,
OffsetParameter offset,
[Range(0, 10000)] int limit = 100)
{
#region validate
if (sort != null && !sort.Validate("id", "upvotes", "rolls"))
{
return(new BadRequest($"{nameof(sort)}", "Sorting by the specified field is not allowed."));
}
#endregion
if (select == null)
{
return(Ok(await Voting.GetProposals(hash, epoch, sort, offset, limit)));
}
if (select.Values != null)
{
if (select.Values.Length == 1)
{
return(Ok(await Voting.GetProposals(hash, epoch, sort, offset, limit, select.Values[0])));
}
else
{
return(Ok(await Voting.GetProposals(hash, epoch, sort, offset, limit, select.Values)));
}
}
else
{
if (select.Fields.Length == 1)
{
return(Ok(await Voting.GetProposals(hash, epoch, sort, offset, limit, select.Fields[0])));
}
else
{
return(Ok(new SelectionResponse
{
Cols = select.Fields,
Rows = await Voting.GetProposals(hash, epoch, sort, offset, limit, select.Fields)
}));
}
}
}
public async Task <ActionResult <IEnumerable <Models.Delegate> > > Get(
BoolParameter active,
Int32Parameter lastActivity,
SelectParameter select,
SortParameter sort,
OffsetParameter offset,
[Range(0, 10000)] int limit = 100)
{
#region validate
if (sort != null && !sort.Validate("id", "stakingBalance", "balance", "numDelegators", "activationLevel", "deactivationLevel"))
{
return(new BadRequest($"{nameof(sort)}", "Sorting by the specified field is not allowed."));
}
#endregion
if (select == null)
{
return(Ok(await Accounts.GetDelegates(active, lastActivity, sort, offset, limit)));
}
if (select.Values != null)
{
if (select.Values.Length == 1)
{
return(Ok(await Accounts.GetDelegates(active, lastActivity, sort, offset, limit, select.Values[0])));
}
else
{
return(Ok(await Accounts.GetDelegates(active, lastActivity, sort, offset, limit, select.Values)));
}
}
else
{
if (select.Fields.Length == 1)
{
return(Ok(await Accounts.GetDelegates(active, lastActivity, sort, offset, limit, select.Fields[0])));
}
else
{
return(Ok(new SelectionResponse
{
Cols = select.Fields,
Rows = await Accounts.GetDelegates(active, lastActivity, sort, offset, limit, select.Fields)
}));
}
}
}
public async Task <ActionResult <IEnumerable <Cycle> > > Get(
Int32Parameter snapshotIndex,
SelectParameter select,
SortParameter sort,
OffsetParameter offset,
[Range(0, 10000)] int limit = 100,
Symbols quote = Symbols.None)
{
#region validate
if (sort != null && !sort.Validate("index"))
{
return(new BadRequest($"{nameof(sort)}", "Sorting by the specified field is not allowed."));
}
#endregion
if (select == null)
{
return(Ok(await Cycles.Get(snapshotIndex, sort, offset, limit, quote)));
}
if (select.Values != null)
{
if (select.Values.Length == 1)
{
return(Ok(await Cycles.Get(snapshotIndex, sort, offset, limit, select.Values[0], quote)));
}
else
{
return(Ok(await Cycles.Get(snapshotIndex, sort, offset, limit, select.Values, quote)));
}
}
else
{
if (select.Fields.Length == 1)
{
return(Ok(await Cycles.Get(snapshotIndex, sort, offset, limit, select.Fields[0], quote)));
}
else
{
return(Ok(new SelectionResponse
{
Cols = select.Fields,
Rows = await Cycles.Get(snapshotIndex, sort, offset, limit, select.Fields, quote)
}));
}
}
}
public async Task <ActionResult <IEnumerable <Quote> > > Get(
Int32Parameter level,
DateTimeParameter timestamp,
SelectParameter select,
SortParameter sort,
OffsetParameter offset,
[Range(0, 10000)] int limit = 100)
{
#region validate
if (sort != null && !sort.Validate("level"))
{
return(new BadRequest($"{nameof(sort)}", "Sorting by the specified field is not allowed."));
}
#endregion
if (select == null)
{
return(Ok(await Quotes.Get(level, timestamp, sort, offset, limit)));
}
if (select.Values != null)
{
if (select.Values.Length == 1)
{
return(Ok(await Quotes.Get(level, timestamp, sort, offset, limit, select.Values[0])));
}
else
{
return(Ok(await Quotes.Get(level, timestamp, sort, offset, limit, select.Values)));
}
}
else
{
if (select.Fields.Length == 1)
{
return(Ok(await Quotes.Get(level, timestamp, sort, offset, limit, select.Fields[0])));
}
else
{
return(Ok(new SelectionResponse
{
Cols = select.Fields,
Rows = await Quotes.Get(level, timestamp, sort, offset, limit, select.Fields)
}));
}
}
}
public async Task <ActionResult <IEnumerable <Software> > > Get(
SelectParameter select,
SortParameter sort,
OffsetParameter offset,
[Range(0, 10000)] int limit = 100)
{
#region validate
if (sort != null && !sort.Validate("firstLevel", "lastLevel", "blocksCount"))
{
return(new BadRequest($"{nameof(sort)}", "Sorting by the specified field is not allowed."));
}
#endregion
if (select == null)
{
return(Ok(await Software.Get(sort, offset, limit)));
}
if (select.Values != null)
{
if (select.Values.Length == 1)
{
return(Ok(await Software.Get(sort, offset, limit, select.Values[0])));
}
else
{
return(Ok(await Software.Get(sort, offset, limit, select.Values)));
}
}
else
{
if (select.Fields.Length == 1)
{
return(Ok(await Software.Get(sort, offset, limit, select.Fields[0])));
}
else
{
return(Ok(new SelectionResponse
{
Cols = select.Fields,
Rows = await Software.Get(sort, offset, limit, select.Fields)
}));
}
}
}
public Uri GetFullUri()
{
var parameters = new List <string>();
if (!FilterParameter.IsNullOrWhiteSpace())
{
parameters.Add(BuildParameter(StringConstants.FilterParameter, HttpUtility.UrlEncode(FilterParameter)));
}
if (!SelectParameter.IsNullOrWhiteSpace())
{
parameters.Add(BuildParameter(StringConstants.SelectParameter, SelectParameter));
}
if (!SkipParameter.IsNullOrWhiteSpace())
{
parameters.Add(BuildParameter(StringConstants.SkipParameter, SkipParameter));
}
if (!TakeParameter.IsNullOrWhiteSpace())
{
parameters.Add(BuildParameter(StringConstants.TopParameter, TakeParameter));
}
if (OrderByParameter.Any())
{
parameters.Add(BuildParameter(StringConstants.OrderByParameter, OrderByParameter.Join(",")));
}
if (!ExpandParameter.IsNullOrWhiteSpace())
{
parameters.Add(BuildParameter(StringConstants.ExpandParameter, ExpandParameter));
}
var builder = new UriBuilder(m_serviceBase);
builder.Query = (string.IsNullOrEmpty(builder.Query) ? string.Empty : "&") + parameters.Join("&");
var resultUri = builder.Uri;
return(resultUri);
}
public void GenerateClientDefaultLoadsFromAFile()
{
var sourceFile = Path.GetTempFileName();
try
{
var lines = new string[]
{
"Option #1",
"Option #2"
};
File.WriteAllLines(sourceFile, lines);
var parameter = new SelectParameter();
parameter.SourceFile = sourceFile;
parameter.GenerateClientDefault();
CollectionAssert.AreEqual(lines, parameter.AllowedValues);
}
finally
{
File.Delete(sourceFile);
}
}
protected virtual async void LoadData()
{
try
{
this.ActivityPresenter.Show("Searching...", ActivityStyle.SmallIndicatorWithText);
QueryDescriptor queryDescriptor = new QueryDescriptor();
queryDescriptor.FilterDescriptors.Add(new FilterDescriptor("Location", FilterOperator.IsEqualTo, this.Item.Location));
queryDescriptor.PageDescriptor.PageIndex = 0;
SelectParameter selectParameter = new SelectParameter();
selectParameter.QueryDescriptor = queryDescriptor;
ISelectResult <Property> selectResult = await this.Repository.GetAllAsync(selectParameter);
SearchResult searchResult = new SearchResult();
searchResult.Items = selectResult;
searchResult.Location = this.Item.Location;
if (selectResult.ItemCount == 0)
{
this.MessagePresenter.Show("No listing found near " + this.Item.Location);
}
else
{
this.Item.ItemCount = selectResult.ItemCount;
this.SaveRecentSearch();
this.ShowSearchResult(searchResult);
}
}
catch (Exception ex)
{
this.MessagePresenter.Show(ex.Message, "Search Failed");
}
finally
{
this.ActivityPresenter.Hide();
}
}
public async Task <ActionResult <Statistics> > GetCycles(SelectParameter select, Symbols quote = Symbols.None)
{
var level = new Int32Parameter {
Eq = State.Current.Level
};
if (select == null)
{
return(Ok((await Statistics.Get(StatisticsPeriod.None, null, level, null, null, null, null, 1, quote)).FirstOrDefault()));
}
if (select.Values != null)
{
if (select.Values.Length == 1)
{
return(Ok((await Statistics.Get(StatisticsPeriod.None, null, level, null, null, null, null, 1, select.Values[0], quote)).FirstOrDefault()));
}
else
{
return(Ok((await Statistics.Get(StatisticsPeriod.None, null, level, null, null, null, null, 1, select.Values, quote)).FirstOrDefault()));
}
}
else
{
if (select.Fields.Length == 1)
{
return(Ok((await Statistics.Get(StatisticsPeriod.None, null, level, null, null, null, null, 1, select.Fields[0], quote)).FirstOrDefault()));
}
else
{
return(Ok(new SelectionSingleResponse
{
Cols = select.Fields,
Vals = (await Statistics.Get(StatisticsPeriod.None, null, level, null, null, null, null, 1, select.Fields, quote)).FirstOrDefault()
}));
}
}
}
public async Task <ActionResult <IEnumerable <Account> > > Get(
AccountTypeParameter type,
ContractKindParameter kind,
AccountParameter @delegate,
Int64Parameter balance,
BoolParameter staked,
Int32Parameter lastActivity,
SelectParameter select,
SortParameter sort,
OffsetParameter offset,
[Range(0, 10000)] int limit = 100)
{
#region validate
if (@delegate != null)
{
if (@delegate.Eqx != null)
{
return(new BadRequest($"{nameof(@delegate)}.eqx", "This parameter doesn't support .eqx mode."));
}
if (@delegate.Nex != null)
{
return(new BadRequest($"{nameof(@delegate)}.nex", "This parameter doesn't support .nex mode."));
}
if (@delegate.Eq == -1 || @delegate.In?.Count == 0)
{
return(Ok(Enumerable.Empty <Account>()));
}
}
if (sort != null && !sort.Validate("id", "balance", "firstActivity", "lastActivity", "numTransactions", "numContracts"))
{
return(new BadRequest($"{nameof(sort)}", "Sorting by the specified field is not allowed."));
}
#endregion
#region optimize
if (kind?.Eq != null && type == null)
{
type = new AccountTypeParameter {
Eq = 2
}
}
;
#endregion
if (select == null)
{
return(Ok(await Accounts.Get(type, kind, @delegate, balance, staked, lastActivity, sort, offset, limit)));
}
if (select.Values != null)
{
if (select.Values.Length == 1)
{
return(Ok(await Accounts.Get(type, kind, @delegate, balance, staked, lastActivity, sort, offset, limit, select.Values[0])));
}
else
{
return(Ok(await Accounts.Get(type, kind, @delegate, balance, staked, lastActivity, sort, offset, limit, select.Values)));
}
}
else
{
if (select.Fields.Length == 1)
{
return(Ok(await Accounts.Get(type, kind, @delegate, balance, staked, lastActivity, sort, offset, limit, select.Fields[0])));
}
else
{
return(Ok(new SelectionResponse
{
Cols = select.Fields,
Rows = await Accounts.Get(type, kind, @delegate, balance, staked, lastActivity, sort, offset, limit, select.Fields)
}));
}
}
}
public async Task <ActionResult <IEnumerable <Block> > > Get(
AccountParameter baker,
Int32Parameter level,
DateTimeParameter timestamp,
Int32Parameter priority,
SelectParameter select,
SortParameter sort,
OffsetParameter offset,
[Range(0, 10000)] int limit = 100,
Symbols quote = Symbols.None)
{
#region validate
if (baker != null)
{
if (baker.Eqx != null)
{
return(new BadRequest($"{nameof(baker)}.eqx", "This parameter doesn't support .eqx mode."));
}
if (baker.Nex != null)
{
return(new BadRequest($"{nameof(baker)}.nex", "This parameter doesn't support .nex mode."));
}
if (baker.Eq == -1 || baker.In?.Count == 0)
{
return(Ok(Enumerable.Empty <OriginationOperation>()));
}
}
if (sort != null && !sort.Validate("id", "level", "priority", "validations", "reward", "fees"))
{
return(new BadRequest($"{nameof(sort)}", "Sorting by the specified field is not allowed."));
}
#endregion
if (select == null)
{
return(Ok(await Blocks.Get(baker, level, timestamp, priority, sort, offset, limit, quote)));
}
if (select.Values != null)
{
if (select.Values.Length == 1)
{
return(Ok(await Blocks.Get(baker, level, timestamp, priority, sort, offset, limit, select.Values[0], quote)));
}
else
{
return(Ok(await Blocks.Get(baker, level, timestamp, priority, sort, offset, limit, select.Values, quote)));
}
}
else
{
if (select.Fields.Length == 1)
{
return(Ok(await Blocks.Get(baker, level, timestamp, priority, sort, offset, limit, select.Fields[0], quote)));
}
else
{
return(Ok(new SelectionResponse
{
Cols = select.Fields,
Rows = await Blocks.Get(baker, level, timestamp, priority, sort, offset, limit, select.Fields, quote)
}));
}
}
}
