public async Task <IEnumerable <RevelationPenaltyOperation> > GetRevelationPenalties(
AccountParameter baker,
Int32Parameter level,
DateTimeParameter timestamp,
SortParameter sort,
OffsetParameter offset,
int limit,
Symbols quote)
{
var sql = new SqlBuilder(@"SELECT o.*, b.""Hash"" FROM ""RevelationPenaltyOps"" AS o INNER JOIN ""Blocks"" as b ON b.""Level"" = o.""Level""")
.FilterA(@"o.""BakerId""", baker)
.FilterA(@"o.""Level""", level)
.FilterA(@"o.""Timestamp""", timestamp)
.Take(sort, offset, limit, x => x == "level" ? ("Id", "Level") : ("Id", "Id"), "o");
using var db = GetConnection();
var rows = await db.QueryAsync(sql.Query, sql.Params);
return(rows.Select(row => new RevelationPenaltyOperation
{
Id = row.Id,
Level = row.Level,
Block = row.Hash,
Timestamp = row.Timestamp,
Baker = Accounts.GetAlias(row.BakerId),
MissedLevel = row.MissedLevel,
LostReward = row.LostReward,
LostFees = row.LostFees,
Quote = Quotes.Get(quote, row.Level)
}));
}
public async Task <IEnumerable <RegisterConstantOperation> > GetRegisterConstants(
AccountParameter sender,
ExpressionParameter address,
Int32Parameter level,
DateTimeParameter timestamp,
OperationStatusParameter status,
SortParameter sort,
OffsetParameter offset,
int limit,
MichelineFormat format,
Symbols quote)
{
var sql = new SqlBuilder(@"
SELECT o.*, b.""Hash""
FROM ""RegisterConstantOps"" AS o
INNER JOIN ""Blocks"" as b
ON b.""Level"" = o.""Level""")
.Filter("SenderId", sender)
.Filter("Address", address)
.FilterA(@"o.""Level""", level)
.FilterA(@"o.""Timestamp""", timestamp)
.Filter("Status", status)
.Take(sort, offset, limit, x => x switch
{
"level" => ("Id", "Level"),
"gasUsed" => ("GasUsed", "GasUsed"),
"storageUsed" => ("StorageUsed", "StorageUsed"),
"bakerFee" => ("BakerFee", "BakerFee"),
"storageFee" => ("StorageFee", "StorageFee"),
_ => ("Id", "Id")
}, "o");
public async Task <IEnumerable <OriginationOperation> > GetOriginations(
AnyOfParameter anyof,
AccountParameter initiator,
AccountParameter sender,
AccountParameter contractManager,
AccountParameter contractDelegate,
AccountParameter originatedContract,
Int32Parameter typeHash,
Int32Parameter codeHash,
Int32Parameter level,
DateTimeParameter timestamp,
OperationStatusParameter status,
SortParameter sort,
OffsetParameter offset,
int limit,
MichelineFormat format,
Symbols quote,
bool includeStorage = false,
bool includeBigmaps = false)
{
var sql = new SqlBuilder($@"
SELECT o.*, b.""Hash""
FROM ""OriginationOps"" AS o
INNER JOIN ""Blocks"" as b
ON b.""Level"" = o.""Level""
{(typeHash != null || codeHash != null ? @"LEFT JOIN ""Accounts"" as c ON c.""Id"" = o.""ContractId""" : "")}")
.Filter(anyof, x => x switch
{
"initiator" => "InitiatorId",
"sender" => "SenderId",
"contractManager" => "ManagerId",
"contractDelegate" => "DelegateId",
_ => "ContractId"
})
public async Task <IEnumerable <DoubleBakingOperation> > GetDoubleBakings(
AnyOfParameter anyof,
AccountParameter accuser,
AccountParameter offender,
Int32Parameter level,
DateTimeParameter timestamp,
SortParameter sort,
OffsetParameter offset,
int limit,
Symbols quote)
{
var sql = new SqlBuilder(@"SELECT o.*, b.""Hash"" FROM ""DoubleBakingOps"" AS o INNER JOIN ""Blocks"" as b ON b.""Level"" = o.""Level""")
.Filter(anyof, x => x == "accuser" ? "AccuserId" : "OffenderId")
.Filter("AccuserId", accuser, x => "OffenderId")
.Filter("OffenderId", offender, x => "AccuserId")
.FilterA(@"o.""Level""", level)
.FilterA(@"o.""Timestamp""", timestamp)
.Take(sort, offset, limit, x => x switch
{
"level" => ("Id", "Level"),
"accusedLevel" => ("AccusedLevel", "AccusedLevel"),
"accuserRewards" => ("AccuserReward", "AccuserReward"),
"offenderLostDeposits" => ("OffenderLostDeposit", "OffenderLostDeposit"),
"offenderLostRewards" => ("OffenderLostReward", "OffenderLostReward"),
"offenderLostFees" => ("OffenderLostFee", "OffenderLostFee"),
_ => ("Id", "Id")
}, "o");
public void Two_Parameters_Are_Equal()
{
ParameterBase param1 = new AccountParameter() { Value = "@pay_by_phone"};
ParameterBase param2 = new AccountParameter() { Value = "@pay_by_phone" };
Assert.IsTrue(param1.Equals(param2));
}
public async Task <IEnumerable <EndorsementOperation> > GetEndorsements(
AccountParameter delegat,
Int32Parameter level,
DateTimeParameter timestamp,
SortParameter sort,
OffsetParameter offset,
int limit,
Symbols quote)
{
var sql = new SqlBuilder(@"SELECT o.*, b.""Hash"" FROM ""EndorsementOps"" AS o INNER JOIN ""Blocks"" as b ON b.""Level"" = o.""Level""")
.Filter("DelegateId", delegat)
.FilterA(@"o.""Level""", level)
.FilterA(@"o.""Timestamp""", timestamp)
.Take(sort, offset, limit, x => x == "level" ? ("Id", "Level") : ("Id", "Id"), "o");
using var db = GetConnection();
var rows = await db.QueryAsync(sql.Query, sql.Params);
return(rows.Select(row => new EndorsementOperation
{
Id = row.Id,
Level = row.Level,
Block = row.Hash,
Timestamp = row.Timestamp,
Hash = row.OpHash,
Delegate = Accounts.GetAlias(row.DelegateId),
Slots = row.Slots,
Rewards = row.Reward,
Deposit = row.Deposit,
Quote = Quotes.Get(quote, row.Level)
}));
}
public async Task <ActionResult <IEnumerable <BigMapUpdate> > > GetBigMapUpdates(
Int32Parameter bigmap,
StringParameter path,
AccountParameter contract,
BigMapTagsParameter tags,
BigMapActionParameter action,
JsonParameter value,
Int32Parameter level,
TimestampParameter timestamp,
SortParameter sort,
OffsetParameter offset,
[Range(0, 10000)] int limit = 100,
MichelineFormat micheline = MichelineFormat.Json)
{
#region validate
if (sort != null && !sort.Validate("id", "level"))
{
return(new BadRequest($"{nameof(sort)}", "Sorting by the specified field is not allowed."));
}
#endregion
if (path == null && contract == null && tags == null)
{
return(Ok(await BigMaps.GetUpdates(bigmap, action, value, level, timestamp, sort, offset, limit, micheline)));
}
return(Ok(await BigMaps.GetUpdates(bigmap, path, contract, action, value, tags, level, timestamp, sort, offset, limit, micheline)));
}
public async Task <IEnumerable <Constant> > Get(
ExpressionParameter address,
Int32Parameter creationLevel,
TimestampParameter creationTime,
AccountParameter creator,
Int32Parameter refs,
Int32Parameter size,
SortParameter sort,
OffsetParameter offset,
int limit,
int format)
{
var sql = new SqlBuilder(@"SELECT * FROM ""RegisterConstantOps""")
.Filter(@"""Address"" IS NOT NULL")
.Filter("Address", address)
.Filter("Level", creationLevel)
.Filter("Level", creationTime)
.Filter("SenderId", creator)
.Filter("Refs", refs)
.Filter("StorageUsed", size)
.Take(sort, offset, limit, x => x switch
{
"creationLevel" => ("Level", "Level"),
"size" => ("StorageUsed", "StorageUsed"),
"refs" => ("Refs", "Refs"),
_ => ("Id", "Id")
});
public void A_New_Account_Parameter_With_Value_Pay_By_Phone_Is_Created()
{
ParameterBase param = new AccountParameter();
param.Value = "Pay By Phone";
Assert.AreEqual("Pay By Phone", param.Value);
}
public async Task <IEnumerable <BakingOperation> > GetBakings(
AccountParameter baker,
Int32Parameter level,
DateTimeParameter timestamp,
SortParameter sort,
OffsetParameter offset,
int limit,
Symbols quote)
{
var sql = new SqlBuilder(@"SELECT ""Id"", ""Level"", ""Timestamp"", ""BakerId"", ""Hash"", ""Priority"", ""Deposit"", ""Reward"", ""Fees"" FROM ""Blocks""")
.Filter("BakerId", baker)
.Filter(@"""BakerId"" IS NOT NULL")
.Filter("Level", level)
.Filter("Timestamp", timestamp)
.Take(sort, offset, limit, x => x == "level" ? ("Id", "Level") : ("Id", "Id"));
using var db = GetConnection();
var rows = await db.QueryAsync(sql.Query, sql.Params);
return(rows.Select(row => new BakingOperation
{
Id = row.Id,
Level = row.Level,
Timestamp = row.Timestamp,
Baker = Accounts.GetAlias(row.BakerId),
Block = row.Hash,
Priority = row.Priority,
Deposit = row.Deposit,
Reward = row.Reward,
Fees = row.Fees,
Quote = Quotes.Get(quote, row.Level)
}));
}
public async Task <IEnumerable <BallotOperation> > GetBallots(
AccountParameter sender,
Int32Parameter level,
DateTimeParameter timestamp,
Int32Parameter epoch,
Int32Parameter period,
ProtocolParameter proposal,
SortParameter sort,
OffsetParameter offset,
int limit,
Symbols quote)
{
var sql = new SqlBuilder(@"
SELECT o.""Id"", o.""Level"", o.""Timestamp"", o.""OpHash"", o.""SenderId"", o.""Rolls"", o.""Vote"", o.""Epoch"", o.""Period"",
b.""Hash"",
proposal.""Hash"" as ""ProposalHash"", proposal.""Metadata"" ->> 'alias' as ""ProposalAlias"",
period.""Kind"", period.""FirstLevel"", period.""LastLevel""
FROM ""BallotOps"" as o
INNER JOIN ""Blocks"" as b ON b.""Level"" = o.""Level""
INNER JOIN ""Proposals"" as proposal ON proposal.""Id"" = o.""ProposalId""
INNER JOIN ""VotingPeriods"" as period ON period.""Index"" = o.""Period""
")
.Filter("SenderId", sender)
.FilterA(@"o.""Level""", level)
.FilterA(@"o.""Timestamp""", timestamp)
.FilterA(@"o.""Epoch""", epoch)
.FilterA(@"o.""Period""", period)
.FilterA(@"proposal.""Hash""", proposal)
.Take(sort, offset, limit, x => x == "level" ? ("Id", "Level") : ("Id", "Id"), "o");
using var db = GetConnection();
var rows = await db.QueryAsync(sql.Query, sql.Params);
return(rows.Select(row => new BallotOperation
{
Id = row.Id,
Level = row.Level,
Block = row.Hash,
Timestamp = row.Timestamp,
Hash = row.OpHash,
Period = new PeriodInfo
{
Index = row.Period,
Epoch = row.Epoch,
Kind = PeriodKinds.ToString(row.Kind),
FirstLevel = row.FirstLevel,
LastLevel = row.LastLevel
},
Proposal = new ProposalAlias
{
Hash = row.ProposalHash,
Alias = row.ProposalAlias
},
Delegate = Accounts.GetAlias(row.SenderId),
Rolls = row.Rolls,
Vote = Votes.ToString(row.Vote),
Quote = Quotes.Get(quote, row.Level)
}));
}
public void Get_Url_Encode_Value_Of_Parameter()
{
ParameterBase param = new AccountParameter() { Value = "@pay_by_phone" };
string expectedResult = "q=" + HttpUtility.UrlEncode("@pay_by_phone");
Assert.AreEqual(expectedResult, param.ToString());
}
public ResultViewModel UpdateAccount([FromBody] AccountParameter parameter)
{
var info = this._mapper.Map <AccountInfoModel>(parameter);
var data = this._accountService.UpdateAccount(info);
var result = this._mapper.Map <ResultViewModel>(data);
return(result);
}
public Task <int> GetCount(
BakingRightTypeParameter type,
AccountParameter baker,
Int32Parameter cycle,
Int32Parameter level,
Int32NullParameter slots,
Int32NullParameter priority,
BakingRightStatusParameter status)
{
return(BakingRights.GetCount(type, baker, cycle, level, slots, priority, status));
}
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 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 async Task <IEnumerable <ActivationOperation> > GetActivations(
AccountParameter account,
Int32Parameter level,
DateTimeParameter timestamp,
SortParameter sort,
OffsetParameter offset,
int limit,
Symbols quote)
{
var sql = new SqlBuilder(@"SELECT o.*, b.""Hash"" FROM ""ActivationOps"" AS o INNER JOIN ""Blocks"" as b ON b.""Level"" = o.""Level""")
.Filter("AccountId", account)
.FilterA(@"o.""Level""", level)
.FilterA(@"o.""Timestamp""", timestamp)
.Take(sort, offset, limit, x => x switch
{
"level" => ("Id", "Level"),
"balance" => ("Balance", "Balance"),
_ => ("Id", "Id")
}, "o");
public async Task <IEnumerable <BakingRight> > Get(
BakingRightTypeParameter type,
AccountParameter baker,
Int32Parameter cycle,
Int32Parameter level,
Int32NullParameter slots,
Int32NullParameter priority,
BakingRightStatusParameter status,
SortParameter sort,
OffsetParameter offset,
int limit)
{
var sql = new SqlBuilder(@"SELECT * FROM ""BakingRights""")
.Filter("Cycle", cycle)
.Filter("Level", level)
.Filter("BakerId", baker)
.Filter("Type", type)
.Filter("Status", status)
.Filter("Priority", priority)
.Filter("Slots", slots)
.Take(sort ?? new SortParameter {
Asc = "level"
}, offset, limit, x => ("Level", "Level"));
using var db = GetConnection();
var rows = await db.QueryAsync(sql.Query, sql.Params);
var state = State.GetState();
return(rows.Select(row => new BakingRight
{
Type = TypeToString(row.Type),
Cycle = row.Cycle,
Level = row.Level,
Timestamp = row.Status == 0 ? state.Timestamp.AddMinutes(row.Level - state.Level) : Time[row.Level],
Baker = Accounts.GetAlias(row.BakerId),
Priority = row.Priority,
Slots = row.Slots,
Status = StatusToString(row.Status)
}));
}
public async Task <int> GetCount(
BakingRightTypeParameter type,
AccountParameter baker,
Int32Parameter cycle,
Int32Parameter level,
Int32NullParameter slots,
Int32NullParameter priority,
BakingRightStatusParameter status)
{
var sql = new SqlBuilder(@"SELECT COUNT(*) FROM ""BakingRights""")
.Filter("Cycle", cycle)
.Filter("Level", level)
.Filter("BakerId", baker)
.Filter("Type", type)
.Filter("Status", status)
.Filter("Priority", priority)
.Filter("Slots", slots);
using var db = GetConnection();
return(await db.QueryFirstAsync <int>(sql.Query, sql.Params));
}
public async Task <IEnumerable <DelegationOperation> > GetDelegations(
AnyOfParameter anyof,
AccountParameter initiator,
AccountParameter sender,
AccountParameter prevDelegate,
AccountParameter newDelegate,
Int32Parameter level,
DateTimeParameter timestamp,
OperationStatusParameter status,
SortParameter sort,
OffsetParameter offset,
int limit,
Symbols quote)
{
var sql = new SqlBuilder(@"SELECT o.*, b.""Hash"" FROM ""DelegationOps"" AS o INNER JOIN ""Blocks"" as b ON b.""Level"" = o.""Level""")
.Filter(anyof, x => x switch
{
"initiator" => "InitiatorId",
"sender" => "SenderId",
"prevDelegate" => "PrevDelegateId",
_ => "DelegateId"
})
public async Task <IEnumerable <Block> > Get(
AccountParameter baker,
Int32Parameter level,
DateTimeParameter timestamp,
Int32Parameter priority,
SortParameter sort,
OffsetParameter offset,
int limit,
Symbols quote)
{
var sql = new SqlBuilder(@"SELECT * FROM ""Blocks""")
.Filter("BakerId", baker)
.Filter("Level", level)
.Filter("Timestamp", timestamp)
.Filter("Priority", priority)
.Take(sort, offset, limit, x => x switch
{
"level" => ("Id", "Level"),
"priority" => ("Priority", "Priority"),
"validations" => ("Validations", "Validations"),
"reward" => ("Reward", "Reward"),
"fees" => ("Fees", "Fees"),
_ => ("Id", "Id")
});
public async Task <object[]> GetProposals(
AccountParameter sender,
Int32Parameter level,
DateTimeParameter timestamp,
Int32Parameter epoch,
Int32Parameter period,
ProtocolParameter proposal,
BoolParameter duplicated,
SortParameter sort,
OffsetParameter offset,
int limit,
string field,
Symbols quote)
{
var columns = new HashSet <string>(4);
var joins = new HashSet <string>(3);
switch (field)
{
case "id": columns.Add(@"o.""Id"""); break;
case "level": columns.Add(@"o.""Level"""); break;
case "timestamp": columns.Add(@"o.""Timestamp"""); break;
case "hash": columns.Add(@"o.""OpHash"""); break;
case "delegate": columns.Add(@"o.""SenderId"""); break;
case "rolls": columns.Add(@"o.""Rolls"""); break;
case "duplicated": columns.Add(@"o.""Duplicated"""); break;
case "proposal":
columns.Add(@"proposal.""Hash"" as ""ProposalHash""");
columns.Add(@"proposal.""Metadata"" ->> 'alias' as ""ProposalAlias""");
joins.Add(@"INNER JOIN ""Proposals"" as proposal ON proposal.""Id"" = o.""ProposalId""");
break;
case "period":
columns.Add(@"o.""Epoch""");
columns.Add(@"o.""Period""");
columns.Add(@"period.""Kind""");
columns.Add(@"period.""FirstLevel""");
columns.Add(@"period.""LastLevel""");
joins.Add(@"INNER JOIN ""VotingPeriods"" as period ON period.""Index"" = o.""Period""");
break;
case "block":
columns.Add(@"b.""Hash""");
joins.Add(@"INNER JOIN ""Blocks"" as b ON b.""Level"" = o.""Level""");
break;
case "quote": columns.Add(@"o.""Level"""); break;
}
if (period != null)
{
joins.Add(@"INNER JOIN ""VotingPeriods"" as period ON period.""Index"" = o.""Period""");
}
if (proposal != null)
{
joins.Add(@"INNER JOIN ""Proposals"" as proposal ON proposal.""Id"" = o.""ProposalId""");
}
if (columns.Count == 0)
{
return(Array.Empty <object>());
}
var sql = new SqlBuilder($@"SELECT {string.Join(',', columns)} FROM ""ProposalOps"" as o {string.Join(' ', joins)}")
.Filter("SenderId", sender)
.FilterA(@"o.""Level""", level)
.FilterA(@"o.""Timestamp""", timestamp)
.FilterA(@"o.""Duplicated""", duplicated)
.FilterA(@"o.""Epoch""", epoch)
.FilterA(@"o.""Period""", period)
.FilterA(@"proposal.""Hash""", proposal)
.Take(sort, offset, limit, x => x == "level" ? ("Id", "Level") : ("Id", "Id"), "o");
using var db = GetConnection();
var rows = await db.QueryAsync(sql.Query, sql.Params);
//TODO: optimize memory allocation
var result = new object[rows.Count()];
var j = 0;
switch (field)
{
case "id":
foreach (var row in rows)
{
result[j++] = row.Id;
}
break;
case "level":
foreach (var row in rows)
{
result[j++] = row.Level;
}
break;
case "block":
foreach (var row in rows)
{
result[j++] = row.Hash;
}
break;
case "timestamp":
foreach (var row in rows)
{
result[j++] = row.Timestamp;
}
break;
case "hash":
foreach (var row in rows)
{
result[j++] = row.OpHash;
}
break;
case "rolls":
foreach (var row in rows)
{
result[j++] = row.Rolls;
}
break;
case "duplicated":
foreach (var row in rows)
{
result[j++] = row.Duplicated;
}
break;
case "period":
foreach (var row in rows)
{
result[j++] = new PeriodInfo
{
Index = row.Period,
Epoch = row.Epoch,
Kind = PeriodKinds.ToString(row.Kind),
FirstLevel = row.FirstLevel,
LastLevel = row.LastLevel
}
}
;
break;
case "proposal":
foreach (var row in rows)
{
result[j++] = new ProposalAlias
{
Hash = row.ProposalHash,
Alias = row.ProposalAlias
}
}
;
break;
case "delegate":
foreach (var row in rows)
{
result[j++] = await Accounts.GetAliasAsync(row.SenderId);
}
break;
case "quote":
foreach (var row in rows)
{
result[j++] = Quotes.Get(quote, row.Level);
}
break;
}
return(result);
}
public async Task <object[][]> GetBakings(
AccountParameter baker,
Int32Parameter level,
DateTimeParameter timestamp,
SortParameter sort,
OffsetParameter offset,
int limit,
string[] fields,
Symbols quote)
{
var columns = new HashSet <string>(fields.Length);
foreach (var field in fields)
{
switch (field)
{
case "id": columns.Add(@"""Id"""); break;
case "level": columns.Add(@"""Level"""); break;
case "timestamp": columns.Add(@"""Timestamp"""); break;
case "baker": columns.Add(@"""BakerId"""); break;
case "block": columns.Add(@"""Hash"""); break;
case "priority": columns.Add(@"""Priority"""); break;
case "deposit": columns.Add(@"""Deposit"""); break;
case "reward": columns.Add(@"""Reward"""); break;
case "fees": columns.Add(@"""Fees"""); break;
case "quote": columns.Add(@"""Level"""); break;
}
}
if (columns.Count == 0)
{
return(Array.Empty <object[]>());
}
var sql = new SqlBuilder($@"SELECT {string.Join(',', columns)} FROM ""Blocks""")
.Filter("BakerId", baker)
.Filter(@"""BakerId"" IS NOT NULL")
.Filter("Level", level)
.Filter("Timestamp", timestamp)
.Take(sort, offset, limit, x => x == "level" ? ("Id", "Level") : ("Id", "Id"));
using var db = GetConnection();
var rows = await db.QueryAsync(sql.Query, sql.Params);
var result = new object[rows.Count()][];
for (int i = 0; i < result.Length; i++)
{
result[i] = new object[fields.Length];
}
for (int i = 0, j = 0; i < fields.Length; j = 0, i++)
{
switch (fields[i])
{
case "id":
foreach (var row in rows)
{
result[j++][i] = row.Id;
}
break;
case "level":
foreach (var row in rows)
{
result[j++][i] = row.Level;
}
break;
case "timestamp":
foreach (var row in rows)
{
result[j++][i] = row.Timestamp;
}
break;
case "baker":
foreach (var row in rows)
{
result[j++][i] = await Accounts.GetAliasAsync(row.BakerId);
}
break;
case "block":
foreach (var row in rows)
{
result[j++][i] = row.Hash;
}
break;
case "priority":
foreach (var row in rows)
{
result[j++][i] = row.Priority;
}
break;
case "deposit":
foreach (var row in rows)
{
result[j++][i] = row.Deposit;
}
break;
case "reward":
foreach (var row in rows)
{
result[j++][i] = row.Reward;
}
break;
case "fees":
foreach (var row in rows)
{
result[j++][i] = row.Fees;
}
break;
case "quote":
foreach (var row in rows)
{
result[j++][i] = Quotes.Get(quote, row.Level);
}
break;
}
}
return(result);
}
public async Task <object[]> Get(
BakingRightTypeParameter type,
AccountParameter baker,
Int32Parameter cycle,
Int32Parameter level,
Int32NullParameter slots,
Int32NullParameter priority,
BakingRightStatusParameter status,
SortParameter sort,
OffsetParameter offset,
int limit,
string field)
{
var columns = new HashSet <string>(1);
switch (field)
{
case "type": columns.Add(@"""Type"""); break;
case "cycle": columns.Add(@"""Cycle"""); break;
case "level": columns.Add(@"""Level"""); break;
case "timestamp": columns.Add(@"""Level"""); columns.Add(@"""Status"""); break;
case "baker": columns.Add(@"""BakerId"""); break;
case "priority": columns.Add(@"""Priority"""); break;
case "slots": columns.Add(@"""Slots"""); break;
case "status": columns.Add(@"""Status"""); break;
}
if (columns.Count == 0)
{
return(Array.Empty <object>());
}
var sql = new SqlBuilder($@"SELECT {string.Join(',', columns)} FROM ""BakingRights""")
.Filter("Cycle", cycle)
.Filter("Level", level)
.Filter("BakerId", baker)
.Filter("Type", type)
.Filter("Status", status)
.Filter("Priority", priority)
.Filter("Slots", slots)
.Take(sort ?? new SortParameter {
Asc = "level"
}, offset, limit, x => ("Level", "Level"));
using var db = GetConnection();
var rows = await db.QueryAsync(sql.Query, sql.Params);
//TODO: optimize memory allocation
var result = new object[rows.Count()];
var j = 0;
switch (field)
{
case "type":
foreach (var row in rows)
{
result[j++] = TypeToString(row.Type);
}
break;
case "cycle":
foreach (var row in rows)
{
result[j++] = row.Cycle;
}
break;
case "level":
foreach (var row in rows)
{
result[j++] = row.Level;
}
break;
case "timestamp":
var state = State.GetState();
foreach (var row in rows)
{
result[j++] = row.Status == 0 ? state.Timestamp.AddMinutes(row.Level - state.Level) : Time[row.Level];
}
break;
case "baker":
foreach (var row in rows)
{
result[j++] = await Accounts.GetAliasAsync(row.BakerId);
}
break;
case "priority":
foreach (var row in rows)
{
result[j++] = row.Priority;
}
break;
case "slots":
foreach (var row in rows)
{
result[j++] = row.Slots;
}
break;
case "status":
foreach (var row in rows)
{
result[j++] = StatusToString(row.Status);
}
break;
}
return(result);
}
public void A_New_Account_Parameter_Is_Created()
{
ParameterBase param = new AccountParameter();
Assert.IsNotNull(param);
}
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)
}));
}
}
}
public async Task <ActionResult <IEnumerable <Operation> > > GetOperations(
[Required][Address] string address,
string type,
AccountParameter initiator,
AccountParameter sender,
AccountParameter target,
AccountParameter prevDelegate,
AccountParameter newDelegate,
AccountParameter contractManager,
AccountParameter contractDelegate,
AccountParameter originatedContract,
AccountParameter accuser,
AccountParameter offender,
AccountParameter baker,
Int32Parameter level,
DateTimeParameter timestamp,
StringParameter entrypoint,
JsonParameter parameter,
StringParameter parameters,
BoolParameter hasInternals,
OperationStatusParameter status,
SortMode sort = SortMode.Descending,
int?lastId = null,
[Range(0, 1000)] int limit = 100,
MichelineFormat micheline = MichelineFormat.Json,
Symbols quote = Symbols.None,
DateTimeOffset?from = null,
DateTimeOffset?to = null)
{
#region validate
if (initiator != null)
{
if (initiator.Eqx != null)
{
return(new BadRequest($"{nameof(initiator)}.eqx", "This parameter doesn't support .eqx mode."));
}
if (initiator.Nex != null)
{
return(new BadRequest($"{nameof(initiator)}.eqx", "This parameter doesn't support .eqx mode."));
}
}
if (sender != null)
{
if (sender.Eqx != null)
{
return(new BadRequest($"{nameof(sender)}.eqx", "This parameter doesn't support .eqx mode."));
}
if (sender.Nex != null)
{
return(new BadRequest($"{nameof(sender)}.eqx", "This parameter doesn't support .eqx mode."));
}
}
if (target != null)
{
if (target.Eqx != null)
{
return(new BadRequest($"{nameof(target)}.eqx", "This parameter doesn't support .eqx mode."));
}
if (target.Nex != null)
{
return(new BadRequest($"{nameof(target)}.eqx", "This parameter doesn't support .eqx mode."));
}
}
if (prevDelegate != null)
{
if (prevDelegate.Eqx != null)
{
return(new BadRequest($"{nameof(prevDelegate)}.eqx", "This parameter doesn't support .eqx mode."));
}
if (prevDelegate.Nex != null)
{
return(new BadRequest($"{nameof(prevDelegate)}.nex", "This parameter doesn't support .nex mode."));
}
}
if (newDelegate != null)
{
if (newDelegate.Eqx != null)
{
return(new BadRequest($"{nameof(newDelegate)}.eqx", "This parameter doesn't support .eqx mode."));
}
if (newDelegate.Nex != null)
{
return(new BadRequest($"{nameof(newDelegate)}.nex", "This parameter doesn't support .nex mode."));
}
}
if (contractManager != null)
{
if (contractManager.Eqx != null)
{
return(new BadRequest($"{nameof(contractManager)}.eqx", "This parameter doesn't support .eqx mode."));
}
if (contractManager.Nex != null)
{
return(new BadRequest($"{nameof(contractManager)}.nex", "This parameter doesn't support .nex mode."));
}
}
if (contractDelegate != null)
{
if (contractDelegate.Eqx != null)
{
return(new BadRequest($"{nameof(contractDelegate)}.eqx", "This parameter doesn't support .eqx mode."));
}
if (contractDelegate.Nex != null)
{
return(new BadRequest($"{nameof(contractDelegate)}.nex", "This parameter doesn't support .nex mode."));
}
}
if (originatedContract != null)
{
if (originatedContract.Eqx != null)
{
return(new BadRequest($"{nameof(originatedContract)}.eqx", "This parameter doesn't support .eqx mode."));
}
if (originatedContract.Nex != null)
{
return(new BadRequest($"{nameof(originatedContract)}.nex", "This parameter doesn't support .nex mode."));
}
}
if (accuser != null)
{
if (accuser.Eqx != null)
{
return(new BadRequest($"{nameof(accuser)}.eqx", "This parameter doesn't support .eqx mode."));
}
if (accuser.Nex != null)
{
return(new BadRequest($"{nameof(accuser)}.nex", "This parameter doesn't support .nex mode."));
}
}
if (offender != null)
{
if (offender.Eqx != null)
{
return(new BadRequest($"{nameof(offender)}.eqx", "This parameter doesn't support .eqx mode."));
}
if (offender.Nex != null)
{
return(new BadRequest($"{nameof(offender)}.nex", "This parameter doesn't support .nex mode."));
}
}
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."));
}
}
#endregion
var types = type != null ? new HashSet <string>(type.Split(',')) : OpTypes.DefaultSet;
var _sort = sort == SortMode.Ascending
? new SortParameter {
Asc = "Id"
}
: new SortParameter {
Desc = "Id"
};
var _offset = lastId != null
? new OffsetParameter {
Cr = lastId
}
: null;
#region legacy
if (timestamp == null && (from != null || to != null))
{
timestamp = new DateTimeParameter();
}
if (from != null)
{
timestamp.Ge = from.Value.DateTime;
}
if (to != null)
{
timestamp.Lt = to.Value.DateTime;
}
#endregion
return(Ok(await Accounts.GetOperations(address, types, initiator, sender, target, prevDelegate, newDelegate, contractManager, contractDelegate, originatedContract, accuser, offender, baker, level, timestamp, entrypoint, parameter, parameters, hasInternals, status, _sort, _offset, limit, micheline, quote)));
}
public async Task <object[][]> Get(
BakingRightTypeParameter type,
AccountParameter baker,
Int32Parameter cycle,
Int32Parameter level,
Int32NullParameter slots,
Int32NullParameter priority,
BakingRightStatusParameter status,
SortParameter sort,
OffsetParameter offset,
int limit,
string[] fields)
{
var columns = new HashSet <string>(fields.Length);
foreach (var field in fields)
{
switch (field)
{
case "type": columns.Add(@"""Type"""); break;
case "cycle": columns.Add(@"""Cycle"""); break;
case "level": columns.Add(@"""Level"""); break;
case "timestamp": columns.Add(@"""Level"""); columns.Add(@"""Status"""); break;
case "baker": columns.Add(@"""BakerId"""); break;
case "priority": columns.Add(@"""Priority"""); break;
case "slots": columns.Add(@"""Slots"""); break;
case "status": columns.Add(@"""Status"""); break;
}
}
if (columns.Count == 0)
{
return(Array.Empty <object[]>());
}
var sql = new SqlBuilder($@"SELECT {string.Join(',', columns)} FROM ""BakingRights""")
.Filter("Cycle", cycle)
.Filter("Level", level)
.Filter("BakerId", baker)
.Filter("Type", type)
.Filter("Status", status)
.Filter("Priority", priority)
.Filter("Slots", slots)
.Take(sort ?? new SortParameter {
Asc = "level"
}, offset, limit, x => ("Level", "Level"));
using var db = GetConnection();
var rows = await db.QueryAsync(sql.Query, sql.Params);
var result = new object[rows.Count()][];
for (int i = 0; i < result.Length; i++)
{
result[i] = new object[fields.Length];
}
for (int i = 0, j = 0; i < fields.Length; j = 0, i++)
{
switch (fields[i])
{
case "type":
foreach (var row in rows)
{
result[j++][i] = BakingRightTypes.ToString(row.Type);
}
break;
case "cycle":
foreach (var row in rows)
{
result[j++][i] = row.Cycle;
}
break;
case "level":
foreach (var row in rows)
{
result[j++][i] = row.Level;
}
break;
case "timestamp":
foreach (var row in rows)
{
result[j++][i] = Time[row.Level];
}
break;
case "baker":
foreach (var row in rows)
{
result[j++][i] = await Accounts.GetAliasAsync(row.BakerId);
}
break;
case "priority":
foreach (var row in rows)
{
result[j++][i] = row.Priority;
}
break;
case "slots":
foreach (var row in rows)
{
result[j++][i] = row.Slots;
}
break;
case "status":
foreach (var row in rows)
{
result[j++][i] = BakingRightStatuses.ToString(row.Status);
}
break;
}
}
return(result);
}
public async Task <ActionResult <IEnumerable <Contract> > > Get(
ContractKindParameter kind,
AccountParameter creator,
AccountParameter manager,
AccountParameter @delegate,
Int32Parameter lastActivity,
SelectParameter select,
SortParameter sort,
OffsetParameter offset,
[Range(0, 10000)] int limit = 100,
bool includeStorage = false)
{
#region validates
if (creator != null)
{
if (creator.Eqx != null && creator.Eqx != "manager" && creator.Eqx != "delegate")
{
return(new BadRequest($"{nameof(creator)}.eqx", "The 'creator' field can be compared with the 'manager' or 'delegate' field only."));
}
if (creator.Nex != null && creator.Nex != "manager" && creator.Nex != "delegate")
{
return(new BadRequest($"{nameof(creator)}.nex", "The 'creator' field can be compared with the 'manager' or 'delegate' field only."));
}
if (creator.Eq == -1 || creator.In?.Count == 0)
{
return(Ok(Enumerable.Empty <Contract>()));
}
}
if (manager != null)
{
if (manager.Eqx != null && manager.Eqx != "creator" && manager.Eqx != "delegate")
{
return(new BadRequest($"{nameof(manager)}.eqx", "The 'manager' field can be compared with the 'creator' or 'delegate' field only."));
}
if (manager.Nex != null && manager.Nex != "creator" && manager.Nex != "delegate")
{
return(new BadRequest($"{nameof(manager)}.nex", "The 'manager' field can be compared with the 'creator' or 'delegate' field only."));
}
if (manager.Eq == -1 || manager.In?.Count == 0)
{
return(Ok(Enumerable.Empty <Contract>()));
}
}
if (@delegate != null)
{
if (@delegate.Eqx != null && @delegate.Eqx != "creator" && @delegate.Eqx != "manager")
{
return(new BadRequest($"{nameof(@delegate)}.eqx", "The 'delegate' field can be compared with the 'creator' or 'manager' field only."));
}
if (@delegate.Nex != null && @delegate.Nex != "creator" && @delegate.Nex != "manager")
{
return(new BadRequest($"{nameof(@delegate)}.nex", "The 'delegate' field can be compared with the 'creator' or 'manager' field only."));
}
if (@delegate.Eq == -1 || @delegate.In?.Count == 0)
{
return(Ok(Enumerable.Empty <Contract>()));
}
}
if (sort != null && !sort.Validate("id", "balance", "firstActivity", "lastActivity", "numTransactions"))
{
return(new BadRequest($"{nameof(sort)}", "Sorting by the specified field is not allowed."));
}
#endregion
if (select == null)
{
return(Ok(await Accounts.GetContracts(kind, creator, manager, @delegate, lastActivity, sort, offset, limit, includeStorage)));
}
if (select.Values != null)
{
if (select.Values.Length == 1)
{
return(Ok(await Accounts.GetContracts(kind, creator, manager, @delegate, lastActivity, sort, offset, limit, select.Values[0], includeStorage)));
}
else
{
return(Ok(await Accounts.GetContracts(kind, creator, manager, @delegate, lastActivity, sort, offset, limit, select.Values, includeStorage)));
}
}
else
{
if (select.Fields.Length == 1)
{
return(Ok(await Accounts.GetContracts(kind, creator, manager, @delegate, lastActivity, sort, offset, limit, select.Fields[0], includeStorage)));
}
else
{
return(Ok(new SelectionResponse
{
Cols = select.Fields,
Rows = await Accounts.GetContracts(kind, creator, manager, @delegate, lastActivity, sort, offset, limit, select.Fields, includeStorage)
}));
}
}
}
public async Task <object[]> GetEndorsements(
AccountParameter delegat,
Int32Parameter level,
DateTimeParameter timestamp,
SortParameter sort,
OffsetParameter offset,
int limit,
string field,
Symbols quote)
{
var columns = new HashSet <string>(1);
var joins = new HashSet <string>(1);
switch (field)
{
case "id": columns.Add(@"o.""Id"""); break;
case "level": columns.Add(@"o.""Level"""); break;
case "timestamp": columns.Add(@"o.""Timestamp"""); break;
case "hash": columns.Add(@"o.""OpHash"""); break;
case "delegate": columns.Add(@"o.""DelegateId"""); break;
case "slots": columns.Add(@"o.""Slots"""); break;
case "rewards": columns.Add(@"o.""Reward"""); break;
case "deposit": columns.Add(@"o.""Deposit"""); break;
case "block":
columns.Add(@"b.""Hash""");
joins.Add(@"INNER JOIN ""Blocks"" as b ON b.""Level"" = o.""Level""");
break;
case "quote": columns.Add(@"o.""Level"""); break;
}
if (columns.Count == 0)
{
return(Array.Empty <object>());
}
var sql = new SqlBuilder($@"SELECT {string.Join(',', columns)} FROM ""EndorsementOps"" as o {string.Join(' ', joins)}")
.Filter("DelegateId", delegat)
.FilterA(@"o.""Level""", level)
.FilterA(@"o.""Timestamp""", timestamp)
.Take(sort, offset, limit, x => x == "level" ? ("Id", "Level") : ("Id", "Id"), "o");
using var db = GetConnection();
var rows = await db.QueryAsync(sql.Query, sql.Params);
//TODO: optimize memory allocation
var result = new object[rows.Count()];
var j = 0;
switch (field)
{
case "id":
foreach (var row in rows)
{
result[j++] = row.Id;
}
break;
case "level":
foreach (var row in rows)
{
result[j++] = row.Level;
}
break;
case "block":
foreach (var row in rows)
{
result[j++] = row.Hash;
}
break;
case "timestamp":
foreach (var row in rows)
{
result[j++] = row.Timestamp;
}
break;
case "hash":
foreach (var row in rows)
{
result[j++] = row.OpHash;
}
break;
case "delegate":
foreach (var row in rows)
{
result[j++] = await Accounts.GetAliasAsync(row.DelegateId);
}
break;
case "slots":
foreach (var row in rows)
{
result[j++] = row.Slots;
}
break;
case "rewards":
foreach (var row in rows)
{
result[j++] = row.Reward;
}
break;
case "deposit":
foreach (var row in rows)
{
result[j++] = row.Deposit;
}
break;
case "quote":
foreach (var row in rows)
{
result[j++] = Quotes.Get(quote, row.Level);
}
break;
}
return(result);
}
public async Task <IEnumerable <MigrationOperation> > GetMigrations(
AccountParameter account,
MigrationKindParameter kind,
Int64Parameter balanceChange,
Int32Parameter level,
DateTimeParameter timestamp,
SortParameter sort,
OffsetParameter offset,
int limit,
MichelineFormat format,
Symbols quote,
bool includeStorage = false,
bool includeDiffs = false)
{
var sql = new SqlBuilder(@"SELECT o.*, b.""Hash"" FROM ""MigrationOps"" AS o INNER JOIN ""Blocks"" as b ON b.""Level"" = o.""Level""")
.Filter("AccountId", account)
.Filter("Kind", kind)
.Filter("BalanceChange", balanceChange)
.FilterA(@"o.""Level""", level)
.FilterA(@"o.""Timestamp""", timestamp)
.Take(sort, offset, limit, x => x == "level" ? ("Id", "Level") : ("Id", "Id"), "o");
using var db = GetConnection();
var rows = await db.QueryAsync(sql.Query, sql.Params);
#region include storage
var storages = includeStorage
? await AccountRepository.GetStorages(db,
rows.Where(x => x.StorageId != null)
.Select(x => (int)x.StorageId)
.Distinct()
.ToList(),
format)
: null;
#endregion
#region include diffs
var diffs = includeDiffs
? await BigMapsRepository.GetMigrationDiffs(db,
rows.Where(x => x.BigMapUpdates != null)
.Select(x => (int)x.Id)
.ToList(),
format)
: null;
#endregion
return(rows.Select(row => new MigrationOperation
{
Id = row.Id,
Level = row.Level,
Block = row.Hash,
Timestamp = row.Timestamp,
Account = Accounts.GetAlias(row.AccountId),
Kind = MigrationKinds.ToString(row.Kind),
BalanceChange = row.BalanceChange,
Storage = row.StorageId == null ? null : storages?[row.StorageId],
Diffs = row.BigMapUpdates == null ? null : diffs?[row.Id],
Quote = Quotes.Get(quote, row.Level)
}));
}
public async Task <object[][]> GetRevelationPenalties(
AccountParameter baker,
Int32Parameter level,
DateTimeParameter timestamp,
SortParameter sort,
OffsetParameter offset,
int limit,
string[] fields,
Symbols quote)
{
var columns = new HashSet <string>(fields.Length);
var joins = new HashSet <string>(1);
foreach (var field in fields)
{
switch (field)
{
case "id": columns.Add(@"o.""Id"""); break;
case "level": columns.Add(@"o.""Level"""); break;
case "timestamp": columns.Add(@"o.""Timestamp"""); break;
case "baker": columns.Add(@"o.""BakerId"""); break;
case "missedLevel": columns.Add(@"o.""MissedLevel"""); break;
case "lostReward": columns.Add(@"o.""LostReward"""); break;
case "lostFees": columns.Add(@"o.""LostFees"""); break;
case "block":
columns.Add(@"b.""Hash""");
joins.Add(@"INNER JOIN ""Blocks"" as b ON b.""Level"" = o.""Level""");
break;
case "quote": columns.Add(@"o.""Level"""); break;
}
}
if (columns.Count == 0)
{
return(Array.Empty <object[]>());
}
var sql = new SqlBuilder($@"SELECT {string.Join(',', columns)} FROM ""RevelationPenaltyOps"" as o {string.Join(' ', joins)}")
.FilterA(@"o.""BakerId""", baker)
.FilterA(@"o.""Level""", level)
.FilterA(@"o.""Timestamp""", timestamp)
.Take(sort, offset, limit, x => x == "level" ? ("Id", "Level") : ("Id", "Id"), "o");
using var db = GetConnection();
var rows = await db.QueryAsync(sql.Query, sql.Params);
var result = new object[rows.Count()][];
for (int i = 0; i < result.Length; i++)
{
result[i] = new object[fields.Length];
}
for (int i = 0, j = 0; i < fields.Length; j = 0, i++)
{
switch (fields[i])
{
case "id":
foreach (var row in rows)
{
result[j++][i] = row.Id;
}
break;
case "level":
foreach (var row in rows)
{
result[j++][i] = row.Level;
}
break;
case "block":
foreach (var row in rows)
{
result[j++][i] = row.Hash;
}
break;
case "timestamp":
foreach (var row in rows)
{
result[j++][i] = row.Timestamp;
}
break;
case "baker":
foreach (var row in rows)
{
result[j++][i] = await Accounts.GetAliasAsync(row.BakerId);
}
break;
case "missedLevel":
foreach (var row in rows)
{
result[j++][i] = row.MissedLevel;
}
break;
case "lostReward":
foreach (var row in rows)
{
result[j++][i] = row.LostReward;
}
break;
case "lostFees":
foreach (var row in rows)
{
result[j++][i] = row.LostFees;
}
break;
case "quote":
foreach (var row in rows)
{
result[j++][i] = Quotes.Get(quote, row.Level);
}
break;
}
}
return(result);
}
