public async Task <List <DomainReservation> > QueryReservations(QueryReservationCommand cmd)
{
var query = new ReservationQuery();
if (cmd.UserId.HasValue)
{
query.ForOwner(await _users.FindById(cmd.UserId.Value));
}
if (cmd.ResourceId.HasValue)
{
query.ForResource(await _resources.FindById(cmd.ResourceId.Value));
}
query.CollideWith(
cmd.StartTime.GetValueOrDefault(Instant.FromUnixTimeMilliseconds(0)),
cmd.EndTime.GetValueOrDefault(Instant.MaxValue)
);
if (cmd.StatusList != null && cmd.StatusList.Length > 0)
{
query.WithStatuses((await _statuses.All()).Where(st => cmd.StatusList.Contains(st.Status)));
}
return((await _reservations.Query(query))
.Select(r => _mapper.Map <DomainReservation>(r))
.ToList());
}
public void FromUnixTimeMilliseconds_Valid()
{
Instant actual = Instant.FromUnixTimeMilliseconds(12345L);
Instant expected = Instant.FromUnixTimeTicks(12345L * NodaConstants.TicksPerMillisecond);
Assert.AreEqual(expected, actual);
}
protected bool SqliteDataToMarkdownModel(SqliteDataReader reader, MarkdownPage page)
{
page.Id = Guid.Parse(reader.GetString(reader.GetOrdinal("id")));
page.Content = reader.GetString(reader.GetOrdinal("content"));
page.Created = Instant.FromUnixTimeMilliseconds(reader.GetInt64(reader.GetOrdinal("created")));
page.LastChanged = Instant.FromUnixTimeMilliseconds(reader.GetInt64(reader.GetOrdinal("changed")));
page.IsLocked = reader.GetBoolean(reader.GetOrdinal("locked"));
var link = reader.GetString(reader.GetOrdinal("link"));
var path = link.Split(new[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
if (path.Length > 1)
{
string[] path2 = new string[path.Length - 1];
Array.Copy(path, path2, path.Length - 1);
page.Path = Path.of(path2, path[path.Length - 1]);
}
else
{
page.Path = Path.ofLink(link);
}
return(true);
}
public Data()
{
Id = Guid.NewGuid();
var milliseconds = SystemClock.Instance.GetCurrentInstant().ToUnixTimeMilliseconds();
Created = Instant.FromUnixTimeMilliseconds(milliseconds).InZone(provider.GetSystemDefault());
CreatedDateTime = Created.LocalDateTime;
CreatedDate = CreatedDateTime.Date;
CreatedTime = CreatedDateTime.TimeOfDay;
CreatedOffsetDateTime = Created.ToOffsetDateTime();
CreatedOffsetTime = CreatedOffsetDateTime.ToOffsetTime();
Duration = Duration.FromHours(29.5);
var b = new PeriodBuilder
{
Years = 1,
Months = 10,
Weeks = 3,
Days = 4,
Hours = 25,
Minutes = 65,
Seconds = 100,
Milliseconds = 4,
Nanoseconds = 3,
Ticks = 3
};
Period = b.Build();
}
public async Task Flush()
{
var bucketName = _bucket.Name;
var writeOptions = WriteOptions.CreateNew().BatchSize(10).FlushInterval(100_000).Build();
_writeApi = Client.GetWriteApi(writeOptions);
var listener = new WriteApiTest.EventListener(_writeApi);
var record = "h2o_feet,location=coyote_creek level\\ water_level=1.0 1";
_writeApi.WriteRecord(bucketName, _organization.Id, WritePrecision.Ns, record);
_writeApi.Flush();
listener.WaitToSuccess();
var query = await _queryApi.QueryAsync(
$"from(bucket:\"{bucketName}\") |> range(start: 1970-01-01T00:00:00.000000001Z)",
_organization.Id);
Assert.AreEqual(1, query.Count);
var records = query[0].Records;
Assert.AreEqual(1, records.Count);
Assert.AreEqual("h2o_feet", records[0].GetMeasurement());
Assert.AreEqual(1, records[0].GetValue());
Assert.AreEqual("level water_level", records[0].GetField());
var instant = Instant.Add(Instant.FromUnixTimeMilliseconds(0), Duration.FromNanoseconds(1L));
Assert.AreEqual(instant, records[0].GetTime());
}
public IEnumerable <GenericPageHistory> ConvertToHistoryPageModels(SqliteDataReader reader)
{
var pages = new List <GenericPageHistory>();
while (reader.Read())
{
var page = new GenericPage();
if (SqliteDataToPageModel(reader, page))
{
var action = (PageAction)reader.GetInt32(reader.GetOrdinal("action"));
var pageHistory = new GenericPageHistory(page)
{
ValidFrom =
Instant.FromUnixTimeMilliseconds(reader.GetInt64(reader.GetOrdinal("valid_from"))),
ValidTo = Instant.FromUnixTimeMilliseconds(reader.GetInt64(reader.GetOrdinal("valid_to"))),
Action = (PageAction)reader.GetInt16(reader.GetOrdinal("action"))
};
pages.Add(pageHistory);
}
}
return(pages);
}
public void NullableIntervalRoundTripTest()
{
var interval = new Interval(start: Instant.FromJulianDate(0), end: Instant.FromUnixTimeMilliseconds(0));
Assert.That(interval.HasStart);
Assert.That(interval.HasEnd);
RoundTripTest((Interval?)interval);
}
public void IntervalWithStartAndEndRoundTripTest()
{
var interval = new Interval(start: Instant.FromJulianDate(0), end: Instant.FromUnixTimeMilliseconds(0));
Assert.That(interval.HasStart);
Assert.That(interval.HasEnd);
RoundTripTest(interval);
}
/// <summary>
/// Converts a Java Date value to a UTC DateTime value
/// </summary>
/// <param name="javaDate">The Java date</param>
/// <returns></returns>
private static DateTime FromJavaDate(Date javaDate)
{
// Convert javaDate to UTC Instant (Epoch)
var instant = Instant.FromUnixTimeMilliseconds(javaDate.getTime());
// Convert to .Net UTC DateTime
return(instant.ToDateTimeUtc());
}
public void IntervalWithEndRoundTripTest()
{
var interval = new Interval(end: Instant.FromUnixTimeMilliseconds(0), start: null);
Assert.That(!interval.HasStart);
Assert.That(interval.HasEnd);
RoundTripTest(interval);
}
/// <inheritdoc/>
public override async Task Handle(UpdateDailyOutflow command)
{
var root = await _repository.Find <Wallet>(command.Target);
if (root == null)
{
throw new ArgumentNullException(nameof(command.Address));
}
var coin = await _repository.Find <Coin>(root.Coin);
if (coin == null)
{
throw new ArgumentNullException(nameof(root.Coin));
}
var txResults = await GetTransactions(command);
if (txResults == null)
{
return;
}
var outflows = new Dictionary <Instant, (Instant time, double amount)>();
foreach (var tx in txResults)
{
var dateTime = Instant.FromUnixTimeMilliseconds(tx.ReceiveTime).InUtc().LocalDateTime;
var date = new LocalDate(dateTime.Year, dateTime.Month, dateTime.Day);
var instant = date.AtMidnight().InUtc().ToInstant();
var amount = tx.Amount;
if (tx.To == command.Target)
{
amount *= -1;
}
if (outflows.ContainsKey(instant))
{
amount += outflows[instant].amount;
}
outflows[instant] = (Instant.FromUnixTimeMilliseconds(tx.ReceiveTime), amount);
}
ICommand changeBalanceCommand = null;
var idx = 0;
foreach (var v in outflows)
{
changeBalanceCommand = new RetroactiveCommand <ChangeWalletBalance>(new ChangeWalletBalance(command.Address, new Quantity(-v.Value.amount, coin.Asset), $"Out{command.Index}_{idx}"), v.Value.time);
await _balanceHandler.Handle(changeBalanceCommand);
++idx;
}
command.EventType = changeBalanceCommand?.EventType;
}
protected Instant?ExtractTimestampFromFilename(string filename, string regex)
{
var match = Regex.Match(filename, regex);
if (match.Success)
{
return(Instant.FromUnixTimeMilliseconds(long.Parse(match.Groups[1].Value)));
}
return(null);
}
public virtual void SupportsFromFromUnixTimeMilliseconds(TestEntity <long> testEntity)
{
AddToDatabase(testEntity);
var minimum = Instant.FromUnixTimeMilliseconds(testEntity.TestProperty);
ExecuteWithQueryable <TestEntity <long> >(q =>
{
var foundEntities = q.Where(x => Instant.FromUnixTimeMilliseconds(x.TestProperty) == minimum).ToList();
});
}
protected Instant?ExtractTimestamp(JToken obj)
{
var timestampToken = obj["clientMeta"]?["timestamp"];
if (timestampToken == null)
{
return(null);
}
return(Instant.FromUnixTimeMilliseconds(timestampToken.Value <long>()));
}
public async Task PruneAttendance(IMessage message)
{
var zoneId = (await Prompt(message.Author, $"What zone ID? (Hint: {_raidIds.Last().Value})",
message.Channel))?.Content;
var attendanceReports = (await _attendanceRepo.GetAllAsync()).Where(att => att.ZoneId == zoneId && !att.Excluded);
var raidGroupings = attendanceReports.GroupBy(r =>
Instant.FromUnixTimeMilliseconds(r.Timestamp).ToString("yyyy-MM-dd", CultureInfo.InvariantCulture))
.ToList();
foreach (var raids in raidGroupings)
{
if (raids.Count() > 1)
{
var raidsToMerge = string.Join("\n", raids.Select((r, idx) =>
$"[{idx + 1}] {raids.Key} - {r.LogUrl} - {r.Attendees.Count} attendees"));
var response = await Prompt(message.Author,
$"Detected possible duplicate reports.\n\n{raidsToMerge}\n" +
"Pick an action: \n`merge`\n`pick <id>`\n`ignore`",
message.Channel, 60000);
if (response?.Content == "merge")
{
var recordToKeep = raids.First();
foreach (var recordToExclude in raids.Skip(1))
{
recordToKeep.Attendees = recordToKeep.Attendees.Concat(recordToExclude.Attendees)
.Distinct()
.ToList();
recordToExclude.Excluded = true;
_attendanceRepo.AddOrEdit(recordToExclude);
}
_attendanceRepo.AddOrEdit(recordToKeep);
}
else if (response?.Content.StartsWith("pick ") == true)
{
var idx = int.Parse(response.Content.Replace("pick ", "").Trim()) - 1;
var recordToKeep = raids.ElementAt(idx);
foreach (var recordToExclude in raids.Where(r => r.Id != recordToKeep.Id))
{
recordToExclude.Excluded = true;
_attendanceRepo.AddOrEdit(recordToExclude);
}
}
}
}
await message.Channel.SendMessageAsync("✅ Attendance pruned.");
}
private long MidnightTonightInMilliseconds()
{
long now = SystemClock.Instance.GetCurrentInstant().ToUnixTimeMilliseconds();
var nowDateTime = new ZonedDateTime(Instant.FromUnixTimeMilliseconds(now),
DateTimeZoneProviders.Bcl.GetSystemDefault());
return(new LocalDateTime(nowDateTime.Year, nowDateTime.Month, nowDateTime.Day, 23, 59, 59)
.InZoneLeniently(DateTimeZoneProviders.Bcl.GetSystemDefault())
.ToInstant()
.ToUnixTimeMilliseconds());
}
public AggregatorSystem.ProcessedContentAdditions Process(RawContentTransferObject contentTransferObject)
{
var content = new RawContent(Id: Guid.NewGuid(),
RetrieveTime: Instant.FromUnixTimeMilliseconds(contentTransferObject.RetrieveTime),
Type: contentTransferObject.Type,
Content: contentTransferObject.Content,
Context: contentTransferObject.Context,
SourceUri: contentTransferObject.SourceUri);
// TODO: error handling...
return(system.ProcessRawContent(content));
}
public static UserIdentityModel ToDomainIdentityModel(this UserDbEntity dbEntity)
{
var regDate = Instant.FromUnixTimeMilliseconds(dbEntity.RegistrationDate);
return(new UserIdentityModel(
dbEntity.Id,
dbEntity.Email,
dbEntity.Name,
dbEntity.Role,
dbEntity.PasswordHash,
regDate));
}
public static UserModel ToDomainModel(this UserDbEntity dbEntity)
{
var regDate = Instant.FromUnixTimeMilliseconds(dbEntity.RegistrationDate);
return(new UserModel
{
Id = dbEntity.Id,
Email = dbEntity.Email,
Name = dbEntity.Name,
RegistrationDate = regDate
});
}
public void Given_a_valid_Instant_When_WithCreated_is_called_Then_Created_Should_be_set()
{
// Arrange.
IClock clock = ConstantClockStub.Create(0);
BlogPostBuilder builder = BlogPostBuilder.Create(clock);
Instant created = Instant.FromUnixTimeMilliseconds(100000);
// Act.
builder = builder.WithCreated(created);
// Assert.
builder.Created.Should().Be(created);
}
/// <inheritdoc/>
public override async Task Handle(UpdateDailyMining command)
{
var root = await _repository.Find <Wallet>(command.Target);
if (root == null)
{
throw new ArgumentNullException(nameof(command.Address));
}
var coin = await _repository.Find <Coin>(root.Coin);
if (coin == null)
{
throw new ArgumentNullException(nameof(root.Coin));
}
var minedBlocks = await GetMinedBlocks(command);
if (minedBlocks == null)
{
return;
}
var blocks = new Dictionary <Instant, (Instant time, double amount)>();
foreach (var block in minedBlocks)
{
var dateTime = Instant.FromUnixTimeMilliseconds(block.Timestamp).InUtc().LocalDateTime;
var date = new LocalDate(dateTime.Year, dateTime.Month, dateTime.Day);
var instant = date.AtMidnight().InUtc().ToInstant();
var amount = block.Feereward;
if (blocks.ContainsKey(instant))
{
amount += blocks[instant].amount;
}
blocks[instant] = (Instant.FromUnixTimeMilliseconds(block.Timestamp), amount);
}
ICommand mineCommand = null;
var idx = 0;
foreach (var v in blocks)
{
mineCommand = new RetroactiveCommand <MineCoin>(new MineCoin(command.Address, new Quantity(v.Value.amount, coin.Asset), $"Mining{command.Index}_{idx}"), v.Value.time);
await _mineHandler.Handle(mineCommand);
++idx;
}
command.EventType = mineCommand?.EventType;
}
/// <summary>
/// Returns a new <see cref="Tick"/> from the given <see cref="string"/>.
/// </summary>
/// <param name="symbol">The symbol to create the tick with.</param>
/// <param name="values">The string containing tick values.</param>
/// <returns>The created <see cref="Tick"/>.</returns>
public static TradeTick FromSerializableString(Symbol symbol, string values)
{
Debug.NotEmptyOrWhiteSpace(values, nameof(values));
var pieces = values.Split(',', 5);
return(new TradeTick(
symbol,
Price.Create(pieces[0]),
Quantity.Create(pieces[1]),
pieces[2].ToEnum <Maker>(),
new MatchId(pieces[3]),
Instant.FromUnixTimeMilliseconds(Convert.ToInt64(pieces[4])).InUtc()));
}
/// <summary>
/// Returns a new <see cref="Bar"/> from the given <see cref="string"/>.
/// </summary>
/// <param name="barString">The bar string.</param>
/// <returns>The created <see cref="Bar"/>.</returns>
public static Bar FromSerializableString(string barString)
{
Debug.NotEmptyOrWhiteSpace(barString, nameof(barString));
var values = barString.Split(',', 6);
return(new Bar(
Price.Create(Parser.ToDecimal(values[0])),
Price.Create(Parser.ToDecimal(values[1])),
Price.Create(Parser.ToDecimal(values[2])),
Price.Create(Parser.ToDecimal(values[3])),
Quantity.Create(Parser.ToDecimal(values[4])),
Instant.FromUnixTimeMilliseconds(Convert.ToInt64(values[5])).InUtc()));
}
/// <summary>
/// Initializes a new instance of the <see cref="Bar"/> class.
/// </summary>
/// <param name="open">The open price.</param>
/// <param name="high">The high price.</param>
/// <param name="low">The low price.</param>
/// <param name="close">The close price.</param>
/// <param name="volume">The volume.</param>
/// <param name="unixTimestamp">The unix timestamp in milliseconds.</param>
public Bar(
Price open,
Price high,
Price low,
Price close,
Quantity volume,
long unixTimestamp)
{
this.Open = open;
this.High = high;
this.Low = low;
this.Close = close;
this.Volume = volume;
this.Timestamp = Instant.FromUnixTimeMilliseconds(unixTimestamp).InUtc();
}
private AppointmentData UpdateStartEndTimes(AppointmentData input)
{
//Update start time and end time in each appointment
foreach (Appointment appointment in input.data)
{
Duration duration = Duration.FromHours(1);
Instant startTime = Instant.FromUnixTimeMilliseconds(Convert.ToInt64(appointment.date));
Instant endTime = startTime + duration;
var timeZone = DateTimeZoneProviders.Tzdb["America/New_York"];
appointment.startTime = startTime.InZone(timeZone).LocalDateTime.ToString("hh:mm tt", CultureInfo.InvariantCulture);
appointment.endTime = endTime.InZone(timeZone).LocalDateTime.ToString("hh:mm tt", CultureInfo.InvariantCulture);
}
return(input);
}
public void UnixConversions_ExtremeValues()
{
// Round down to a whole second to make round-tripping work.
var max = Instant.MaxValue - Duration.FromSeconds(1) + Duration.Epsilon;
Assert.AreEqual(max, Instant.FromUnixTimeSeconds(max.ToUnixTimeSeconds()));
Assert.AreEqual(max, Instant.FromUnixTimeMilliseconds(max.ToUnixTimeMilliseconds()));
Assert.AreEqual(max, Instant.FromUnixTimeTicks(max.ToUnixTimeTicks()));
var min = Instant.MinValue;
Assert.AreEqual(min, Instant.FromUnixTimeSeconds(min.ToUnixTimeSeconds()));
Assert.AreEqual(min, Instant.FromUnixTimeMilliseconds(min.ToUnixTimeMilliseconds()));
Assert.AreEqual(min, Instant.FromUnixTimeTicks(min.ToUnixTimeTicks()));
}
public override Instant?Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
{
BsonType type = context.Reader.GetCurrentBsonType();
if (type == BsonType.Null)
{
context.Reader.ReadNull();
return(null);
}
if (type == BsonType.DateTime)
{
return(Instant.FromUnixTimeMilliseconds(context.Reader.ReadDateTime()));
}
throw CreateCannotBeDeserializedException();
}
public JObject ToJson(LookupContext ctx, APIVersion v)
{
var o = new JObject();
o.Add("timestamp", Instant.FromUnixTimeMilliseconds((long)(Message.Mid >> 22) + 1420070400000).ToString());
o.Add("id", Message.Mid.ToString());
o.Add("original", Message.OriginalMid.ToString());
o.Add("sender", Message.Sender.ToString());
o.Add("channel", Message.Channel.ToString());
o.Add("guild", Message.Guild?.ToString());
o.Add("system", System?.ToJson(ctx, v));
o.Add("member", Member?.ToJson(ctx, v: v));
return(o);
}
public OffsetTime Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
{
var bsonType = context.Reader.GetCurrentBsonType();
if (bsonType != BsonType.Document)
{
throw new InvalidOperationException($"{bsonType} is not a document.");
}
context.Reader.ReadStartDocument();
var dtValue = context.Reader.ReadDateTime("time");
var offSetNanoSeconds = context.Reader.ReadInt64("offset");
context.Reader.ReadEndDocument();
return(Instant.FromUnixTimeMilliseconds(dtValue).WithOffset(Offset.FromNanoseconds(offSetNanoSeconds)).ToOffsetTime());
}
private DateTime GetCurrentPlaybackTime()
{
lock (PlaybackLock)
{
var now = SystemClock.Instance.GetCurrentInstant();
if (_anchorTime == 0 && _initiatedTime == 0)
{
return(now.ToDateTimeUtc());
}
var current = now.ToUnixTimeTicks() / NodaConstants.TicksPerMillisecond;
long currentAnchor = ((long)((current - _initiatedTime) * _scale) + _anchorTime);
Instant whereWeShouldBe = Instant.FromUnixTimeMilliseconds(currentAnchor);
return(whereWeShouldBe.ToDateTimeUtc());
}
}