public static bool IsInSamePeriodAs(this DateTime instance, DateTime date, UnitOfTime unitOfTime) { if (instance.Year == date.Year && instance.Month == date.Month) { if (unitOfTime == UnitOfTime.Month) { return(true); } else if (unitOfTime == UnitOfTime.Day) { if (instance.Day == date.Day) { return(true); } } else if (unitOfTime == UnitOfTime.Hour) { if (instance.Day == date.Day && instance.Hour == date.Hour) { return(true); } } } return(false); }
public static object GetGroupBy(DateTime date, UnitOfTime uot) { if (uot == UnitOfTime.Month) { return(new { date.Year, date.Month }); } if (uot == UnitOfTime.Day) { return(new { date.Year, date.Month, date.Day }); } return(new { date.Year, date.Month, date.Day, date.Hour }); }
public double AveragePer(UnitOfTime unitOfTime) { var total = this.Total(); if (total > 0) { var since = this.db.Transactions .Where(x => x.Timestamp != 0) .OrderBy(x => x.Timestamp) .Select(x => x.Timestamp) .First().ToUnixDate(); var end = this.db.Transactions .Where(x => x.Timestamp != 0) .OrderByDescending(x => x.Timestamp) .Select(x => x.Timestamp) .First().ToUnixDate(); double timeFrames = 1; if (unitOfTime == UnitOfTime.Hour) { timeFrames = (end - since).TotalHours; } if (unitOfTime == UnitOfTime.Day) { timeFrames = (end - since).TotalDays; } var result = total / timeFrames; return(result); } return(0); }
public int CreatedAddressesCountForLast(UnitOfTime unit = UnitOfTime.Day) { // Skipping this date untill fully synced with blockchain //var date = DateTime.UtcNow; var date = this.db.Addresses .OrderByDescending(x => x.FirstTransactionOn) .Select(x => x.FirstTransactionOn) .First(); var query = this.db.Addresses.AsQueryable(); if (unit == UnitOfTime.Second) { query = query.Where(x => x.FirstTransactionOn > date.AddSeconds(-1)); } if (unit == UnitOfTime.Hour) { query = query.Where(x => x.FirstTransactionOn > date.AddHours(-1)); } if (unit == UnitOfTime.Day) { query = query.Where(x => x.FirstTransactionOn > date.AddDays(-1)); } if (unit == UnitOfTime.Month) { query = query.Where(x => x.FirstTransactionOn > date.AddMonths(-1)); } return(query.Count()); }
private List <ChartStatsViewModel> GetChartEntries(UnitOfTime unitOfTime, ChartEntryType type) => this.db.ChartEntries .Where(x => x.UnitOfTime == unitOfTime && x.Type == type) .OrderByDescending(x => x.Timestamp) .Take(36) .ProjectTo <ChartStatsViewModel>() .ToList();
private void AddChartValues(string chartName, double value, DateTime time, UnitOfTime unitOfTime, double?accumulatedValue = 0) { var chart = this.GetChart(chartName); var lastRecord = chart[unitOfTime].OrderByDescending(x => x.StartDate).FirstOrDefault(); if (lastRecord.StartDate.IsInSamePeriodAs(time, unitOfTime)) { lastRecord.Value += (decimal)value; } else { lastRecord = new ChartStatsViewModel { StartDate = time, UnitOfTime = unitOfTime, Value = (decimal)value }; if (this.charts[chartName][unitOfTime].Count > 100) { this.charts[chartName][unitOfTime] = this.charts[chartName][unitOfTime] .OrderByDescending(x => x.StartDate) .Take(35) .ToList(); } this.charts[chartName][unitOfTime].Add(lastRecord); } if (accumulatedValue != 0) { lastRecord.AccumulatedValue += (decimal)accumulatedValue.Value; } }
/// <summary> /// Initializes a new instance of the <see cref="BoundedReportingPeriod"/> class. /// </summary> /// <param name="start">The start of the reporting period.</param> /// <param name="end">The end of the reporting period.</param> public BoundedReportingPeriod( UnitOfTime start, UnitOfTime end) : base(start, end) { new { start }.AsArg().Must().NotBeAssignableToType <IAmUnboundedTime>(); new { end }.AsArg().Must().NotBeAssignableToType <IAmUnboundedTime>(); }
/// <summary> /// Initializes a new instance of the <see cref="ReportingPeriodWrapper"/> class. /// </summary> /// <param name="start">The start of the reporting period.</param> /// <param name="end">The end of the reporting period.</param> protected ReportingPeriodWrapper( UnitOfTime start, UnitOfTime end) { var reportingPeriod = new ReportingPeriod(start, end); this.ReportingPeriod = reportingPeriod; }
/// <inheritdoc /> public object Deserialize(string serializedString, Type type) { if (!UnitOfTime.IsUnitOfTimeType(type)) { throw new NotSupportedException(Invariant($"Unsupported type {type?.FullName ?? "<NULL TYPE>"}, expected an implmenter {nameof(UnitOfTime)}")); } return(serializedString.DeserializeFromSortableString(type)); }
public ICollection <ChartStatsViewModel> GetBlockTimesChart(UnitOfTime unitOfTime, int count) => this.GetChart("blockTimes")[unitOfTime] .OrderByDescending(x => x.StartDate) .Take(count) .Where(x => x.Value > 0) .Select(x => new ChartStatsViewModel { Label = x.Label, StartDate = x.StartDate, Value = x.AccumulatedValue / x.Value }) .ToList();
public static void GreaterThanOrEqualToOperator___Should_return_true___When_both_sides_of_operator_are_null() { // Arrange UnitOfTime systemUnderTest1 = null; UnitOfTime systemUnderTest2 = null; // Act var result = systemUnderTest1 >= systemUnderTest2; // Assert result.Should().BeTrue(); }
public static void GreaterThanOrEqualToOperator___Should_return_true___When_left_side_of_operator_is_not_null_and_right_side_is_null() { // Arrange var systemUnderTest1 = A.Dummy <UnitOfTime>(); UnitOfTime systemUnderTest2 = null; // Act var result = systemUnderTest1 >= systemUnderTest2; // Assert result.Should().BeTrue(); }
public static void GreaterThanOperator___Should_return_false___When_left_side_of_operator_is_null_and_right_side_is_not_null() { // Arrange UnitOfTime systemUnderTest1 = null; var systemUnderTest2 = A.Dummy <UnitOfTime>(); // Act var result = systemUnderTest1 > systemUnderTest2; // Assert result.Should().BeFalse(); }
public static void LessThanOperator___Should_return_false___When_both_sides_of_operator_are_null() { // Arrange UnitOfTime systemUnderTest1 = null; UnitOfTime systemUnderTest2 = null; // Act var result = systemUnderTest1 < systemUnderTest2; // Assert result.Should().BeFalse(); }
private static bool IsTimeWord(string word, out UnitOfTime unit) { foreach (var timeUnit in _unitsOfTime.Keys) { if (word.StartsWith(timeUnit)) { unit = _unitsOfTime[timeUnit]; return(true); } } unit = UnitOfTime.Unknown; return(false); }
public static DateTime GetDateTime(DateTime date, UnitOfTime uot) { if (uot == UnitOfTime.Month) { return(new DateTime(date.Year, date.Month, 1)); } if (uot == UnitOfTime.Day) { return(new DateTime(date.Year, date.Month, date.Day)); } return(new DateTime(date.Year, date.Month, date.Day, date.Hour, 0, 0)); }
public static void EqualsOperator___Should_return_false___When_one_side_of_operator_is_null_and_the_other_side_is_not_null() { // Arrange UnitOfTime systemUnderTest1 = null; var systemUnderTest2 = A.Dummy <UnitOfTime>(); // Act var result1 = systemUnderTest1 == systemUnderTest2; var result2 = systemUnderTest2 == systemUnderTest1; // Assert result1.Should().BeFalse(); result2.Should().BeFalse(); }
/// <summary> /// Converts the number of source units to target units. /// </summary> /// <param name="aUnits">A number of units.</param> /// <param name="aFromUnitOfTime">A from unit of time.</param> /// <param name="aToUnitOfTime">A to unit of time.</param> /// <returns></returns> public static double Convert(double aUnits, UnitOfTime aFromUnitOfTime, UnitOfTime aToUnitOfTime) { var vEnumType = typeof(UnitOfTime); // var vFromEnumInfo = vEnumType.GetMember(aFromUnitOfTime.ToString()); var vFromEnumAttributes = vFromEnumInfo[0].GetCustomAttributes(typeof(UnitOfTimeAttribute), false); var vFromOfBase = ((UnitOfTimeAttribute)vFromEnumAttributes[0]).OfBase; // var vToEnumInfo = vEnumType.GetMember(aToUnitOfTime.ToString()); var vToEnumAttributes = vToEnumInfo[0].GetCustomAttributes(typeof(UnitOfTimeAttribute), false); var vToOfBase = ((UnitOfTimeAttribute)vToEnumAttributes[0]).OfBase; // return((aUnits / vFromOfBase) * vToOfBase); }
public static void ToUnitOfTime___Should_return_UnitOfTime_of_specified_kind_with_specified_quarterNumber_and_year___When_called() { // Arrange var expected = new UnitOfTime[] { A.Dummy <CalendarQuarter>(), A.Dummy <FiscalQuarter>(), A.Dummy <GenericQuarter>(), }; // Act var actual = expected.Select(_ => ((IHaveAQuarter)_).QuarterNumber.ToUnitOfTime(((IHaveAQuarter)_).Year, _.UnitOfTimeKind)).ToArray(); // Assert actual.AsTest().Must().BeEqualTo(expected); }
/// <inheritdoc /> public override object ReadJson( JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { new { reader }.Must().NotBeNull(); UnitOfTime result = null; if (reader.Value != null) { result = reader.Value.ToString().DeserializeFromSortableString <UnitOfTime>(); } return(result); }
public static DateTime GetPeriodStart(this DateTime date, UnitOfTime unitOfTime) { if (unitOfTime == UnitOfTime.Hour) { return(new DateTime(date.Year, date.Month, date.Day, date.Hour, 0, 0)); } else if (unitOfTime == UnitOfTime.Day) { return(new DateTime(date.Year, date.Month, date.Day)); } else if (unitOfTime == UnitOfTime.Month) { return(new DateTime(date.Year, date.Month, 1)); } return(default(DateTime)); }
private static TimeSpan AddTo(TimeSpan timeSpan, string numberWords, UnitOfTime unit) { var number = NumbersHelper.ParseNumber(numberWords); switch (unit) { case UnitOfTime.Second: return(timeSpan.Add(TimeSpan.FromSeconds(number))); case UnitOfTime.Minute: return(timeSpan.Add(TimeSpan.FromMinutes(number))); case UnitOfTime.Hour: return(timeSpan.Add(TimeSpan.FromHours(number))); case UnitOfTime.Day: return(timeSpan.Add(TimeSpan.FromDays(number))); case UnitOfTime.Week: return(timeSpan.Add(TimeSpan.FromDays(number * 7))); } return(timeSpan); }
public static bool IsPeriodOver(this long timestamp, UnitOfTime unitOfTime) { var date = timestamp.ToUnixDate(); var now = DateTime.UtcNow; if (unitOfTime == UnitOfTime.Hour) { return(date.AddHours(1) < now); } else if (unitOfTime == UnitOfTime.Day) { return(date.AddDays(1) < now); } else if (unitOfTime == UnitOfTime.Month) { return(date.AddMonths(1) < now); } return(false); }
public static long ToStartOfPeriod(this long timestamp, UnitOfTime unitOfTime) { var date = timestamp.ToUnixDate(); DateTime result = default(DateTime); if (unitOfTime == UnitOfTime.Month) { result = new DateTime(date.Year, date.Month, 1); } else if (unitOfTime == UnitOfTime.Day) { result = new DateTime(date.Year, date.Month, date.Day); } else if (unitOfTime == UnitOfTime.Hour) { result = new DateTime(date.Year, date.Month, date.Day, date.Hour, 0, 0); } return(result.ToUnixTimestamp()); }
public int AddressCount(string hash, UnitOfTime unitOfTime = UnitOfTime.None, bool active = false) { if (unitOfTime == UnitOfTime.Month) { var date = DateTime.UtcNow.AddMonths(-1); if (active) { return(this.db.AddressBalances .Include(x => x.Address) .Count(x => x.AssetHash == hash && x.Address.FirstTransactionOn >= date)); } else { return(this.db.AddressBalances .Include(x => x.Address) .Count(x => x.AssetHash == hash && x.Address.LastTransactionOn >= date)); } } return(this.db.AddressBalances.Count(x => x.AssetHash == hash)); }
public Rental ProvideRental(IClient client, Bike bike, UnitOfTime unitOfTime) { if (!bike.IsAvailable()) { throw new BikeIsNotAvailableException("Bike is not available"); } RentalModality rentalModality; switch (unitOfTime) { case UnitOfTime.Hour: rentalModality = this.CurrentRentalByHourModality; break; case UnitOfTime.Day: rentalModality = this.CurrentRentalByDayModality; break; case UnitOfTime.Week: rentalModality = this.CurrentRentalByWeekModality; break; default: throw new UnitOfTimeIsNotValidException("Unit of time is not valid"); } Rental rental = new Rental(client, new RentalBeginning(this), bike, rentalModality); bike.ChangeState(BikeState.In_Use); bike.Rental = rental; client.AddRental(rental); return(rental); }
private ICollection <ChartStatsViewModel> GetChartPer(string chart, UnitOfTime unitOfTime) => this.GetChart(chart)[unitOfTime];
public TimeSpanStep(double amount, UnitOfTime unitOfTime) { _amount = amount; _unitOfTime = unitOfTime; }
public IEnumerable <ChartStatsViewModel> GetTransactionsPer(UnitOfTime unitOfTime, int count) => this.charts["transactions"][unitOfTime].OrderByDescending(x => x.StartDate).Take(count);
public LoggingInterval(int n, UnitOfTime unit, DateTimeOffset? beginning = null) { Duration = unit.AsTimeSpan().Multiply(n); Beginning = beginning ?? Duration.LastInstanceAsOfNow(); InitTimer(); }
public ICollection <ChartStatsViewModel> GetAddressesChart(UnitOfTime unitOfTime, int count) => this.GetChart("createdAddresses")[unitOfTime].OrderByDescending(x => x.StartDate).Take(count).ToList();
internal TimeSpanModel AddStep(double amount, UnitOfTime unitOfTime) { _steps.Add(new TimeSpanStep(amount, unitOfTime)); return this; }
public ICollection <ChartStatsViewModel> GetTransactionsChart(UnitOfTime unitOfTime, int count) => this.GetChart("transactions")[unitOfTime] .OrderByDescending(x => x.StartDate) .Take(count) .ToList();
internal TimeSpanModel(int amount, UnitOfTime unitOfTime) { _steps = new List<TimeSpanStep>(); AddStep(amount, unitOfTime); }