public async Task <Metric> CreateAsync(CreateMetricRequest request)
{
Ensure.NotNull(request, nameof(request));
var id = await db.Metrics.Sequence.NextAsync();
var metric = new Metric(
id: id,
ownerId: request.OwnerId,
name: request.Name,
type: request.Type,
unit: request.Unit
);
await db.Metrics.InsertAsync(metric);
if (request.Dimensions != null)
{
var dimensions = new MetricDimension[request.Dimensions.Length];
for (var i = 0; i < dimensions.Length; i++)
{
dimensions[i] = new MetricDimension(
id: ScopedId.Create(metric.Id, i + 1),
name: request.Name
);
}
await db.MetricDimensions.InsertAsync(dimensions);
}
return(metric);
}
public Task <IReadOnlyList <DatabaseBackup> > ListAsync(IDatabaseInfo database)
{
Ensure.NotNull(database, nameof(database));
var range = ScopedId.GetRange(database.Id);
return(db.DatabaseBackups.QueryAsync(Between("id", range.Start, range.End), Order.Descending("id")));
}
public static async Task <long> NextAsync(IDbContext context, long programId)
{
using (var connection = await context.GetConnectionAsync())
{
var currentReleaseCount = await connection.ExecuteScalarAsync <int>(sql, new { id = programId });
return(ScopedId.Create(programId, currentReleaseCount + 1));
}
}
public static async Task <long> NextAsync(IDbContext context, long domainId)
{
using (var connection = await context.GetConnectionAsync())
{
var currentValue = await connection.ExecuteScalarAsync <int>(sql, new { id = domainId });
return(ScopedId.Create(domainId, currentValue + 1));
}
}
public Task <IReadOnlyList <RepositoryCommit> > ListAsync(IRepository repository)
{
var range = ScopedId.GetRange(repository.Id);
return(db.RepositoryCommits.QueryAsync(
Between("id", range.Start, range.End),
order: Order.Descending("id")
));
}
public Task <IReadOnlyList <DatabaseGrant> > ListAsync(IDatabaseInfo database)
{
Ensure.NotNull(database, nameof(database));
var range = ScopedId.GetRange(database.Id);
return(db.DatabaseGrants.QueryAsync(
And(Between("id", range.Start, range.End), IsNull("deleted"))
));
}
public async Task <IReadOnlyList <DomainRecord> > ListAsync(IDomain domain)
{
var range = ScopedId.GetRange(domain.Id);
// order?
return(await db.DomainRecords.QueryAsync(
And(Between("id", range.Start, range.End), IsNull("deleted"))
));
}
public Task <IReadOnlyList <DomainAuthorization> > ListAsync(IDomain domain)
{
Ensure.NotNull(domain, nameof(domain));
var range = ScopedId.GetRange(domain.Id);
return(db.DomainAuthorizations.QueryAsync(
Expression.Between("id", range.Start, range.End)
));
}
public static async Task <long> GetNextScopedIdAsync <T>(this Dataset <T, long> dataset, long scopeId)
{
var range = ScopedId.GetRange(scopeId);
// should be max id in range...
var count = await dataset.CountAsync(
Expression.Between("id", range.Start, range.End)
);
return(ScopedId.Create(scopeId, count));
}
/// <summary>
/// Converts the specified id into a new Id. If we've already converted this id,
/// then returns the original conversion. This method is for creating outgoing
/// ids.
/// </summary>
/// <param name="scope">The scope for the id. For example, for an auto-incrementing
/// int id in a table, this might be the table name. This is how we can distinguish
/// between two ids that might be the same.</param>
/// <param name="originalId"></param>
/// <returns></returns>
public string GetConvertedId(string scope, string originalId)
{
ScopedId scopedId = new ScopedId(scope, originalId);
string convertedId;
if(this.idMap.TryGetValue(scopedId, out convertedId))
return convertedId;
convertedId = Generate(scope, originalId);
this.idMap.Add(scopedId, convertedId);
return convertedId;
}
public async Task <DomainAuthorization> GetLatestAsync(IDomain domain)
{
Ensure.NotNull(domain, nameof(domain));
var range = ScopedId.GetRange(domain.Id);
return((await db.DomainAuthorizations.QueryAsync(
Expression.Between("id", range.Start, range.End),
order: Order.Descending("id"),
take: 1
)).FirstOrDefault());
}
public Task <IReadOnlyList <DatabaseGrant> > ListAsync(IDatabaseInfo database, IUser user)
{
Ensure.NotNull(database, nameof(database));
Ensure.NotNull(user, nameof(user));
var range = ScopedId.GetRange(database.Id);
return(db.DatabaseGrants.QueryAsync(
Conjunction(
Between("id", range.Start, range.End),
Eq("userId", user.Id),
IsNull("deleted")
)
));
}
public void B()
{
var name = DomainName.Parse("www.processor.ai");
var record = new DomainRecord(
id: ScopedId.Create(456, 1),
name: "www",
path: name.Path,
type: DnsRecordType.A,
value: "192.168.1.1",
ttl: 600,
flags: DomainRecordFlags.None
);
Assert.Equal(1912602625, record.Id);
Assert.Equal("www", record.Name);
Assert.Equal("ai/processor/www", record.Path);
Assert.Equal(456, record.DomainId);
Assert.Equal(1, (int)record.Type);
Assert.Equal("192.168.1.1", record.Value);
Assert.Equal(600, record.Ttl);
}
public static Uid Create(long accountId, DateTimeOffset timestamp, long sequenceNumber)
{
#region Preconditions
if (accountId < 0)
{
throw new ArgumentException("Must be >= 0", nameof(accountId));
}
if (sequenceNumber < 0)
{
throw new ArgumentException("Must be >= 0", nameof(sequenceNumber));
}
#endregion
var(hours, milliseconds) = Timestamp.Split(timestamp.ToUnixTimeMilliseconds());
return(new Uid(
upper: (ulong)ScopedId.Create(accountId, (int)hours),
lower: RequestIdLower.Create((ulong)milliseconds, (ulong)sequenceNumber)
));
}
