private static void InitCustomers()
{
DateTimeOffset dto = new DateTimeOffset(2015, 1, 1, 1, 2, 3, 4, TimeSpan.Zero);
_customers = Enumerable.Range(1, 5).Select(e =>
new DCustomer
{
Id = e,
DateTime = dto.AddYears(e).DateTime,
Offset = e % 2 == 0 ? dto.AddMonths(e) : dto.AddDays(e).AddMilliseconds(10),
Date = e % 2 == 0 ? dto.AddDays(e).Date : dto.AddDays(-e).Date,
TimeOfDay = e % 3 == 0 ? dto.AddHours(e).TimeOfDay : dto.AddHours(-e).AddMilliseconds(10).TimeOfDay,
NullableDateTime = e % 2 == 0 ? (DateTime?)null : dto.AddYears(e).DateTime,
NullableOffset = e % 3 == 0 ? (DateTimeOffset?)null : dto.AddMonths(e),
NullableDate = e % 2 == 0 ? (Date?)null : dto.AddDays(e).Date,
NullableTimeOfDay = e % 3 == 0 ? (TimeOfDay?)null : dto.AddHours(e).TimeOfDay,
DateTimes = new [] { dto.AddYears(e).DateTime, dto.AddMonths(e).DateTime },
Offsets = new [] { dto.AddMonths(e), dto.AddDays(e) },
Dates = new [] { (Date)dto.AddYears(e).Date, (Date)dto.AddMonths(e).Date },
TimeOfDays = new [] { (TimeOfDay)dto.AddHours(e).TimeOfDay, (TimeOfDay)dto.AddMinutes(e).TimeOfDay },
NullableDateTimes = new [] { dto.AddYears(e).DateTime, (DateTime?)null, dto.AddMonths(e).DateTime },
NullableOffsets = new [] { dto.AddMonths(e), (DateTimeOffset?)null, dto.AddDays(e) },
NullableDates = new [] { (Date)dto.AddYears(e).Date, (Date?)null, (Date)dto.AddMonths(e).Date },
NullableTimeOfDays = new [] { (TimeOfDay)dto.AddHours(e).TimeOfDay, (TimeOfDay?)null, (TimeOfDay)dto.AddMinutes(e).TimeOfDay },
}).ToList();
}
private static List<Event> GetEvents(DateTimeOffset may, DateTimeOffset june)
{
var inRange = new Event { StartDateTime = may, EndDateTime = june };
var startBeforeRangeEndsInRange = new Event { StartDateTime = may.AddMonths(-1), EndDateTime = june };
var startInRangeEndsAfterRange = new Event { StartDateTime = may, EndDateTime = june.AddMonths(1) };
var startsAndEndsAfterRange = new Event { StartDateTime = may.AddMonths(2), EndDateTime = june.AddMonths(2) };
var startsAndEndsBeforRange = new Event { StartDateTime = may.AddMonths(-2), EndDateTime = june.AddMonths(-2) };
var events = new List<Event>
{
startsAndEndsBeforRange,
startBeforeRangeEndsInRange,
inRange,
startInRangeEndsAfterRange,
startsAndEndsAfterRange,
};
return events;
}
public void CreateAbonnements(int kundeId, DateTimeOffset start, DateTimeOffset stop)
{
var period = ((stop.Year - start.Year) * 12) + stop.Month - start.Month;
if (period == 0)
{
_context.Abonnements.Add(new Data.Abonnement(kundeId, start.Year, start.Month, true));
}
else
{
for (int i = 0; i < period; i++)
{
_context.Abonnements.Add(new Data.Abonnement(kundeId, start.AddMonths(i).Year, start.AddMonths(i).Month, true));
}
}
_context.SaveChanges();
}
public static IEnumerable<DateTimeOffset> GetSundaysInMonth(this DateTimeOffset date)
{
DateTimeOffset start = new DateTimeOffset(date.Year, date.Month, 1, 0, 0, 0, DateTimeOffset.Now.Offset);
var sunday = date.GetSundayNearMonthsBegin();
while (sunday < start.AddMonths(1))
{
yield return sunday;
sunday = sunday.AddDays(7);
}
}
public void CanAddMonthsAcrossDstTransition()
{
var tz = TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time");
var dto = new DateTimeOffset(2015, 2, 9, 0, 0, 0, TimeSpan.FromHours(-8));
var result = dto.AddMonths(1, tz);
var expected = new DateTimeOffset(2015, 3, 9, 0, 0, 0, TimeSpan.FromHours(-7));
Assert.Equal(expected, result);
Assert.Equal(expected.Offset, result.Offset);
}
/// <summary>
/// Parses the time in day hour minute format..
/// </summary>
/// <param name="reference">The reference.</param>
/// <param name="dayHourMinute">The time string in day hour minute format.</param>
/// <returns>DateTimeOffset.</returns>
public static DateTimeOffset ParseDayHourMinute(DateTimeOffset reference, string dayHourMinute)
{
if (reference == DateTimeOffset.MinValue || reference == DateTimeOffset.MaxValue)
reference = DateTimeOffset.UtcNow;
int dayOfMonth, hour, minute;
int.TryParse(dayHourMinute.Substring(0, 2), out dayOfMonth);
int.TryParse(dayHourMinute.Substring(2, 2), out hour);
int.TryParse(dayHourMinute.Substring(4, 2), out minute);
if (dayOfMonth != reference.Day)
{
// Check for previous month
if (dayOfMonth > 25 && reference.Day < 5)
reference = reference.AddMonths(-1);
// Next month
else if (dayOfMonth < 5 && reference.Day > 25)
reference = reference.AddMonths(1);
}
return new DateTimeOffset(reference.Year, reference.Month, dayOfMonth, hour, minute, 0, TimeSpan.Zero);
}
public void TestDateTimeOffsetDayLightSavingWhenAddingMonth()
{
DateTimeOffset someNov2014 = new DateTime(2014, 11, 12, 22, 28, 11, 0, DateTimeKind.Local);
DateTimeOffset someDec2014 = someNov2014.AddMonths(1);
DateTimeOffset dec2014Start = new DateTimeOffset(someDec2014.Year, someDec2014.Month, 1, 0, 0, 0, someNov2014.Offset);
DateTimeOffset nov2014End = dec2014Start.PreviousMoment();
DateTimeOffset nov2014Start = dec2014Start.AddMonths(-1);
DateTimeOffset expectedStart = someNov2014.StartOf(TimeUnits.Month);
DateTimeOffset expectedEnd = someNov2014.EndOf(TimeUnits.Month);
Assert.AreEqual(expectedStart, nov2014Start);
Assert.AreEqual(expectedEnd, nov2014End);
}
public static void TestAddition()
{
DateTimeOffset dt = new DateTimeOffset(new DateTime(1986, 8, 15, 10, 20, 5, 70));
Assert.Equal(17, dt.AddDays(2).Day);
Assert.Equal(13, dt.AddDays(-2).Day);
Assert.Equal(10, dt.AddMonths(2).Month);
Assert.Equal(6, dt.AddMonths(-2).Month);
Assert.Equal(1996, dt.AddYears(10).Year);
Assert.Equal(1976, dt.AddYears(-10).Year);
Assert.Equal(13, dt.AddHours(3).Hour);
Assert.Equal(7, dt.AddHours(-3).Hour);
Assert.Equal(25, dt.AddMinutes(5).Minute);
Assert.Equal(15, dt.AddMinutes(-5).Minute);
Assert.Equal(35, dt.AddSeconds(30).Second);
Assert.Equal(2, dt.AddSeconds(-3).Second);
Assert.Equal(80, dt.AddMilliseconds(10).Millisecond);
Assert.Equal(60, dt.AddMilliseconds(-10).Millisecond);
}
public void From_FromFixedDateTime_Tests(int value)
{
var originalPointInTime = new DateTimeOffset(1976, 12, 31, 17, 0, 0, 0, TimeSpan.Zero);
Assert.AreEqual(value.Years().From(originalPointInTime), originalPointInTime.AddYears(value));
Assert.AreEqual(value.Months().From(originalPointInTime), originalPointInTime.AddMonths(value));
Assert.AreEqual(value.Weeks().From(originalPointInTime), originalPointInTime.AddDays(value*DaysPerWeek));
Assert.AreEqual(value.Days().From(originalPointInTime), originalPointInTime.AddDays(value));
Assert.AreEqual(value.Hours().From(originalPointInTime), originalPointInTime.AddHours(value));
Assert.AreEqual(value.Minutes().From(originalPointInTime), originalPointInTime.AddMinutes(value));
Assert.AreEqual(value.Seconds().From(originalPointInTime), originalPointInTime.AddSeconds(value));
Assert.AreEqual(value.Milliseconds().From(originalPointInTime), originalPointInTime.AddMilliseconds(value));
Assert.AreEqual(value.Ticks().From(originalPointInTime), originalPointInTime.AddTicks(value));
}
internal void ResetByDate()
{
var rResetState = false;
var rNow = DateTimeOffset.Now.ToOffset(TimeZoneOffset);
if (!UpdateTime.HasValue)
Current = 0;
else
{
var rUpdateTime = UpdateTime.Value;
DateTimeOffset rResetTime;
switch (Type)
{
case QuestType.Daily:
case QuestType.Special1:
case QuestType.Special2:
rResetTime = new DateTimeOffset(rNow.Year, rNow.Month, rNow.Day, 5, 0, 0, TimeZoneOffset);
if (rNow.Hour < 5)
rResetTime -= TimeSpan.FromDays(1.0);
rResetState = rUpdateTime < rResetTime;
break;
case QuestType.Weekly:
var rOffset = rNow.DayOfWeek - DayOfWeek.Monday;
if (rOffset < 0)
rOffset += 7;
rResetTime = rNow.AddDays(-1 * rOffset) - rNow.TimeOfDay + ResetHour;
rResetState = rUpdateTime < rResetTime;
break;
case QuestType.Monthly:
rResetTime = new DateTimeOffset(rNow.Year, rNow.Month, 1, 5, 0, 0, TimeZoneOffset);
if (rNow.Hour < 5)
rResetTime = rResetTime.AddMonths(-1);
rResetState = rUpdateTime < rResetTime;
break;
}
}
if (rResetState)
{
DebugUtil.Log(string.Format("任务 {0}: 被重置 原时间={1}", ID, UpdateTime.Value));
StateInternal = QuestState.None;
CurrentInternal = 0;
UpdateTime = rNow;
RecordManager.Instance.Quest.UpdateProgress(this);
RecordManager.Instance.Quest.UpdateStatus(this);
}
}
public void When_a_value_is_not_one_of_the_specified_values_it_should_throw_with_descriptive_message()
{
//-----------------------------------------------------------------------------------------------------------
// Arrange
//-----------------------------------------------------------------------------------------------------------
DateTimeOffset value = new DateTimeOffset(31.December(2016), 1.Hours());
//-----------------------------------------------------------------------------------------------------------
// Act
//-----------------------------------------------------------------------------------------------------------
Action action = () => value.Should().BeOneOf(new[] { value.AddDays(1), value.AddMonths(1) }, "because it's true");
//-----------------------------------------------------------------------------------------------------------
// Assert
//-----------------------------------------------------------------------------------------------------------
action.ShouldThrow<AssertFailedException>()
.WithMessage("Expected value to be one of {<2017-01-01 +1h>, <2017-01-31 +1h>} because it's true, but found <2016-12-31 +1h>.");
}
/// <summary>
/// Creates the month range.
/// </summary>
/// <param name="current">The current</param>
/// <returns>Set of days</returns>
public static DateRange CreateMonthRange(DateTimeOffset current)
{
DateTimeOffset start = new DateTimeOffset(current.Year, current.Month, 1, 0, 0, 0, 0, TimeSpan.Zero);
DateTimeOffset end = start.AddMonths(1).AddMilliseconds(-1);
return new DateRange(start, end);
}
public IHttpActionResult ResetDataSource()
{
DateAndTimeOfDayContext db = new DateAndTimeOfDayContext();
if (!db.Customers.Any())
{
DateTimeOffset dateTime = new DateTimeOffset(2014, 12, 24, 1, 2, 3, 4, new TimeSpan(-8, 0, 0));
IEnumerable<EfCustomer> customers = Enumerable.Range(1, 5).Select(e =>
new EfCustomer
{
Id = e,
DateTime = dateTime.AddYears(e).AddHours(e).AddMilliseconds(e).DateTime,
NullableDateTime = e % 2 == 0 ? (DateTime?)null : dateTime.AddHours(e * 5).AddMilliseconds(e * 5).DateTime,
Offset = dateTime.AddMonths(e).AddHours(e).AddMilliseconds(e),
NullableOffset = e % 3 == 0 ? (DateTimeOffset?)null : dateTime.AddDays(e).AddHours(e * 5)
}).ToList();
foreach (EfCustomer customer in customers)
{
db.Customers.Add(customer);
}
db.SaveChanges();
}
return Ok();
}
/// <summary>
/// Returns an enumerable collection of log blobs containing Analytics log records. The blobs are retrieved lazily.
/// </summary>
/// <param name="service">A <see cref="StorageService"/> enumeration value.</param>
/// <param name="startTime">A <see cref="DateTimeOffset"/> object representing the start of the time range for which logs should be retrieved.</param>
/// <param name="endTime">A <see cref="DateTimeOffset"/> object representing the end of the time range for which logs should be retrieved.</param>
/// <param name="operations">A <see cref="LoggingOperations"/> enumeration value that indicates the types of logging operations on which to filter the log blobs.</param>
/// <param name="details">A <see cref="BlobListingDetails"/> enumeration value that indicates whether or not blob metadata should be returned. Only <c>None</c> and <c>Metadata</c> are valid values. </param>
/// <param name="options">A <see cref="BlobRequestOptions"/> object that specifies additional options for the request.</param>
/// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
/// <returns>An enumerable collection of objects that implement <see cref="ICloudBlob"/> and are retrieved lazily.</returns>
/// <remarks>Note that specifying a logging operation type for the <paramref name="operations"/> parameter will return any Analytics log blob that contains the specified logging operation,
/// even if that log blob also includes other types of logging operations. Also note that the only currently supported values for the <paramref name="details"/>
/// parameter are <c>None</c> and <c>Metadata</c>.</remarks>
public IEnumerable<ICloudBlob> ListLogs(StorageService service, DateTimeOffset startTime, DateTimeOffset? endTime, LoggingOperations operations, BlobListingDetails details, BlobRequestOptions options, OperationContext operationContext)
{
CloudBlobDirectory logDirectory = this.GetLogDirectory(service);
BlobListingDetails metadataDetails = details;
DateTimeOffset utcStartTime = startTime.ToUniversalTime();
DateTimeOffset dateCounter = new DateTimeOffset(utcStartTime.Ticks - (utcStartTime.Ticks % TimeSpan.TicksPerHour), utcStartTime.Offset);
DateTimeOffset? utcEndTime = null;
string endPrefix = null;
// Ensure that the date range is correct.
if (endTime.HasValue)
{
utcEndTime = endTime.Value.ToUniversalTime();
endPrefix = logDirectory.Prefix + utcEndTime.Value.ToString("yyyy/MM/dd/HH", CultureInfo.InvariantCulture);
if (utcStartTime > utcEndTime.Value)
{
string errorString = string.Format(CultureInfo.InvariantCulture, SR.StartTimeExceedsEndTime, startTime, endTime.Value);
throw new ArgumentException(errorString);
}
}
// Currently only support the ability to retrieve metadata on logs.
if (details.HasFlag(BlobListingDetails.Copy) || details.HasFlag(BlobListingDetails.Snapshots) || details.HasFlag(BlobListingDetails.UncommittedBlobs))
{
throw new ArgumentException(SR.InvalidListingDetails);
}
// At least one LogType must be specified.
if (operations == LoggingOperations.None)
{
throw new ArgumentException(SR.InvalidLoggingLevel);
}
// If metadata or a specific LogType is specified, metadata should be retrieved.
if (details.HasFlag(BlobListingDetails.Metadata) || !operations.HasFlag(LoggingOperations.All))
{
metadataDetails = BlobListingDetails.Metadata;
}
// Check logs using an hour-based prefix until we reach a day boundary.
while (dateCounter.Hour > 0)
{
string currentPrefix = logDirectory.Prefix + dateCounter.ToString("yyyy/MM/dd/HH", CultureInfo.InvariantCulture);
IEnumerable<IListBlobItem> currentLogs = logDirectory.Container.ListBlobs(currentPrefix, true, metadataDetails, options, operationContext);
foreach (ICloudBlob log in currentLogs)
{
if (!utcEndTime.HasValue || string.Compare(log.Parent.Prefix, endPrefix) <= 0)
{
if (IsCorrectLogType(log, operations))
{
yield return log;
}
}
else
{
yield break;
}
}
dateCounter = dateCounter.AddHours(1);
if (dateCounter > DateTimeOffset.UtcNow.AddHours(1))
{
yield break;
}
}
// Check logs using a day-based prefix until we reach a month boundary.
while (dateCounter.Day > 1)
{
string currentPrefix = logDirectory.Prefix + dateCounter.ToString("yyyy/MM/dd", CultureInfo.InvariantCulture);
IEnumerable<IListBlobItem> currentLogs = logDirectory.Container.ListBlobs(currentPrefix, true, metadataDetails, options, operationContext);
foreach (ICloudBlob log in currentLogs)
{
if (!utcEndTime.HasValue || string.Compare(log.Parent.Prefix, endPrefix) <= 0)
{
if (IsCorrectLogType(log, operations))
{
yield return log;
}
}
else
{
yield break;
}
}
dateCounter = dateCounter.AddDays(1);
if (dateCounter > DateTimeOffset.UtcNow.AddHours(1))
{
yield break;
}
}
// Check logs using a month-based prefix until we reach a year boundary.
while (dateCounter.Month > 1)
{
string currentPrefix = logDirectory.Prefix + dateCounter.ToString("yyyy/MM", CultureInfo.InvariantCulture);
IEnumerable<IListBlobItem> currentLogs = logDirectory.Container.ListBlobs(currentPrefix, true, metadataDetails, options, operationContext);
foreach (ICloudBlob log in currentLogs)
{
if (!utcEndTime.HasValue || string.Compare(log.Parent.Prefix, endPrefix) <= 0)
{
if (IsCorrectLogType(log, operations))
{
yield return log;
}
}
else
{
yield break;
}
}
dateCounter = dateCounter.AddMonths(1);
if (dateCounter > DateTimeOffset.UtcNow.AddHours(1))
{
yield break;
}
}
// Continue using a year-based prefix.
while (true)
{
string currentPrefix = logDirectory.Prefix + dateCounter.ToString("yyyy", CultureInfo.InvariantCulture);
IEnumerable<IListBlobItem> currentLogs = logDirectory.Container.ListBlobs(currentPrefix, true, metadataDetails, options, operationContext);
foreach (ICloudBlob log in currentLogs)
{
if (!utcEndTime.HasValue || string.Compare(log.Parent.Prefix, endPrefix) <= 0)
{
if (IsCorrectLogType(log, operations))
{
yield return log;
}
}
else
{
yield break;
}
}
dateCounter = dateCounter.AddYears(1);
if (dateCounter > DateTimeOffset.UtcNow.AddHours(1))
{
yield break;
}
}
}
private static DateTimeOffset TranslatedAdd(DateTimeOffset date, IntervalUnit unit, int amountToAdd)
{
switch (unit)
{
case IntervalUnit.Day:
return date.AddDays(amountToAdd);
case IntervalUnit.Hour:
return date.AddHours(amountToAdd);
case IntervalUnit.Minute:
return date.AddMinutes(amountToAdd);
case IntervalUnit.Month:
return date.AddMonths(amountToAdd);
case IntervalUnit.Second:
return date.AddSeconds(amountToAdd);
case IntervalUnit.Millisecond:
return date.AddMilliseconds(amountToAdd);
case IntervalUnit.Week:
return date.AddDays(amountToAdd*7);
case IntervalUnit.Year:
return date.AddYears(amountToAdd);
default:
throw new ArgumentException("Unknown IntervalUnit");
}
}
public void TestMonthlyIntervalGetFireTimeAfter()
{
DateTimeOffset startCalendar = new DateTimeOffset(2005, 6, 1, 9, 30, 17, TimeSpan.Zero);
CalendarIntervalTriggerImpl yearlyTrigger = new CalendarIntervalTriggerImpl();
yearlyTrigger.StartTimeUtc = startCalendar;
yearlyTrigger.RepeatIntervalUnit = IntervalUnit.Month;
yearlyTrigger.RepeatInterval = 5; // every five months
DateTimeOffset targetCalendar = new DateTimeOffset(2005, 6, 1, 9, 30, 17, TimeSpan.Zero);
targetCalendar = targetCalendar.AddMonths(25); // jump 25 five months (5 intervals)
IList<DateTimeOffset> fireTimes = TriggerUtils.ComputeFireTimes(yearlyTrigger, null, 6);
DateTimeOffset fifthTime = fireTimes[5]; // get the sixth fire time
Assert.AreEqual(targetCalendar, fifthTime, "Month increment result not as expected.");
}
public void ToRelativeTimeTest()
{
var date = new DateTimeOffset(2015, 8, 7, 13, 26, 30, TimeSpan.Zero);
var now = DateTimeOffset.Now;
Assert.AreEqual("now", now.ToRelativeTimeString());
Assert.AreEqual("now", now.ToRelativeTimeString(now));
Assert.AreEqual("1 second ago", date.AddSeconds(-1).ToRelativeTimeString(date));
Assert.AreEqual("10 seconds ago", date.AddSeconds(-10).ToRelativeTimeString(date));
Assert.AreEqual("1 minute ago", date.AddSeconds(-90).ToRelativeTimeString(date));
Assert.AreEqual("1 minute ago", date.AddSeconds(-100).ToRelativeTimeString(date));
Assert.AreEqual("2 minutes ago", date.AddSeconds(-120).ToRelativeTimeString(date));
Assert.AreEqual("7 minutes ago", date.AddMinutes(-7).ToRelativeTimeString(date));
Assert.AreEqual("59 minutes ago", date.AddMinutes(-59).ToRelativeTimeString(date));
Assert.AreEqual("1 hour ago", date.AddMinutes(-60).ToRelativeTimeString(date));
Assert.AreEqual("1 hour ago", date.AddHours(-1).ToRelativeTimeString(date));
Assert.AreEqual("9 hours ago", date.AddHours(-9).ToRelativeTimeString(date));
Assert.AreEqual("1 day ago", date.AddHours(-24).ToRelativeTimeString(date));
Assert.AreEqual("1 day ago", date.AddHours(-30).ToRelativeTimeString(date));
Assert.AreEqual("2 days ago", date.AddHours(-48).ToRelativeTimeString(date));
Assert.AreEqual("1 day ago", date.AddDays(-1).ToRelativeTimeString(date));
Assert.AreEqual("12 days ago", date.AddDays(-12).ToRelativeTimeString(date));
Assert.AreEqual("29 days ago", date.AddDays(-29).ToRelativeTimeString(date));
Assert.AreEqual("1 month ago", date.AddDays(-30).ToRelativeTimeString(date));
Assert.AreEqual("1 month ago", date.AddMonths(-1).ToRelativeTimeString(date));
Assert.AreEqual("3 months ago", date.AddMonths(-3).ToRelativeTimeString(date));
Assert.AreEqual("11 months ago", date.AddMonths(-11).ToRelativeTimeString(date));
Assert.AreEqual("1 year ago", date.AddMonths(-12).ToRelativeTimeString(date));
Assert.AreEqual("1 year ago", date.AddYears(-1).ToRelativeTimeString(date));
Assert.AreEqual("3 years ago", date.AddYears(-3).ToRelativeTimeString(date));
Assert.AreEqual("1 second from now", date.AddSeconds(1).ToRelativeTimeString(date));
Assert.AreEqual("10 seconds from now", date.AddSeconds(10).ToRelativeTimeString(date));
Assert.AreEqual("1 minute from now", date.AddSeconds(90).ToRelativeTimeString(date));
Assert.AreEqual("1 minute from now", date.AddSeconds(100).ToRelativeTimeString(date));
Assert.AreEqual("2 minutes from now", date.AddSeconds(120).ToRelativeTimeString(date));
Assert.AreEqual("7 minutes from now", date.AddMinutes(7).ToRelativeTimeString(date));
Assert.AreEqual("59 minutes from now", date.AddMinutes(59).ToRelativeTimeString(date));
Assert.AreEqual("1 hour from now", date.AddMinutes(60).ToRelativeTimeString(date));
Assert.AreEqual("1 hour from now", date.AddHours(1).ToRelativeTimeString(date));
Assert.AreEqual("9 hours from now", date.AddHours(9).ToRelativeTimeString(date));
Assert.AreEqual("1 day from now", date.AddDays(1).ToRelativeTimeString(date));
Assert.AreEqual("1 day from now", date.AddHours(24).ToRelativeTimeString(date));
Assert.AreEqual("12 days from now", date.AddDays(12).ToRelativeTimeString(date));
Assert.AreEqual("29 days from now", date.AddDays(29).ToRelativeTimeString(date));
Assert.AreEqual("1 month from now", date.AddDays(30).ToRelativeTimeString(date));
Assert.AreEqual("1 month from now", date.AddMonths(1).ToRelativeTimeString(date));
Assert.AreEqual("3 months from now", date.AddMonths(3).ToRelativeTimeString(date));
Assert.AreEqual("11 months from now", date.AddMonths(11).ToRelativeTimeString(date));
Assert.AreEqual("1 year from now", date.AddMonths(12).ToRelativeTimeString(date));
Assert.AreEqual("1 year from now", date.AddYears(1).ToRelativeTimeString(date));
Assert.AreEqual("3 years from now", date.AddYears(3).ToRelativeTimeString(date));
}
public void Between()
{
var date = new DateTimeOffset(2015, 8, 7, 13, 26, 30, TimeSpan.Zero);
Assert.IsTrue(date.Between(date.AddMonths(-3), date.AddMonths(3)));
Assert.IsTrue(date.AddHours(36).Between(date.AddMonths(-3), date.AddMonths(3)));
Assert.IsFalse(date.AddMonths(6).Between(date.AddMonths(-3), date.AddMonths(3)));
Assert.IsFalse(date.AddHours(-2).Between(date, date.AddMonths(3)));
Assert.IsTrue(date.Between(date.AddMonths(-3), date.AddMonths(3), false));
Assert.IsTrue(date.AddHours(36).Between(date.AddMonths(-3), date.AddMonths(3), false));
Assert.IsFalse(date.AddMonths(6).Between(date.AddMonths(-3), date.AddMonths(3), false));
Assert.IsTrue(date.AddHours(-2).Between(date, date.AddMonths(3), false));
Assert.IsFalse(date.AddHours(-24).Between(date, date.AddMonths(3), false));
}
public async Task GetTransactionsInDateRange()
{
IHttpClientWrapper httpClient = this.GetMockHttpClient("DateRangeTransactions.json", HttpStatusCode.OK, HttpMethod.Post, "connect/get");
IPlaidClient testClient = this.GetPlaidClient(httpClient);
DateTimeOffset startDate = new DateTimeOffset(2014, 4, 1, 0, 0, 0, TimeSpan.Zero);
DateTimeOffset endDate = startDate.AddMonths(1);
TransactionResult result = await testClient.GetTransactionsAsync(new AccessToken("test_wells"), null, null, startDate, endDate);
Assert.IsNotNull(result);
Assert.IsFalse(result.IsError);
Assert.IsNotNull(result.Accounts);
Assert.IsNotNull(result.Transactions);
Assert.AreEqual(4, result.Accounts.Count);
Assert.AreEqual(5, result.Transactions.Count);
foreach (Transaction t in result.Transactions)
{
Assert.IsTrue(t.Date > startDate);
Assert.IsTrue(t.Date < endDate);
}
}
public static void AddMonths(DateTimeOffset dateTimeOffset, int months, DateTimeOffset expected)
{
Assert.Equal(expected, dateTimeOffset.AddMonths(months));
}
/// <summary>
/// Adds given <see cref="TimeSpan"/> to supplied <paramref name="originalValue"/> <see cref="DateTime"/> and returns resulting <see cref="DateTime"/> in the future.
/// </summary>
public static DateTimeOffset From(this FluentTimeSpan from, DateTimeOffset originalValue)
{
return originalValue.AddMonths(from.Months).AddYears(from.Years).Add(from.TimeSpan);
}
