public async Task <IEnumerable <Statistics> > Get(
StatisticsPeriod period,
Int32Parameter cycle,
Int32Parameter level,
TimestampParameter timestamp,
DateTimeParameter date,
SortParameter sort,
OffsetParameter offset,
int limit,
Symbols quote)
{
var sql = new SqlBuilder(@"SELECT * FROM ""Statistics""");
if (period == StatisticsPeriod.Cyclic)
{
sql.Filter(@"""Cycle"" IS NOT NULL");
}
else if (period == StatisticsPeriod.Daily)
{
sql.Filter(@"""Date"" IS NOT NULL");
}
sql.Filter("Cycle", cycle)
.Filter("Level", level)
.Filter("Level", timestamp)
.Filter("Date", date)
.Take(sort, offset, limit, x => x switch
{
"level" => ("Level", "Level"),
"cycle" => ("Cycle", "Cycle"),
"date" => ("Date", "Date"),
_ => ("Id", "Id")
});
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 <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 <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)
}));
}
/// <summary>
/// 煤车篷布资讯
/// </summary>
/// <param name="pageIndex"></param>
/// <param name="pageSize"></param>
/// <param name="id"></param>
/// <returns></returns>
public ActionResult Index(int pageIndex = 1, int pageSize = 5, int?id = 0)
{
ViewData["pageIndex"] = pageIndex;
ViewData["pageSize"] = pageSize;
ViewData["total"] = 0;
int totalcount = 0;
List <newst> list = new List <newst>();
// list = newsbll.getall();
StringBuilder where = new StringBuilder();
where.Append(" and del =1");
SortParameter sa = new SortParameter();
sa.Field = "creationtime";
sa.Direction = SortDirection.DESC;
SortParameters ot = new SortParameters();
ot.Add(sa);
list = newsbll.GetPage(out totalcount, pageIndex, pageSize, where.ToString(), "", ot);
ViewData["total"] = totalcount;
return(View(list));
}
public async Task <ActionResult <IEnumerable <BigMapKeyUpdate> > > GetKeyUpdates(
[Min(0)] int id,
[Required] string key,
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
try
{
if (Regex.IsMatch(key, @"^expr[0-9A-z]{50}$"))
{
return(Ok(await BigMaps.GetKeyByHashUpdates(id, key, sort, offset, limit, micheline)));
}
using var doc = JsonDocument.Parse(WrapKey(key));
return(Ok(await BigMaps.GetKeyUpdates(id, doc.RootElement.GetRawText(), sort, offset, limit, micheline)));
}
catch (JsonException)
{
return(new BadRequest(nameof(key), "invalid json value"));
}
catch
{
throw;
}
}
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)));
}
/// <summary>
/// Gestione dell'evento di click del mouse
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void SortingHandler(object sender, DataGridSortingEventArgs e)
{
SortParameter sp = new SortParameter()
{
Path = e.Column.SortMemberPath
};
switch (e.Column.SortDirection)
{
case ListSortDirection.Ascending:
sp.Direction = ListSortDirection.Descending;
break;
case ListSortDirection.Descending:
sp.Direction = ListSortDirection.Ascending;
break;
default:
sp.Direction = ListSortDirection.Ascending;
break;
}
//exec command
Command?.Execute(sp);
e.Handled = false;
}
public async Task <IEnumerable <Cycle> > Get(
Int32Parameter snapshotIndex,
SortParameter sort,
OffsetParameter offset,
int limit,
Symbols quote)
{
var sql = new SqlBuilder(@"SELECT * FROM ""Cycles""")
.Filter("SnapshotIndex", snapshotIndex)
.Take(sort ?? new SortParameter {
Desc = "index"
}, offset, limit, x => ("Index", "Index"));
using var db = GetConnection();
var rows = await db.QueryAsync(sql.Query, sql.Params);
return(rows.Select(row => new Cycle
{
Index = row.Index,
FirstLevel = row.FirstLevel,
StartTime = Times[row.FirstLevel],
LastLevel = row.LastLevel,
EndTime = Times[row.LastLevel],
RandomSeed = row.Seed,
SnapshotIndex = row.SnapshotIndex,
SnapshotLevel = row.SnapshotLevel,
TotalBakers = row.TotalBakers,
TotalDelegated = row.TotalDelegated,
TotalDelegators = row.TotalDelegators,
TotalRolls = row.TotalRolls,
TotalStaking = row.TotalStaking,
Quote = Quotes.Get(quote, row.LastLevel)
}));
}
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 Response MessageReport(MessageReportDataSourceContext data)
{
Assert.ArgumentNotNull(data, "requestArgs");
DataPage page = new DataPage
{
Index = data.PageIndex,
Size = data.PageSize
};
SortParameter sortParameter = this.sortParameterFactory.Create(data.Sorting);
switch (data.Type)
{
case "{B25B894F-867D-4F49-A4D8-CFFFAB28C46D}":
return(this.GetBestEmailLandingPagesReportResponse(data.MessageId, data.Language, sortParameter));
case "{FCA32D8F-7D95-41E7-9F25-B69D620D1680}":
return(this.GetEmailLandingPagesReportResponse(data.MessageId, data.Language, sortParameter, page));
case "{5164EF31-7CF5-47A5-8B5B-2EDFB59FD93C}":
return(this.GetUnsubscribedDetailsReportResponse(data.MessageId, data.Language, page, data.UtcOffset));
case "{3C101F2E-2D9A-4A31-82A0-FAB3C979914B}":
return(this.GetEmailBouncesDetailsReportResponse(data.MessageId, data.Language, page, data.UtcOffset));
case "{B8736652-76C6-428E-840D-67E363E593F8}":
return(this.GetMessagePerformancePerLanguageReportResponse(data.MessageId));
}
return(new MessageReportResponse <object>
{
Results = new object[0],
TotalCount = 0
});
}
private SortParameter GetSortParameter()
{
SortParameter sortParam;
switch (sortBy.SelectedIndex)
{
case 1:
sortParam = new SortParameter(FieldToSort.Popularity, false);
break;
case 2:
sortParam = new SortParameter(FieldToSort.Price, false);
break;
case 3:
sortParam = new SortParameter(FieldToSort.Price, true);
break;
case 4:
sortParam = new SortParameter(FieldToSort.Novelity, false);
break;
default:
sortParam = new SortParameter(FieldToSort.Name, true);
break;
}
return(sortParam);
}
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 <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 DateTime LastPublished(string[] schemaUris)
{
TcmUri schemaTcmUri = new TcmUri(schemaUris.First());
PublicationCriteria publicationCriteria = new PublicationCriteria(schemaTcmUri.PublicationId);
Criteria[] schemaCriterias = schemaUris
.Select(uri => new ItemSchemaCriteria(new TcmUri(uri).ItemId))
.ToArray();
Criteria basedOnSchema = CriteriaFactory.Or(schemaCriterias);
Criteria basedOnSchemaAndInPublication = CriteriaFactory.And(publicationCriteria, basedOnSchema);
Query q = new Query(basedOnSchemaAndInPublication);
SortParameter sortParameter = new SortParameter(SortParameter.ItemLastPublishedDate, SortParameter.Descending);
q.AddSorting(sortParameter);
q.AddLimitFilter(new LimitFilter(1));
string[] foundUris = q.ExecuteQuery();
if (foundUris.Length > 0)
{
using (Tridion.ContentDelivery.Meta.ComponentMetaFactory fac = new Tridion.ContentDelivery.Meta.ComponentMetaFactory(schemaTcmUri.PublicationId))
{
Tridion.ContentDelivery.Meta.IComponentMeta meta = fac.GetMeta(foundUris[0]);
return(meta.LastPublicationDate);
}
}
return(DateTime.MinValue);
}
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 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 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 async Task <IEnumerable <Protocol> > Get(SortParameter sort, OffsetParameter offset, int limit)
{
var sql = new SqlBuilder(@"SELECT * FROM ""Protocols""")
.Take(sort, offset, limit, x => x switch
{
"code" => ("Id", "Code"),
"firstLevel" => ("Id", "FirstLevel"),
"lastLevel" => ("Id", "LastLevel"),
_ => ("Id", "Id")
});
public void SortParameter002()
{
// Arrange
var expressionCache = new ExpressionCache <TestDocument>();
var expressionBuilder = (IExpressionBuilder <TestDocument>) new ExpressionBuilder <TestDocument>(expressionCache);
var parameter = new SortParameter <TestDocument>(expressionBuilder);
// Act / Assert
Assert.Throws <ArgumentNullException>(() => parameter.Configure(null, true));
}
public async Task <IEnumerable <Software> > Get(SortParameter sort, OffsetParameter offset, int limit)
{
var sql = new SqlBuilder(@"SELECT * FROM ""Software""")
.Take(sort, offset, limit, x => x switch
{
"firstLevel" => ("FirstLevel", "FirstLevel"),
"lastLevel" => ("LastLevel", "LastLevel"),
"blocksCount" => ("BlocksCount", "BlocksCount"),
_ => ("Id", "Id")
});
public ActionResult videoList(int pageIndex = 1, int pageSize = 10)
{
List <video> list = new List <sjth.Model.video>();
List <video> li = new List <video>();
ViewData["pageIndex"] = pageIndex;
ViewData["pageSize"] = pageSize;
ViewData["total"] = 0;
string name = Request["name"];
string start = Request["start"];
string end = Request["end"];
try
{
StringBuilder where = new StringBuilder();
where.Append(" and del =1 ");
if (!string.IsNullOrWhiteSpace(name))
{
where.Append(" and name like'%" + name.Trim() + "%'");
}
if (!string.IsNullOrWhiteSpace(start) && !string.IsNullOrWhiteSpace(end))
{
//where.Append(" and creationtime>='" + start + "'");
//creationtime between '2016-12-07' and '2016-12-08 23:59:59'
where.Append(" and datatimes between '" + start + "' and '" + end + " 23:59:59'");
}
if (!string.IsNullOrWhiteSpace(start) && string.IsNullOrWhiteSpace(end))
{
where.Append(" and datatimes>='" + start + "'");
}
if (string.IsNullOrWhiteSpace(start) && !string.IsNullOrWhiteSpace(end))
{
where.Append(" and datatimes<='" + end + " 23:59:59'");
}
SortParameter sa = new SortParameter();
sa.Field = "datatimes";
sa.Direction = SortDirection.DESC;
SortParameters ot = new SortParameters();
ot.Add(sa);
int totalcount = 0;
list = _video.GetPage(out totalcount, pageIndex, pageSize, where.ToString(), "", ot);
// list = newsbll.getall();
ViewData["total"] = totalcount;
// list = _video.allList();
return(View(list));
}
catch (Exception)
{
return(View(list));
}
}
protected ProductCollection GetProducts()
{
string productName = CommonHelper.QueryString("searchParameter");
SortParameter sortParameter = GetSortParameter();
ProductCollection products = ProductManager.GetAllProducts(0, 0, null, null, null,
productName, false, pageSize, CurrentPageIndex,
null, (int)sortParameter.SortBy, sortParameter.Ascending,
out totalItemCount);
return(products);
}
public async Task <object[]> GetPeriods(SortParameter sort, OffsetParameter offset, int limit, string field)
{
var columns = new HashSet <string>(1);
switch (field)
{
case "kind": columns.Add(@"""Kind"""); break;
case "firstLevel": columns.Add(@"""StartLevel"""); break;
case "lastLevel": columns.Add(@"""EndLevel"""); break;
}
if (columns.Count == 0)
{
return(Array.Empty <object>());
}
var sql = new SqlBuilder($@"SELECT {string.Join(',', columns)} FROM ""VotingPeriods""")
.Take(sort, offset, limit, x => ("Id", "Id"));
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 "kind":
foreach (var row in rows)
{
result[j++] = KindToString(row.Kind);
}
break;
case "firstLevel":
foreach (var row in rows)
{
result[j++] = row.StartLevel;
}
break;
case "lastLevel":
foreach (var row in rows)
{
result[j++] = row.EndLevel;
}
break;
}
return(result);
}
public async Task <IEnumerable <Block> > Get(SortParameter sort, OffsetParameter offset, int limit)
{
var sql = new SqlBuilder(@"SELECT ""Level"", ""Hash"", ""Timestamp"", ""ProtoCode"", ""Priority"", ""Validations"", ""Operations"", ""Reward"", ""Fees"", ""BakerId"", ""RevelationId"" FROM ""Blocks""")
.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 <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 <IEnumerable <HistoricalBalance> > Get(
string address,
int step,
SortParameter sort,
int offset,
int limit,
Symbols quote)
{
var account = await Accounts.GetAsync(address);
if (account == null)
{
return(Enumerable.Empty <HistoricalBalance>());
}
var union = SelectUnion(account);
if (union.Length == 0)
{
return(Enumerable.Empty <HistoricalBalance>());
}
var key = step > 1
? @"(""Level"" + @step - 1) / @step * @step"
: @"""Level""";
var orderBy = sort?.Desc == "level" ? "ORDER BY lvl DESC" : "";
var sql = $@"
SELECT lvl as ""Level"", (SUM(""Change"") OVER (ORDER BY lvl asc))::bigint as ""Balance""
FROM (
SELECT {key} as lvl, SUM(""Change"")::bigint as ""Change""
FROM ({union}) as u
GROUP BY lvl
ORDER BY lvl
) as gr
WHERE lvl <= {State.Current.Level}
{orderBy}
OFFSET @offset
LIMIT @limit";
using var db = GetConnection();
var rows = await db.QueryAsync(sql, new { account = account.Id, step, offset, limit });
return(rows.Select(row => new HistoricalBalance
{
Level = row.Level,
Timestamp = Time[row.Level],
Balance = row.Balance,
Quote = Quotes.Get(quote, row.Level)
}));
}
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 <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 override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
try
{
JObject jObject = JObject.Load(reader);
SortParameter sp = new SortParameter(jObject.Properties().ElementAt(0).Name
, (ListSortDirection)Enum.Parse(typeof(ListSortDirection), (string)jObject.Properties().ElementAt(0).Value));
return sp;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Sorts a DBObjectCollection so that the order of its items corresponds
/// to the position of these items along the axis parameter.
/// </summary>
/// <param name="entities">Entities that will be sorted.</param>
/// <param name="axis">Axis along which the entities will be sorted.</param>
/// <param name="sortParameter">Defines what point in the object's GeometricExtents will be used to sort.</param>
/// <remarks>The entity's position is obtained from the GeometricExtents and uses what the sortParameter indicates.</remarks>
public static DBObjectCollection SortEntities(DBObjectCollection entities, Axis axis, SortParameter sortParameter)
{
DBObject[] entitiesArray = new DBObject[entities.Count];
double[] positions = new double[entities.Count];
for (int i = 0; i < entities.Count; i++)
{
Entity entity = (Entity)entities[i];
entitiesArray[i] = entity;
switch (axis)
{
case Axis.X:
switch (sortParameter)
{
case SortParameter.MinPoint:
positions[i] = entity.GeometricExtents.MinPoint.X;
break;
case SortParameter.CenterPoint:
positions[i] = (entity.GeometricExtents.MinPoint.X + entity.GeometricExtents.MaxPoint.X) / 2;
break;
case SortParameter.MaxPoint:
positions[i] = entity.GeometricExtents.MinPoint.X;
break;
default:
break;
}
break;
case Axis.Y:
switch (sortParameter)
{
case SortParameter.MinPoint:
positions[i] = entity.GeometricExtents.MinPoint.Y;
break;
case SortParameter.CenterPoint:
positions[i] = (entity.GeometricExtents.MinPoint.Y + entity.GeometricExtents.MaxPoint.Y) / 2;
break;
case SortParameter.MaxPoint:
positions[i] = entity.GeometricExtents.MinPoint.Y;
break;
default:
break;
}
break;
case Axis.Z:
switch (sortParameter)
{
case SortParameter.MinPoint:
positions[i] = entity.GeometricExtents.MinPoint.Z;
break;
case SortParameter.CenterPoint:
positions[i] = (entity.GeometricExtents.MinPoint.Z + entity.GeometricExtents.MaxPoint.Z) / 2;
break;
case SortParameter.MaxPoint:
positions[i] = entity.GeometricExtents.MinPoint.Z;
break;
default:
break;
}
break;
}
}
Array.Sort(positions, entitiesArray);
DBObjectCollection sortedEntities = new DBObjectCollection();
for (int i = 0; i < entitiesArray.Length; i++)
{
sortedEntities.Add(entitiesArray[i]);
}
return sortedEntities;
}
public Tridion.ContentDelivery.DynamicContent.Query.Query ToTridionQuery()
{
string[] basedOnSchemas = QuerySchemas;
DateTime lastPublishedDate = LastPublishedDate;
IList<MetaQueryItem> metaQueryItems = MetaQueryValues;
QueryLogic metaQueryLogic = MetaQueryLogic;
int maxmimumComponents = MaximumComponents;
Query q = null;
//PublicationCriteria publicationAndLastPublishedDateCriteria = new PublicationCriteria(PublicationId);
PublicationCriteria publicationAndLastPublishedDateCriteria = new PublicationCriteria(PublicationId);
//format DateTime // 00:00:00.000
ItemLastPublishedDateCriteria dateLastPublished = new ItemLastPublishedDateCriteria(lastPublishedDate.ToString("yyyy-MM-dd HH:mm:ss.fff"), Criteria.GreaterThanOrEqual);
//publicationAndLastPublishedDateCriteria.AddCriteria(dateLastPublished);
Criteria basedOnSchemaAndInPublication;
if (basedOnSchemas.Length > 0)
{
Criteria[] schemaCriterias = new Criteria[basedOnSchemas.Length];
int i = 0;
foreach (var schema in basedOnSchemas)
{
TcmUri schemaUri = new TcmUri(schema);
schemaCriterias.SetValue(new ItemSchemaCriteria(schemaUri.ItemId), i);
i++;
}
Criteria basedOnSchema = CriteriaFactory.Or(schemaCriterias);
basedOnSchemaAndInPublication = CriteriaFactory.And(publicationAndLastPublishedDateCriteria, basedOnSchema);
}
else
{
basedOnSchemaAndInPublication = publicationAndLastPublishedDateCriteria;
}
// Add filtering for meta data
Criteria schemasAndMetaData;
if (metaQueryItems.Count > 0)
{
Criteria metaQuery;
Criteria[] metaCriterias = new Criteria[metaQueryItems.Count];
int metaCount = 0;
foreach (MetaQueryItem queryItem in metaQueryItems)
{
CustomMetaKeyCriteria metaField = new CustomMetaKeyCriteria(queryItem.MetaField);
CustomMetaValueCriteria metaCriteria;
FieldOperator metaOperator = typeof(Criteria).GetField(queryItem.MetaOperator.ToString()).GetValue(null) as FieldOperator;
switch (queryItem.MetaValue.GetType().Name)
{
case "DateTime":
DateTime tempDate = (DateTime)queryItem.MetaValue;
metaCriteria = new CustomMetaValueCriteria(metaField, tempDate.ToString("yyyy-MM-dd HH:mm:ss.fff"), "yyyy-MM-dd HH:mm:ss.SSS", metaOperator);
break;
case "Float":
metaCriteria = new CustomMetaValueCriteria(metaField, (float)queryItem.MetaValue, metaOperator);
break;
case "String":
metaCriteria = new CustomMetaValueCriteria(metaField, queryItem.MetaValue as string, metaOperator);
break;
default:
throw new System.Exception("Unexpected query item data type; " + queryItem.MetaValue.GetType().Name);
}
metaCriterias.SetValue(metaCriteria, metaCount);
metaCount++;
}
if (MetaQueryLogic == QueryLogic.AllCriteriaMatch)
{
metaQuery = CriteriaFactory.And(metaCriterias);
}
else
{
metaQuery = CriteriaFactory.Or(metaCriterias);
}
schemasAndMetaData = CriteriaFactory.And(basedOnSchemaAndInPublication, metaQuery);
}
else
{
schemasAndMetaData = basedOnSchemaAndInPublication;
}
Criteria allConditions;
if (KeywordValues.Count > 0)
{
Criteria[] keywordCriterias = new Criteria[KeywordValues.Count];
int keywordCount = 0;
foreach (KeywordItem keyCriteria in KeywordValues)
{
TaxonomyKeywordCriteria keywordField = new TaxonomyKeywordCriteria(keyCriteria.CategoryUri, keyCriteria.KeywordUri, false);
keywordCriterias.SetValue(keywordField, keywordCount);
keywordCount++;
}
Criteria keyQuery;
if (KeywordQueryLogic == QueryLogic.AllCriteriaMatch)
{
keyQuery = CriteriaFactory.And(keywordCriterias);
}
else
{
keyQuery = CriteriaFactory.Or(keywordCriterias);
}
allConditions = CriteriaFactory.And(schemasAndMetaData, keyQuery);
}
else
{
allConditions = schemasAndMetaData;
}
q = new Query(allConditions);
if (maxmimumComponents != 0 && maxmimumComponents != int.MaxValue)
{
LimitFilter limitResults = new LimitFilter(maxmimumComponents);
q.SetResultFilter(limitResults);
}
// Sort column should either be a standard or custom metaData field
SortColumn paramSort;
if (typeof(SortParameter).GetField(QuerySortField) != null)
{
paramSort = typeof(SortParameter).GetField(QuerySortField).GetValue(null) as SortColumn;
}
else
{
// Why do we need to tell Tridion what data type the field is! Its in the database already!
paramSort = new CustomMetaKeyColumn(QuerySortField, typeof(MetadataType).GetField(SortType.ToString()).GetValue(null) as MetadataType);
}
SortDirection paramSortDirection = typeof(SortParameter).GetField(QuerySortOrder.ToString()).GetValue(null) as SortDirection;
SortParameter sortParameter = new SortParameter(paramSort, paramSortDirection);
q.AddSorting(sortParameter);
return q;
}
private SortParameter GetSortParameter()
{
SortParameter sortParam;
switch (sortBy.SelectedIndex)
{
case 1:
sortParam = new SortParameter(FieldToSort.Popularity, false);
break;
case 2:
sortParam = new SortParameter(FieldToSort.Price, false);
break;
case 3:
sortParam = new SortParameter(FieldToSort.Price, true);
break;
case 4:
sortParam = new SortParameter(FieldToSort.Novelity, false);
break;
default:
sortParam = new SortParameter(FieldToSort.Name, true);
break;
}
return sortParam;
}
public DateTime LastPublished(string[] schemaUris)
{
TcmUri schemaTcmUri = new TcmUri(schemaUris.First());
PublicationCriteria publicationCriteria = new PublicationCriteria(schemaTcmUri.PublicationId);
Criteria[] schemaCriterias = schemaUris
.Select(uri => new ItemSchemaCriteria(new TcmUri(uri).ItemId))
.ToArray();
Criteria basedOnSchema = CriteriaFactory.Or(schemaCriterias);
Criteria basedOnSchemaAndInPublication = CriteriaFactory.And(publicationCriteria, basedOnSchema);
Query q = new Query(basedOnSchemaAndInPublication);
SortParameter sortParameter = new SortParameter(SortParameter.ItemLastPublishedDate, SortParameter.Descending);
q.AddSorting(sortParameter);
q.AddLimitFilter(new LimitFilter(1));
string[] foundUris = q.ExecuteQuery();
if (foundUris.Length > 0)
{
using (Tridion.ContentDelivery.Meta.ComponentMetaFactory fac = new Tridion.ContentDelivery.Meta.ComponentMetaFactory(schemaTcmUri.PublicationId))
{
Tridion.ContentDelivery.Meta.IComponentMeta meta = fac.GetMeta(foundUris[0]);
return meta.LastPublicationDate;
}
}
return DateTime.MinValue;
}
private string[] FindComponentUrisBySchemas(string[] schemaUris, int? limit, DateTime? sinceLastPublished)
{
TcmUri schemaTcmUri = new TcmUri(schemaUris.First());
PublicationCriteria publicationCriteria = new PublicationCriteria(schemaTcmUri.PublicationId);
Criteria[] schemaCriterias = schemaUris
.Select(uri => new ItemSchemaCriteria(new TcmUri(uri).ItemId))
.ToArray();
Criteria basedOnSchema = CriteriaFactory.Or(schemaCriterias);
Criteria basedOnSchemaAndInPublication = CriteriaFactory.And(publicationCriteria, basedOnSchema);
if (sinceLastPublished.HasValue)
{
ItemLastPublishedDateCriteria dateLastPublished = new ItemLastPublishedDateCriteria(sinceLastPublished.Value.ToString("yyyy-MM-dd hh:mm:ss"), Criteria.GreaterThanOrEqual);
basedOnSchemaAndInPublication = CriteriaFactory.And(basedOnSchemaAndInPublication, dateLastPublished);
}
Query q = new Query(basedOnSchemaAndInPublication);
SortParameter sortParameter = new SortParameter(SortParameter.ItemLastPublishedDate, SortParameter.Descending);
q.AddSorting(sortParameter);
if (limit.HasValue && limit.Value > 0)
{
q.AddLimitFilter(new LimitFilter(limit.Value));
}
else
{
q.AddLimitFilter(new LimitFilter(maximumComponent));
}
return q.ExecuteQuery();
}
