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);
}
