public static DateTime DateAdd(DateInterval Interval, double Number, DateTime DateValue) { int years = (int) Math.Round(Conversion.Fix(Number)); switch (Interval) { case DateInterval.Year: return CurrentCalendar.AddYears(DateValue, years); case DateInterval.Quarter: return DateValue.AddMonths(years * 3); case DateInterval.Month: return CurrentCalendar.AddMonths(DateValue, years); case DateInterval.DayOfYear: case DateInterval.Day: case DateInterval.Weekday: return DateValue.AddDays((double) years); case DateInterval.WeekOfYear: return DateValue.AddDays(years * 7.0); case DateInterval.Hour: return DateValue.AddHours((double) years); case DateInterval.Minute: return DateValue.AddMinutes((double) years); case DateInterval.Second: return DateValue.AddSeconds((double) years); } throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue1", new string[] { "Interval" })); }
public void AccountForEfficiencies_FixedEnd_MultipleDateIntervalEfficiencies_ReturnsCorrectAnswer() { // +------------+ // |0| |0| |0| // Result: // +------------------+ // |0| |0| |0| // Arrange var now = DateTime.Now; var dateInterval = new DateInterval(now, now.AddDays(5)); var dateIntervalEfficiencies = new List<DateIntervalEfficiency>(); var efficiency1 = new DateIntervalEfficiency(now.AddDays(1), now.AddDays(2), 0); var efficiency2 = new DateIntervalEfficiency(now.AddDays(3), now.AddDays(4), 0); var efficiency3 = new DateIntervalEfficiency(now.AddDays(5), now.AddDays(6), 0); dateIntervalEfficiencies.Add(efficiency1); dateIntervalEfficiencies.Add(efficiency2); dateIntervalEfficiencies.Add(efficiency3); // Act var newDateInterval = dateInterval.AccountForEfficiencies(dateIntervalEfficiencies, FixedEndPoint.Max); var correctDateInterval = new DateInterval(dateInterval.Max.Value.Add(-dateInterval.Duration).Add(-efficiency1.Duration).Add(-efficiency2.Duration).Add(-efficiency3.Duration), dateInterval.Max.Value); // Assert Assert.AreEqual(correctDateInterval, newDateInterval); }
public void CompareTo_DateIntervalWithSameStartAndSameEndDates_ReturnsZero() { // Arrange var dateInterval1 = new DateInterval(now, inOneHour); var dateInterval2 = new DateInterval(now, inOneHour); // Act int compareToValue = dateInterval1.CompareTo(dateInterval2); // Shortest duration comes first // Assert Assert.True(compareToValue == 0); }
public static DateTime DateAdd(DateInterval interval, int value, DateTime date) { int ms = date.GetTime(); DateTime result; switch (interval) { case DateInterval.Milliseconds: result = new DateTime(ms + value); break; case DateInterval.Seconds: result = new DateTime(ms + (value * 1000)); break; case DateInterval.Minutes: result = new DateTime(ms + (value * 1000 * 60)); break; case DateInterval.Hours: result = new DateTime(ms + (value * 1000 * 60 * 60)); break; case DateInterval.Days: result = new DateTime(ms + (value * 1000 * 60 * 60 * 24)); break; default: result = date; break; } return result; }
public DateTimeSearchModel(string title, string columnName, DateInterval interval = DateInterval.Month) { this.title = title; ColumnName = columnName; endDate = DateTime.Now; switch (interval) { case DateInterval.Day: startDate = DateTime.Now.AddDays(-1); break; case DateInterval.Week: startDate = DateTime.Now.AddDays(-7); break; case DateInterval.Month: startDate = DateTime.Now.AddMonths(-1); break; case DateInterval.Quarter: startDate = DateTime.Now.AddMonths(-3); break; case DateInterval.Year: startDate = DateTime.Now.AddYears(-1); break; } originalDate = startDate; }
/// <summary> /// Devuelve un valor Long que especifica el número de /// intervalos de tiempo entre dos valores Date. /// </summary> /// <param name="interval">Obligatorio. Valor de enumeración /// DateInterval o expresión String que representa el intervalo /// de tiempo que se desea utilizar como unidad de diferencia /// entre Date1 y Date2.</param> /// <param name="date1">Obligatorio. Date. Primer valor de /// fecha u hora que se desea utilizar en el cálculo.</param> /// <param name="date2">Obligatorio. Date. Segundo valor de /// fecha u hora que se desea utilizar en el cálculo.</param> /// <returns></returns> public static long DateDiff(DateInterval interval, DateTime date1, DateTime date2) { long rs = 0; TimeSpan diff = date2.Subtract(date1); switch (interval) { case DateInterval.Day: case DateInterval.DayOfYear: rs = (long)diff.TotalDays; break; case DateInterval.Hour: rs = (long)diff.TotalHours; break; case DateInterval.Minute: rs = (long)diff.TotalMinutes; break; case DateInterval.Month: rs = (date2.Month - date1.Month) + (12*DateTimeExtension.DateDiff(DateInterval.Year, date1, date2)); break; case DateInterval.Quarter: rs = (long)Math.Ceiling((double)(DateTimeExtension.DateDiff(DateInterval.Month, date1, date2) / 3.0)); break; case DateInterval.Second: rs = (long)diff.TotalSeconds; break; case DateInterval.Weekday: case DateInterval.WeekOfYear: rs = (long)(diff.TotalDays/7); break; case DateInterval.Year: rs = date2.Year - date1.Year; break; }//switch return rs; }
/// <summary> /// Gets the difference between two dates based on an interval. /// </summary> /// <param name="interval">The interval to use (seconds, minutes, hours, days, months, years)</param> /// <param name="date1">The date to use for comparison.</param> /// <param name="date2">The date to compare against the first date.</param> /// <returns></returns> public static object GetDateDiff(DateInterval interval, DateTime date1, DateTime date2) { object returnValue = null; TimeSpan t; object diff = 0.0; //returns negative value if date1 is more recent t = date2 - date1; switch (interval) { case DateInterval.Second: diff = t.TotalSeconds; break; case DateInterval.Minute: diff = t.TotalMinutes; break; case DateInterval.Hour: diff = t.TotalHours; break; case DateInterval.Day: diff = t.TotalDays; break; case DateInterval.Month: diff = t.TotalDays / 365.25 * 12.0; break; case DateInterval.Year: diff = t.TotalDays / 365.25; break; } returnValue = Convert.ToInt32(diff); return returnValue; }
public void Length_Exclusive() { LocalDate start = new LocalDate(2000, 1, 1); LocalDate end = new LocalDate(2000, 2, 10); var interval = new DateInterval(start, end, false); Assert.AreEqual(40, interval.Length); }
internal static long DateDiff(DateInterval Interval, System.DateTime StartDate, System.DateTime EndDate) { long lngDateDiffValue = 0; System.TimeSpan TS = new System.TimeSpan(EndDate.Ticks - StartDate.Ticks); switch (Interval) { case DateInterval.Day: lngDateDiffValue = (long)TS.Days; break; case DateInterval.Hour: lngDateDiffValue = (long)TS.TotalHours; break; case DateInterval.Minute: lngDateDiffValue = (long)TS.TotalMinutes; break; case DateInterval.Month: lngDateDiffValue = (long)(TS.Days / 30); break; case DateInterval.Quarter: lngDateDiffValue = (long)((TS.Days / 30) / 3); break; case DateInterval.Second: lngDateDiffValue = (long)TS.TotalSeconds; break; case DateInterval.Week: lngDateDiffValue = (long)(TS.Days / 7); break; case DateInterval.Year: lngDateDiffValue = (long)(TS.Days / 365); break; } return (lngDateDiffValue); }
public void Construction_DefaultToInclusive() { LocalDate start = new LocalDate(2000, 1, 1); LocalDate end = new LocalDate(2001, 6, 19); var interval = new DateInterval(start, end); Assert.IsTrue(interval.Inclusive); }
public static long DateDiff(this DateTime startDate, DateTime endDate, DateInterval interval = DateInterval.Day) { long lngDateDiffValue = 0; var timeSpan = new TimeSpan(endDate.Ticks - startDate.Ticks); switch (interval) { case DateInterval.Second: lngDateDiffValue = (long) timeSpan.TotalSeconds; break; case DateInterval.Minute: lngDateDiffValue = (long) timeSpan.TotalMinutes; break; case DateInterval.Hour: lngDateDiffValue = (long) timeSpan.TotalHours; break; case DateInterval.Day: lngDateDiffValue = timeSpan.Days; break; case DateInterval.Week: lngDateDiffValue = timeSpan.Days/7; break; case DateInterval.Month: lngDateDiffValue = timeSpan.Days/30; break; case DateInterval.Quarter: lngDateDiffValue = (timeSpan.Days/30)/3; break; case DateInterval.Year: lngDateDiffValue = timeSpan.Days/365; break; } return (lngDateDiffValue); }
public static IList<ITask> Collapse(this IEnumerable<ITask> taskCollection) { var taskList = taskCollection.ToList(); if (taskCollection == null) { return null; } var output = new Collection<ITask>(); // Grabbing all time split points and sorting them List<DateTime> timeEvents = taskList.SelectMany(task => new[] { task.StartTime, task.EndTime }) .Distinct() .OrderBy(x => x) .ToList(); for (var i = 0; i < timeEvents.Count - 1; i++) { var newSpan = new DateInterval(timeEvents[i], timeEvents[i + 1]); var overlappingTasks = taskList.Where(x => x.DateInterval.Overlaps(newSpan)); if (overlappingTasks.Any()) { var quantityPerHour = overlappingTasks.Sum(x => x.QuantityPerHour); output.Add(Task.CreateUsingQuantityPerHour(newSpan, quantityPerHour)); } } return output; }
public void Construction_Properties() { LocalDate start = new LocalDate(2000, 1, 1); LocalDate end = new LocalDate(2001, 6, 19); var interval = new DateInterval(start, end, false); Assert.AreEqual(start, interval.Start); Assert.AreEqual(end, interval.End); Assert.IsFalse(interval.Inclusive); }
public void FixedStartPointNoOverlapsWithOffset(IAccountForEfficiencies accountForEfficienciesCalculator) { // 1% efficiency var dateIntervalEfficiencies = DateIntervalCollectionGenerator.NoOverlaps(this.now, TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(1), this.numberOfIntervals) .Select(interval => new DateIntervalEfficiency(interval, 1)).ToList(); var initialInterval = new DateInterval(this.now, dateIntervalEfficiencies.Last().Max.Value); accountForEfficienciesCalculator.AccountForEfficiencies(initialInterval, dateIntervalEfficiencies, FixedEndPoint.Min); }
public void Setup() { now = DateTime.Now; nowAndTenDaysInterval = new DateInterval(now, now.AddDays(10)); nowAndFiveDaysInterval = new DateInterval(now, now.AddDays(5)); twoDaysAndFiveDaysInterval = new DateInterval(now.AddDays(2), now.AddDays(5)); threeDaysAgoAndTwelveDaysInterval = new DateInterval(now.AddDays(-3), now.AddDays(12)); thirteenDaysAndFourteenDaysInterval = new DateInterval(now.AddDays(13), now.AddDays(14)); }
public void FixedStartPointNoOverlapsWithOffsetWithSpan(double spanEfficiency, int spanPriority, bool assertIntervalsEquality) { // 1% efficiency var dateIntervalEfficiencies = DateIntervalCollectionGenerator.NoOverlaps(now, TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(1), numberOfIntervals) .Select(interval => new DateIntervalEfficiency(interval, 1)).ToList(); var initialInterval = new DateInterval(now, dateIntervalEfficiencies.Last().Max.Value); dateIntervalEfficiencies.Add(new DateIntervalEfficiency(initialInterval, spanEfficiency, spanPriority)); RunAccountForEfficienciesBenchmarkTest(initialInterval, dateIntervalEfficiencies, FixedEndPoint.Min, assertIntervalsEquality); }
public void Equals_EqualValues() { LocalDate start = new LocalDate(2000, 1, 1); LocalDate end = new LocalDate(2001, 6, 19); var interval1 = new DateInterval(start, end, false); var interval2 = new DateInterval(start, end, false); Assert.AreEqual(interval1, interval2); Assert.AreEqual(interval1.GetHashCode(), interval2.GetHashCode()); Assert.IsTrue(interval1 == interval2); Assert.IsFalse(interval1 != interval2); Assert.IsTrue(interval1.Equals(interval2)); // IEquatable implementation }
public void CompareTo_DateIntervalWithSameStartAndDifferentEndDates_ReturnsShortestDurationFirstReversed() { // Arrange var dateInterval1 = new DateInterval(now, inThreeHours); var dateInterval2 = new DateInterval(now, inOneHour); // Act int compareToValue = dateInterval1.CompareTo(dateInterval2); // Shortest duration comes first // Assert Assert.True(compareToValue == 1); }
public void CompareTo_DateIntervalWithDifferentStartAndDifferentEndDates_ReturnsEarliestStart() { // Arrange var dateInterval1 = new DateInterval(now, inOneHour); var dateInterval2 = new DateInterval(inOneHour, inThreeHours); // Act int compareToValue = dateInterval1.CompareTo(dateInterval2); // Assert Assert.True(compareToValue == -1); }
public static IEnumerable<DateInterval> GetDateIntervalsAllDescendingEndTimes(int count) { var date = DateTime.Now; var DateIntervals = new DateInterval[count]; for (int i = 0; i < count; i++) { DateIntervals[count - i - 1] = new DateInterval(date.AddMinutes(-i), date.AddMinutes(i)); } return new List<DateInterval>(DateIntervals).OrderBy( x => x ); }
private static List<DateInterval> CreatetestCase(Random rand, DateTime start, int MaxNumberOfDateRanges) { var orderedDateRanges = new List<DateInterval>(); for (int i = rand.Next(MaxNumberOfDateRanges)+10; i != 0; --i) { var DRStart = start.AddMinutes(rand.Next(1000)); var DR = new DateInterval(DRStart, DRStart.AddMinutes(rand.Next(1000))); orderedDateRanges.Add(DR); } orderedDateRanges.Sort(); return orderedDateRanges; }
public void AccountForEfficiencies_FixedEnd_EmptyListOfDateIntervalEfficiencies_ReturnsUnchangedDateInterval() { // Arrange var now = DateTime.Now; var dateInterval = new DateInterval(now, now.AddDays(1)); var dateIntervalEfficiencies = new List<DateIntervalEfficiency>(); // Act var newDateInterval = dateInterval.AccountForEfficiencies(dateIntervalEfficiencies, FixedEndPoint.Max); // Assert Assert.AreEqual(dateInterval, newDateInterval); }
public static long DateDiff(DateInterval interval, DateTime dt1, DateTime dt2, DayOfWeek eFirstDayOfWeek) { if (interval == DateInterval.Year) return dt2.Year - dt1.Year; if (interval == DateInterval.Month) return (dt2.Month - dt1.Month) + (12 * (dt2.Year - dt1.Year)); TimeSpan ts = dt2 - dt1; if (interval == DateInterval.Day || interval == DateInterval.DayOfYear) return Round(ts.TotalDays); if (interval == DateInterval.Hour) return Round(ts.TotalHours); if (interval == DateInterval.Minute) return Round(ts.TotalMinutes); if (interval == DateInterval.Second) return Round(ts.TotalSeconds); if (interval == DateInterval.Weekday) { return Round(ts.TotalDays / 7.0); } if (interval == DateInterval.WeekOfYear) { while (dt2.DayOfWeek != eFirstDayOfWeek) dt2 = dt2.AddDays(-1); while (dt1.DayOfWeek != eFirstDayOfWeek) dt1 = dt1.AddDays(-1); ts = dt2 - dt1; return Round(ts.TotalDays / 7.0); } if (interval == DateInterval.Quarter) { double d1Quarter = GetQuarter(dt1.Month); double d2Quarter = GetQuarter(dt2.Month); double d1 = d2Quarter - d1Quarter; double d2 = (4 * (dt2.Year - dt1.Year)); return Round(d1 + d2); } return 0; }
public void Equals_DifferentCalendars() { LocalDate start1 = new LocalDate(2000, 1, 1); LocalDate end1 = new LocalDate(2001, 6, 19); // This is a really, really similar calendar to ISO, but we do distinguish. // TODO: Should we? LocalDate start2 = start1.WithCalendar(CalendarSystem.Gregorian); LocalDate end2 = end1.WithCalendar(CalendarSystem.Gregorian); var interval1 = new DateInterval(start1, end1, false); var interval2 = new DateInterval(start2, end2, false); Assert.AreNotEqual(interval1, interval2); Assert.AreNotEqual(interval1.GetHashCode(), interval2.GetHashCode()); Assert.IsFalse(interval1 == interval2); Assert.IsTrue(interval1 != interval2); Assert.IsFalse(interval1.Equals(interval2)); // IEquatable implementation }
public void Equals_DifferentCalendars() { LocalDate start1 = new LocalDate(2000, 1, 1); LocalDate end1 = new LocalDate(2001, 6, 19); // This is a really, really similar calendar to ISO - the dates could differ by week of year, // but that's all. LocalDate start2 = start1.WithCalendar(CalendarSystem.GetGregorianCalendar(1)); LocalDate end2 = end1.WithCalendar(CalendarSystem.GetGregorianCalendar(1)); var interval1 = new DateInterval(start1, end1, false); var interval2 = new DateInterval(start2, end2, false); Assert.AreNotEqual(interval1, interval2); Assert.AreNotEqual(interval1.GetHashCode(), interval2.GetHashCode()); Assert.IsFalse(interval1 == interval2); Assert.IsTrue(interval1 != interval2); Assert.IsFalse(interval1.Equals(interval2)); // IEquatable implementation }
public void FixedStartPointWithOverlaps() { // With decreasing efficiency // |-------------------| 90 // |---------------| 80 // |---------| 70 // |-----| 60 // 1% efficiency var dateIntervalEfficiencies = DateIntervalCollectionGenerator.OverlapsWithDecreasingDuration(now, TimeSpan.FromMinutes(1), numberOfIntervals) .Select((interval, i) => new DateIntervalEfficiency(interval, numberOfIntervals - i)).ToList(); var initialInterval = new DateInterval(now, dateIntervalEfficiencies.First().Max.Value); RunAccountForEfficienciesBenchmarkTest(initialInterval, dateIntervalEfficiencies, FixedEndPoint.Min, assertIntervalsEquality: false); }
public static long DateDiff(this DateTime first, DateTime second, DayOfWeek firstDayOfWeek, DateInterval interval) { if (interval == DateInterval.Year) return second.Year - first.Year; if (interval == DateInterval.Month) return (second.Month - first.Month) + (12 * (second.Year - first.Year)); TimeSpan ts = second - first; if (interval == DateInterval.Day || interval == DateInterval.DayOfYear) return Round(ts.TotalDays); if (interval == DateInterval.Hour) return Round(ts.TotalHours); if (interval == DateInterval.Minute) return Round(ts.TotalMinutes); if (interval == DateInterval.Second) return Round(ts.TotalSeconds); if (interval == DateInterval.Weekday) { return Round(ts.TotalDays / 7.0); } if (interval == DateInterval.WeekOfYear) { while (second.DayOfWeek != firstDayOfWeek) second = second.AddDays(-1); while (first.DayOfWeek != firstDayOfWeek) first = first.AddDays(-1); ts = second - first; return Round(ts.TotalDays / 7.0); } if (interval == DateInterval.Quarter) { double d1Quarter = GetQuarter(first); double d2Quarter = GetQuarter(second); double d1 = d2Quarter - d1Quarter; double d2 = (4 * (second.Year - first.Year)); return Round(d1 + d2); } return 0; }
/// <summary> /// Initializes a new instance of the <see cref="DateRangeBound"/> class. /// </summary> /// <param name="relativeAmount">The relative amount.</param> /// <param name="relativeInterval">The relative interval.</param> /// <param name="specificDate">The specific date.</param> /// <param name="windowAmount">The window amount.</param> /// <param name="windowInterval">The window interval.</param> public DateRangeBound(int? relativeAmount, DateInterval? relativeInterval, DateTime? specificDate, int? windowAmount, DateInterval? windowInterval) { if (specificDate.HasValue) { this.SpecificDate = specificDate; } else if (windowAmount.HasValue && windowInterval.HasValue) { this.WindowAmount = windowAmount; this.WindowInterval = windowInterval; } else { this.RelativeAmount = relativeAmount; this.RelativeInterval = relativeInterval; } }
public static long DateDiff(DateInterval intervalType, System.DateTime dateOne, System.DateTime dateTwo) { switch (intervalType) { case DateInterval.Day: case DateInterval.DayOfYear: System.TimeSpan spanForDays = dateTwo - dateOne; return (long)spanForDays.TotalDays; case DateInterval.Hour: System.TimeSpan spanForHours = dateTwo - dateOne; return (long)spanForHours.TotalHours; case DateInterval.Minute: System.TimeSpan spanForMinutes = dateTwo - dateOne; return (long)spanForMinutes.TotalMinutes; case DateInterval.Month: return ((dateTwo.Year - dateOne.Year) * 12) + (dateTwo.Month - dateOne.Month); case DateInterval.Quarter: long dateOneQuarter = (long)System.Math.Ceiling(dateOne.Month / 3.0); long dateTwoQuarter = (long)System.Math.Ceiling(dateTwo.Month / 3.0); return (4 * (dateTwo.Year - dateOne.Year)) + dateTwoQuarter - dateOneQuarter; case DateInterval.Second: System.TimeSpan spanForSeconds = dateTwo - dateOne; return (long)spanForSeconds.TotalSeconds; case DateInterval.Weekday: System.TimeSpan spanForWeekdays = dateTwo - dateOne; return (long)(spanForWeekdays.TotalDays / 7.0); case DateInterval.WeekOfYear: System.DateTime dateOneModified = dateOne; System.DateTime dateTwoModified = dateTwo; while (dateTwoModified.DayOfWeek != System.Globalization.DateTimeFormatInfo.CurrentInfo.FirstDayOfWeek) { dateTwoModified = dateTwoModified.AddDays(-1); } while (dateOneModified.DayOfWeek != System.Globalization.DateTimeFormatInfo.CurrentInfo.FirstDayOfWeek) { dateOneModified = dateOneModified.AddDays(-1); } System.TimeSpan spanForWeekOfYear = dateTwoModified - dateOneModified; return (long)(spanForWeekOfYear.TotalDays / 7.0); case DateInterval.Year: return dateTwo.Year - dateOne.Year; default: return 0; } }
/// <summary> /// Gets the scalar difference between two dates given a <see cref="DateInterval"/> value. /// </summary> /// <param name="interval">The interval to calculate</param> /// <param name="start">The start date</param> /// <param name="end">The end date</param> /// <param name="excludeEndDate">If true, the difference is exclusive of the end date</param> /// <returns></returns> public static int GetDifference(DateInterval interval, DateTime start, DateTime end, bool excludeEndDate = false) { var sum = 0; var span = new DateSpan(start, end); switch (interval) { case DateInterval.Years: sum += span.Years; break; case DateInterval.Months: if (span.Years > 0) { sum += span.Years * 12; } sum += span.Months; sum += span.Weeks / 4; // Helps resolve lower resolution break; case DateInterval.Weeks: sum = GetDifferenceInDays(start, span, excludeEndDate) / 7; break; case DateInterval.Days: sum = GetDifferenceInDays(start, span, excludeEndDate); break; case DateInterval.Hours: sum = GetDifferenceInDays(start, span, excludeEndDate) * 24; sum += span.Hours; break; case DateInterval.Minutes: sum = GetDifferenceInDays(start, span, excludeEndDate) * 24 * 60; sum += span.Hours * 60; sum += span.Minutes; break; case DateInterval.Seconds: sum = GetDifferenceInDays(start, span, excludeEndDate) * 24 * 60 * 60; sum += span.Hours * 60 * 60; sum += span.Minutes * 60; sum += span.Seconds; break; default: throw new ArgumentOutOfRangeException("interval"); } return sum; }
} // constructor public void Run() { FileCache.ErrorMsg = string.Empty; for (int i = 0; i < FileList.Count; i++) { HttpPostedFileBase oFile = FileList[i]; if (oFile == null) { ms_oLog.Debug("File {0}: not found, ignoring.", i); continue; } // if ms_oLog.Debug("File {0}, name: {1}", i, oFile.FileName); if (oFile.ContentLength == 0) { ms_oLog.Debug("File {0}: is empty, ignoring.", i); continue; } // if var oFileContents = new byte[oFile.ContentLength]; int nRead = oFile.InputStream.Read(oFileContents, 0, oFile.ContentLength); if (nRead != oFile.ContentLength) { ms_oLog.Warn("File {0}: failed to read entire file contents, ignoring.", i); continue; } // if string sMimeType = m_oLimitations.DetectFileMimeType(oFileContents, oFile.FileName, oLog: ms_oLog); ms_oLog.Debug("File {0}, name: {1}, MIME type {2}", i, oFile.FileName, sMimeType); if (string.IsNullOrWhiteSpace(sMimeType)) { ms_oLog.Debug("File {0}: has unsupported content type, ignoring.", i); continue; } // if SaveToDisc(CustomerID, OneUploadLimitation.FixFileName(oFile.FileName), oFileContents); var smd = new SheafMetaData { BaseFileName = OneUploadLimitation.FixFileName(oFile.FileName), DataType = DataType.VatReturn, FileType = FileType.Pdf, Thrasher = null }; FileCache.Add(smd, oFileContents); var vrpt = new VatReturnPdfThrasher(false, ms_oLog); ISeeds oResult; try { oResult = vrpt.Run(smd, oFileContents); } catch (Exception e) { ms_oLog.Warn(e, "Failed to parse file {0} named {1}:", i, oFile.FileName); continue; } // try if (oResult == null) { ErrorMsg = m_sErrorMsg + " " + ((VatReturnSeeds)vrpt.Seeds).FatalError; continue; } // if var oSeeds = (VatReturnSeeds)oResult; var di = new DateInterval(oSeeds.DateFrom, oSeeds.DateTo); ms_oLog.Debug("HMRC file cache state before adding file {0}: {1}.", oFile.FileName, FileCache); if (FileCache.Intersects(oSeeds.RegistrationNo, di)) { return; } FileCache.Add(oSeeds.RegistrationNo, di, smd, oResult); ms_oLog.Debug("HMRC file cache state after adding file {0}: {1}.", oFile.FileName, FileCache); } // for } // Run
protected override LocalDate GetProperty2Value(DateInterval value) => value.End;
public static bool Starts(this DateInterval x, DateInterval y) => x.Start == y.Start && x.End < y.End;
public static ReportDataSource HodnotaSmluvPerZverejneni(string query, DateInterval interval) { DateTime minDate = new DateTime(2012, 1, 1); DateTime maxDate = DateTime.Now.Date.AddDays(1); string datumFormat = "MMM yyyy"; switch (interval) { case DateInterval.Day: datumFormat = "dd.MM.yy"; break; case DateInterval.Week: datumFormat = "dd.MM.yy"; break; case DateInterval.Month: datumFormat = "MMM yyyy"; break; case DateInterval.Quarter: datumFormat = "MMM yyyy"; break; case DateInterval.Year: datumFormat = "yyyy"; break; default: break; } AggregationContainerDescriptor <HlidacStatu.Lib.Data.Smlouva> aggs = new AggregationContainerDescriptor <HlidacStatu.Lib.Data.Smlouva>() .DateHistogram("x-agg", h => h .Field(f => f.datumUzavreni) .Interval(interval) .Format("yyyy-MM-dd") .Aggregations(agg => agg .Sum("sumincome", s => s .Field(ff => ff.CalculatedPriceWithVATinCZK) ) ) ); ReportDataSource rdsPerIntervalSumPrice = new ReportDataSource(new ReportDataSource.Column[] { new ReportDataSource.Column() { Name = "Měsíc", TextRender = (s) => { DateTime dt = ((DateTime)s); return(string.Format("Date.UTC({0}, {1}, {2})", dt.Year, dt.Month - 1, dt.Day)); } }, new ReportDataSource.Column() { Name = "Součet cen", HtmlRender = (s) => { return(HlidacStatu.Lib.Data.Smlouva.NicePrice((double?)s, html: true, shortFormat: true)); } }, }); var res = HlidacStatu.Lib.Data.Smlouva.Search.SimpleSearch("( " + query + " ) AND datumUzavreni:{" + HlidacStatu.Util.RenderData.ToElasticDate(minDate) + " TO " + HlidacStatu.Util.RenderData.ToElasticDate(maxDate) + "}", 1, 0, HlidacStatu.Lib.Data.Smlouva.Search.OrderResult.FastestForScroll, anyAggregation: aggs, exactNumOfResults: true); foreach (Nest.DateHistogramBucket val in ((BucketAggregate)res.Result.Aggregations["x-agg"]).Items ) { if (val.Date >= minDate && val.Date <= maxDate) { rdsPerIntervalSumPrice.AddRow( new DateTime(val.Date.Ticks, DateTimeKind.Utc).ToLocalTime(), ((Nest.DateHistogramBucket)val).Sum("sumincome").Value ); } } return(rdsPerIntervalSumPrice); }
public static ReportDataSource HodnotaSmluvPerZverejneni(DateInterval interval) { return(HodnotaSmluvPerZverejneni("-id:pre* ", interval)); }
/// <summary> /// Works like Visual Basic DateDiff method. /// </summary> /// <param name="interval"></param> /// <param name="date1"></param> /// <param name="date2"></param> /// <returns></returns> public static long DateDiff(DateInterval interval, DateTime date1, DateTime date2) { long _value = 0; TimeSpan _span = date2 - date1; switch (interval) { case DateInterval.Day: case DateInterval.DayOfYear: _value = _span.Days; break; case DateInterval.Hour: if (_span.Hours > 0) { _value = _span.Hours; } else { _value = (_span.Days * 24); } break; case DateInterval.Minute: if (_span.Minutes > 0) { _value = _span.Minutes; } else { _value = (_span.Days * 24) * 60; } break; case DateInterval.Month: _value = CLng(_span.Days / 30); break; case DateInterval.Quarter: _value = (CLng(_span.Days / 30) / 3); break; case DateInterval.Second: if (_span.Seconds > 0) { _value = _span.Seconds; } else { _value = ((_span.Days * 24) * 60) * 60; } break; case DateInterval.Week: case DateInterval.WeekOfYear: _value = CLng(_span.Days / 7); break; case DateInterval.Year: _value = CLng(_span.Days / 365); break; default: break; } return(_value); }
public SolarReport(DateInterval billingInterval, double powerGenerated) { this.billingInterval = billingInterval; this.powerGenerated = powerGenerated; }
protected override LocalDate GetProperty1Value(DateInterval value) => value.Start;
public SolarAndUtilityReport(DateInterval billingInterval, double powerGenerated, int powerBoughtOrSold, int powerCostCents) : base(billingInterval, powerGenerated) { this.powerBoughtOrSold = powerBoughtOrSold; this.powerCostCents = powerCostCents; }
private static IEnumerable <DateTimeOffset> GetOccurrences(DateInterval interval, DatePeriod period, Calendar calendar, DateTimeOffset start, DateTimeOffset end, bool skipWeekends = true) { return(GetOccurrences(interval, period, calendar, start.DateTime, end.DateTime, skipWeekends).Select(occurrence => (DateTimeOffset)occurrence)); }
public DateHistogramAggregationDescriptor <T> Interval(DateInterval interval) => Assign(a => a.Interval = interval);
private ResultSetBuilder EvaluateEquals(Expression expression) { if (expression.NodeType == ExpressionType.Equal || expression.NodeType == ExpressionType.NotEqual) { var literal = ExHelper.GetLiteralValue(expression, _parameters); var memberName = ExHelper.GetMemberName(expression, _itemType); IColumnMetadata column; try { column = _journal.Metadata.GetColumnByPropertyName(memberName); } catch (NFSdbConfigurationException) { throw QueryExceptionExtensions.ExpressionNotSupported( string.Format("Column {0} does not exist", memberName), expression); } if (_journal.Metadata.TimestampColumnID == column.ColumnID) { if (expression.NodeType == ExpressionType.Equal) { if (literal is long || literal is DateTime) { if (GetTimestamp(_journal.Metadata) != null && GetTimestamp(_journal.Metadata).PropertyName == memberName) { DateInterval filterInterval; if (literal is long) { var timestamp = (long)literal; filterInterval = new DateInterval(DateUtils.UnixTimestampToDateTime(timestamp), DateUtils.UnixTimestampToDateTime(timestamp + 1)); } else { var timestamp = (DateTime)literal; filterInterval = new DateInterval(timestamp, new DateTime(timestamp.Ticks + 1, timestamp.Kind)); } var result = new ResultSetBuilder(_journal, _tx); result.TimestampInterval(filterInterval); return(result); } } } } var res = new ResultSetBuilder(_journal, _tx); try { if (literal != null) { if (expression.NodeType == ExpressionType.Equal) { ReflectionHelper.CallStaticPrivateGeneric("CreateColumnScan", this, column.DataType.Clazz, column, literal, res); } else if (expression.NodeType == ExpressionType.NotEqual) { ReflectionHelper.CallStaticPrivateGeneric("CreateColumnNotEqualScan", this, column.DataType.Clazz, column, literal, res); } } else { if (expression.NodeType == ExpressionType.Equal) { ReflectionHelper.CallStaticPrivateGeneric("CreateColumnScan", this, column.DataType.Clazz, column, null, res); } else if (expression.NodeType == ExpressionType.NotEqual) { ReflectionHelper.CallStaticPrivateGeneric("CreateColumnNotEqualScan", this, column.DataType.Clazz, column, null, res); } } } catch (NFSdbQueryableNotSupportedException ex) { throw QueryExceptionExtensions.ExpressionNotSupported(ex.Message, expression); } catch (InvalidCastException ex) { throw QueryExceptionExtensions.ExpressionNotSupported(ex.Message, expression); } return(res); } throw new NotSupportedException( string.Format("Unable to translate expression {0} to journal operation", expression)); }
public static int DatePart(DateInterval Interval, DateTime DateValue, FirstDayOfWeek FirstDayOfWeekValue = 1, FirstWeekOfYear FirstWeekOfYearValue = 1) { DayOfWeek firstDayOfWeek; CalendarWeekRule calendarWeekRule; switch (Interval) { case DateInterval.Year: return(CurrentCalendar.GetYear(DateValue)); case DateInterval.Quarter: return(((DateValue.Month - 1) / 3) + 1); case DateInterval.Month: return(CurrentCalendar.GetMonth(DateValue)); case DateInterval.DayOfYear: return(CurrentCalendar.GetDayOfYear(DateValue)); case DateInterval.Day: return(CurrentCalendar.GetDayOfMonth(DateValue)); case DateInterval.WeekOfYear: if (FirstDayOfWeekValue != FirstDayOfWeek.System) { firstDayOfWeek = (DayOfWeek)(FirstDayOfWeekValue - 1); break; } firstDayOfWeek = Utils.GetCultureInfo().DateTimeFormat.FirstDayOfWeek; break; case DateInterval.Weekday: return(Weekday(DateValue, FirstDayOfWeekValue)); case DateInterval.Hour: return(CurrentCalendar.GetHour(DateValue)); case DateInterval.Minute: return(CurrentCalendar.GetMinute(DateValue)); case DateInterval.Second: return(CurrentCalendar.GetSecond(DateValue)); default: throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue1", new string[] { "Interval" })); } switch (FirstWeekOfYearValue) { case FirstWeekOfYear.System: calendarWeekRule = Utils.GetCultureInfo().DateTimeFormat.CalendarWeekRule; break; case FirstWeekOfYear.Jan1: calendarWeekRule = CalendarWeekRule.FirstDay; break; case FirstWeekOfYear.FirstFourDays: calendarWeekRule = CalendarWeekRule.FirstFourDayWeek; break; case FirstWeekOfYear.FirstFullWeek: calendarWeekRule = CalendarWeekRule.FirstFullWeek; break; } return(CurrentCalendar.GetWeekOfYear(DateValue, calendarWeekRule, firstDayOfWeek)); }
public override object GetContent() { var minDate = DateTime.MinValue; var maxDate = DateTime.MaxValue - TimeSpan.FromDays(1); var frDate = Request.GetValidated("Fr", minDate); var toDate = Request.GetValidated("To", maxDate, dt => dt >= frDate, Tr.PgTrns.Validation_NotBeforeFr); var amtFmt = Request.GetValidated("AmtFmt", "#,0"); _interval = new DateInterval(frDate.Date, toDate.Date + TimeSpan.FromDays(1) - TimeSpan.FromTicks(1)); _account = GetAccount("Acct"); var subAccts = _subaccts = Request.GetValidated("SubAccts", false); var showBalance = Request.GetValidated("ShowBal", false, val => !(val && _subaccts), Tr.PgTrns.Validation_ShowBalVsSubAccts); _subaccts &= _account.EnumChildren().Any(); ReportTable table = new ReportTable(); var colDate = table.AddCol(Tr.PgTrns.ColDate); var colDesc = table.AddCol(Tr.PgTrns.ColDescription); var colQty = table.AddCol(Tr.PgTrns.ColQuantity); var colCcy = table.AddCol(Tr.PgTrns.ColCurrency); var colBal = table.AddCol(Tr.PgTrns.ColBalance); var colAcct = table.AddCol(Tr.PgTrns.ColAccount); var colInBase = table.AddCol(Tr.PgTrns.ColInBaseCcy.Fmt(Program.CurFile.Book.BaseCurrencyId)); if (!_subaccts) { table.Cols.Remove(colAcct); } if (showBalance) { table.Cols.Remove(colInBase); } else { table.Cols.Remove(colBal); } var splits = _account.EnumSplits(_subaccts); splits = splits.Where(split => split.Transaction.DatePosted >= frDate && split.Transaction.DatePosted <= toDate); splits = splits.OrderBy(split => split.Transaction); foreach (var split in splits) { var trn = split.Transaction; var row = table.AddRow(); row.SetValue(colDate, trn.DatePosted.ToShortDateString()); row.SetValue(colDesc, (split.Memo == null || split.Memo == "" || split.Memo == trn.Description) ? trn.Description : (trn.Description + " [" + split.Memo + "]")); row.SetValue(colQty, split.Quantity.ToString(amtFmt), ReportTable.CssClassNumber(split.Quantity)); row.SetValue(colCcy, split.Account.Commodity.Identifier, "ccy_name ccy_" + split.Account.Commodity.Identifier.Replace(":", "_")); if (!showBalance) { row.SetValue(colInBase, split.AmountConverted(Program.CurFile.Book.BaseCurrency).Quantity.ToString(amtFmt), ReportTable.CssClassNumber(split.Quantity)); } if (showBalance) { row.SetValue(colBal, split.AccountBalanceAfter.ToString(amtFmt), ReportTable.CssClassNumber(split.AccountBalanceAfter)); } if (_subaccts) { row.SetValue(colAcct, generateAcctPath(split.Account)); } if (split.IsBalsnap) { try { row.CssClass = split.AccountBalanceAfter == split.Balsnap ? "balsnap_ok" : "balsnap_wrong"; } catch (GncBalsnapParseException) { row.CssClass = "balsnap_error"; } } } return(Ut.NewArray( new P(Tr.PgMonthly.CurAccount, GetAccountBreadcrumbs("Acct", _account)), new P(Tr.PgTrns.ModeCaption, showBalance && !subAccts ? (object)new SPAN(Tr.PgTrns.ModeWithBalance) { class_ = "aw-current" } : new A(Tr.PgTrns.ModeWithBalance) { href = Request.Url.WithQuery("ShowBal", "true").WithoutQuery("SubAccts").ToHref() }, " · ", !showBalance && subAccts ? (object)new SPAN(Tr.PgTrns.ModeWithSubaccts) { class_ = "aw-current" } : new A(Tr.PgTrns.ModeWithSubaccts) { href = Request.Url.WithoutQuery("ShowBal").WithQuery("SubAccts", "true").ToHref() } ), new P(Tr.PgTrns.RoundingCaption, amtFmt == "#,0" ? (object)new SPAN(Tr.PgTrns.RoundingWhole) { class_ = "aw-current" } : new A(Tr.PgTrns.RoundingWhole) { href = Request.Url.WithoutQuery("AmtFmt").ToHref() }, " · ", amtFmt == "#,0.00" ? (object)new SPAN(Tr.PgTrns.RoundingDecimals) { class_ = "aw-current" } : new A(Tr.PgTrns.RoundingDecimals) { href = Request.Url.WithQuery("AmtFmt", "#,0.00").ToHref() } ), new P(Tr.PgTrns.DateCaption, (frDate == minDate && toDate == maxDate) ? (object)Tr.PgTrns.ShowingAll : (frDate == minDate) ? Tr.PgTrns.ShowingOnOrBefore.FmtEnumerable( (object)Ut.NewArray <object>(new SPAN(toDate.ToShortDateString()) { class_ = "filter_hilite" }, " (", new A(Tr.PgTrns.DateRemove) { href = Request.Url.WithoutQuery("To").ToHref() }, ")") ) : (toDate == maxDate) ? Tr.PgTrns.ShowingOnOrAfter.FmtEnumerable( (object)Ut.NewArray <object>(new SPAN(frDate.ToShortDateString()) { class_ = "filter_hilite" }, " (", new A(Tr.PgTrns.DateRemove) { href = Request.Url.WithoutQuery("Fr").ToHref() }, ")") ) : Tr.PgTrns.ShowingBetween.FmtEnumerable( Ut.NewArray <object>(new SPAN(frDate.ToShortDateString()) { class_ = "filter_hilite" }, " (", new A(Tr.PgTrns.DateRemove) { href = Request.Url.WithoutQuery("Fr").ToHref() }, ")"), Ut.NewArray <object>(new SPAN(toDate.ToShortDateString()) { class_ = "filter_hilite" }, " (", new A(Tr.PgTrns.DateRemove) { href = Request.Url.WithoutQuery("To").ToHref() }, ")") ) ), table.GetHtml() )); }
/// <summary> /// Ported from subtotal_posts::report_subtotal /// </summary> public void ReportSubtotal(string specFmt = null, DateInterval interval = null) { if (!ComponentPosts.Any()) { return; } Date?rangeStart = interval != null ? interval.Start : null; Date?rangeFinish = interval != null ? interval.InclusiveEnd : null; if (!rangeStart.HasValue || !rangeFinish.HasValue) { foreach (Post post in ComponentPosts) { Date date = post.GetDate(); Date valueDate = post.ValueDate; if (!rangeStart.HasValue || date < rangeStart) { rangeStart = date; } if (!rangeFinish.HasValue || valueDate > rangeFinish) { rangeFinish = valueDate; } } } ComponentPosts.Clear(); string outDate; if (!String.IsNullOrEmpty(specFmt)) { outDate = TimesCommon.Current.FormatDate(rangeFinish.Value, FormatTypeEnum.FMT_CUSTOM, specFmt); } else if (!String.IsNullOrEmpty(DateFormat)) { outDate = "- " + TimesCommon.Current.FormatDate(rangeFinish.Value, FormatTypeEnum.FMT_CUSTOM, DateFormat); } else { outDate = "- " + TimesCommon.Current.FormatDate(rangeFinish.Value); } Xact xact = Temps.CreateXact(); xact.Payee = outDate; xact.Date = rangeStart.Value; foreach (KeyValuePair <string, AcctValue> pair in Values) { FiltersCommon.HandleValue( /* value= */ pair.Value.Value, /* account= */ pair.Value.Account, /* xact= */ xact, /* temps= */ Temps, /* handler= */ (PostHandler)Handler, /* date= */ rangeFinish.Value, /* act_date_p= */ false); } Values.Clear(); }
public static long DateDiff(DateInterval Interval, System.DateTime Date1, System.DateTime Date2, FirstDayOfWeek DayOfWeek, FirstWeekOfYear WeekOfYear) { }
private static IEnumerable <DateTime> GetOccurrences(DateInterval interval, DatePeriod period, Calendar calendar, DateTime start, DateTime end, bool skipWeekends = true) { var difference = DateSpan.GetDifference(interval, start, end) / period.Quantifier; if (start.Kind == DateTimeKind.Utc) { start = start.ToLocalTime(); } for (var i = 0; i < difference; i++) { switch (period.Frequency) { case DatePeriodFrequency.Seconds: var seconds = calendar.AddSeconds(start, period.Quantifier * i); yield return(DeferOccurrenceFallingOnWeekend(calendar, seconds, skipWeekends)); break; case DatePeriodFrequency.Minutes: var minutes = calendar.AddMinutes(start, period.Quantifier * i); yield return(DeferOccurrenceFallingOnWeekend(calendar, minutes, skipWeekends)); break; case DatePeriodFrequency.Hours: var hours = calendar.AddHours(start, period.Quantifier * i); yield return(DeferOccurrenceFallingOnWeekend(calendar, hours, skipWeekends)); break; case DatePeriodFrequency.Days: var days = calendar.AddDays(start, period.Quantifier * i); yield return(DeferOccurrenceFallingOnWeekend(calendar, days, skipWeekends)); break; case DatePeriodFrequency.Weeks: var weeks = calendar.AddWeeks(start, period.Quantifier * i); yield return(DeferOccurrenceFallingOnWeekend(calendar, weeks, skipWeekends)); break; case DatePeriodFrequency.Months: var months = calendar.AddMonths(start, period.Quantifier * i); yield return(DeferOccurrenceFallingOnWeekend(calendar, months, skipWeekends)); break; case DatePeriodFrequency.Years: var years = calendar.AddYears(start, period.Quantifier * i); yield return(DeferOccurrenceFallingOnWeekend(calendar, years, skipWeekends)); break; default: throw new ArgumentException("Frequency"); } } }
public static int DatePart(DateInterval Interval, System.DateTime DateValue, FirstDayOfWeek FirstDayOfWeekValue, FirstWeekOfYear FirstWeekOfYearValue) { }
public virtual void SupportsUnion(DateInterval dateInterval) { SupportsPropertyOrMethod(x => x.Union(dateInterval)); }
public static long DateDiff(DateInterval interval, DateTime dt1, DateTime dt2, DayOfWeek eFirstDayOfWeek) { if (interval == DateInterval.Year) { return(dt2.Year - dt1.Year); } if (interval == DateInterval.Month) { return((dt2.Month - dt1.Month) + (12 * (dt2.Year - dt1.Year))); } TimeSpan ts = dt2 - dt1; if (interval == DateInterval.Day || interval == DateInterval.DayOfYear) { return(Round(ts.TotalDays)); } if (interval == DateInterval.Hour) { return(Round(ts.TotalHours)); } if (interval == DateInterval.Minute) { return(Round(ts.TotalMinutes)); } if (interval == DateInterval.Second) { return(Round(ts.TotalSeconds)); } if (interval == DateInterval.Weekday) { return(Round(ts.TotalDays / 7.0)); } if (interval == DateInterval.WeekOfYear) { while (dt2.DayOfWeek != eFirstDayOfWeek) { dt2 = dt2.AddDays(-1); } while (dt1.DayOfWeek != eFirstDayOfWeek) { dt1 = dt1.AddDays(-1); } ts = dt2 - dt1; return(Round(ts.TotalDays / 7.0)); } if (interval == DateInterval.Quarter) { double d1Quarter = GetQuarter(dt1.Month); double d2Quarter = GetQuarter(dt2.Month); double d1 = d2Quarter - d1Quarter; double d2 = (4 * (dt2.Year - dt1.Year)); return(Round(d1 + d2)); } return(0); }
public void Union_NullInterval_Throws() { var value = new DateInterval(new LocalDate(100), new LocalDate(200)); Assert.Throws <ArgumentNullException>(() => value.Union(null)); }
public static AggregationContainerDescriptor <T> IntoDateHistogram <T>(this AggregationContainerDescriptor <T> innerAggregation, Expression <Func <T, object> > fieldGetter, DateInterval interval) where T : class { AggregationContainerDescriptor <T> v = new AggregationContainerDescriptor <T>(); var fieldName = GetName(fieldGetter); v.DateHistogram(fieldName, dr => { DateHistogramAggregationDescriptor <T> dateAggDesc = new DateHistogramAggregationDescriptor <T>(); dateAggDesc.Field(fieldGetter).Interval(interval); return(dateAggDesc.Aggregations(x => innerAggregation)); }); return(v); }
// Methods public static System.DateTime DateAdd(DateInterval Interval, double Number, System.DateTime DateValue) { }
/// <inheritdoc cref="IDateHistogramGroupSource.FixedInterval"/> public DateHistogramGroupSourceDescriptor <T> FixedInterval(DateInterval dateInterval) => Assign(dateInterval, (a, v) => a.FixedInterval = v);
public bool IsInInterval(DateInterval interval) { return(Pdt >= interval.Start && Pdt <= interval.End); }
/// <inheritdoc cref="IDateHistogramGroupSource.CalendarInterval"/> public DateHistogramGroupSourceDescriptor <T> CalendarInterval(DateInterval dateInterval) => Assign(dateInterval, (a, v) => a.CalendarInterval = v);
public static long DateDiff(DateInterval interval, DateTime dt1, DateTime dt2) { return(DateDiff(interval, dt1, dt2, System.Globalization.DateTimeFormatInfo.CurrentInfo.FirstDayOfWeek)); }
public static bool IsInCurrentDateInterval(this DateTime dateTime, DateTime selectedDate, DateInterval dateInterval) { if (dateInterval == DateInterval.Day) { return(dateTime.Date == selectedDate.Date); } else if (dateInterval == DateInterval.Week) { return(dateTime.Date >= selectedDate.SearchedDayOfWeek(DayOfWeek.Monday).Date&& dateTime.Date <= selectedDate.SearchedDayOfWeek(DayOfWeek.Sunday).Date); } else if (dateInterval == DateInterval.Month) { return(dateTime.Date >= selectedDate.SearchFirstDayOfMonth().Date&& dateTime.Date <= selectedDate.SearchLastDayOfMonth().Date); } else if (dateInterval == DateInterval.Year) { return(dateTime.Date >= selectedDate.SearchFirstDayOfYear().Date&& dateTime.Date <= selectedDate.SearchLastDayOfYear().Date); } else if (dateInterval == DateInterval.All) { return(true); } else { throw new Exception("Wrong parameters were passed"); } }
private ResultSetBuilder EvaluateCompare(Expression exp) { var memberName = ExHelper.GetMemberName(exp, _itemType); var literal = ExHelper.GetLiteralValue(exp, _parameters); var columnMetadata = GetTimestamp(_journal.Metadata); if (columnMetadata != null && string.Equals(columnMetadata.PropertyName, memberName, StringComparison.OrdinalIgnoreCase) && (literal is long || literal is DateTime)) { DateInterval filterInterval; var nodeType = exp.NodeType; if (exp.GetLeft().NodeType == ExpressionType.Constant) { nodeType = InvertComarison(nodeType); } switch (nodeType) { case ExpressionType.GreaterThan: var timestamp = literal is long ?DateUtils.UnixTimestampToDateTime((long)literal + 1) : ((DateTime)literal).AddTicks(1); filterInterval = DateInterval.From(timestamp); break; case ExpressionType.GreaterThanOrEqual: timestamp = literal is long ?DateUtils.UnixTimestampToDateTime((long)literal) : (DateTime)literal; filterInterval = DateInterval.From(timestamp); break; case ExpressionType.LessThan: timestamp = literal is long ?DateUtils.UnixTimestampToDateTime((long)literal) : (DateTime)literal; filterInterval = DateInterval.To(timestamp); break; case ExpressionType.LessThanOrEqual: timestamp = literal is long ?DateUtils.UnixTimestampToDateTime((long)literal + 1) : ((DateTime)literal).AddTicks(1); filterInterval = DateInterval.To(timestamp); break; default: throw QueryExceptionExtensions.ExpressionNotSupported(string.Format( "Timestamp column operation {0} is not supported. Supported operations are <, >, <=, >=", nodeType), exp); } var result = new ResultSetBuilder(_journal, _tx); result.TimestampInterval(filterInterval); return(result); } throw QueryExceptionExtensions.ExpressionNotSupported( "Comparison is supported for timestamp column only. Unable to bind '{0} to journal query operation", exp); }
public static AggregationContainerDescriptor <T> DateHistogram <T>(this AggregationContainerDescriptor <T> agg, Expression <Func <T, object> > fieldGetter, DateInterval dateInterval) where T : class { return(agg.DateHistogram(GetName(fieldGetter), x => x.Field(fieldGetter).Interval(dateInterval))); }