/// <summary> /// Initializes a new instance of the <see cref="ComplexAnnotationReferenceCore"/> class. /// </summary> /// <param name="returnLatest"> /// The return latest. /// </param> /// <param name="version"> /// The version. /// </param> /// <param name="validFrom"> /// The valid from. /// </param> /// <param name="validTo"> /// The valid to. /// </param> public ComplexVersionReferenceCore(TertiaryBool returnLatest, string version, ITimeRange validFrom, ITimeRange validTo) { if (returnLatest != null) { this._returnLatest = returnLatest; } this._version = version; this._validFrom = validFrom; this._validTo = validTo; }
/// <summary> /// Gets amount of correct answers in a given time range. /// </summary> /// <param name="timeRange"></param> /// <returns></returns> public async Task<int> GetAmountCorrectAsync(ITimeRange timeRange) { var start = new BsonDateTime(timeRange.Start); var end = new BsonDateTime(timeRange.End); var answersSuccessful = await _repository.Find( a => a.Correct == Convert.ToInt32(true) && a.SubmitDateTime > start && a.SubmitDateTime < end); return answersSuccessful.Count(); }
public bool CompareTo(RuleValue value1, RuleValue value2) { if (value1.IsTimeRange && value2.IsTime) { ITimeRange tr = value1.Value as ITimeRange; DateTime dt = Convert.ToDateTime(value2.Value); SimpleTime st = SimpleTime.FromDateTime(dt); return(tr.ContainsTime(st)); } else { throw new ArgumentException("CompareTo does not work with the value types provided."); } }
/// <summary> /// Find out which user had made the most progress in a given time range. /// </summary> /// <param name="timeRange"></param> /// <returns></returns> public async Task<User> GetMostProgressAsync(ITimeRange timeRange) { var answers = await GetAnswersAsync(timeRange); var result = answers.GroupBy(answer => answer.UserId).Select(userAnswers => new { UserId = userAnswers.Key, Progress = userAnswers.Sum(answer => answer.Progress) }) .OrderByDescending(progress => progress.Progress) .FirstOrDefault(); return result == null ? null : new User { UserId = result.UserId }; }
/// <summary> /// Get ratio of overlap between given Energiemenge and a reference. /// Method is basically just another name for <see cref="GetOverlapFactor"/> /// </summary> /// <param name="em">Energiemenge</param> /// <param name="reference">reference time range</param> /// <param name="obisKz">OBIS</param> /// <param name="mengeneinheit">unit of measurement</param> /// <param name="wev">type of measurement</param> /// <param name="decimalRounding">post decimals</param> /// <returns>value between 0 (no overlap) and 1.0 (100% overlap)</returns> public static decimal GetCoverage(this BO.Energiemenge em, ITimeRange reference, Wertermittlungsverfahren wev, string obisKz, Mengeneinheit mengeneinheit, int decimalRounding = 10) { decimal exactResult; using (MiniProfiler.Current.Step( $"calculating coverage for list with {em.Energieverbrauch.Count} entries.")) { exactResult = em.Energieverbrauch .Where(v => v.Einheit == mengeneinheit && v.Obiskennzahl == obisKz && v.Wertermittlungsverfahren == wev) .Sum(v => GetOverlapFactor(new TimeRange(v.Startdatum, v.Enddatum), reference, true)); } return(Math.Round(exactResult, decimalRounding)); }
/// <summary> /// Get percentage of time range covered by pure Energiemenge. /// </summary> /// <param name="em">pure Energiemenge</param> /// <param name="reference">time frame reference</param> /// <returns>value between 0 (only coverage for 1 point in time) and 1.0 (100% coverage)</returns> public static decimal GetCoverage(this BO4E.BO.Energiemenge em, ITimeRange reference) { using (MiniProfiler.Current.Step(nameof(GetCoverage))) { if (!IsPure(em)) { throw new ArgumentException("The Energiemenge is not pure. Cannot determine parameters."); } if (em.Energieverbrauch.Count == 0) { return(0.0M); } Verbrauch v = em.Energieverbrauch.First <Verbrauch>(); return(em.GetCoverage(reference, v.Wertermittlungsverfahren, v.Obiskennzahl, v.Einheit)); } }
/// <summary> /// Initializes a new instance of the <see cref="TimeRangeMutableCore"/> class. /// </summary> /// <param name="immutable"> /// The immutable. /// </param> public TimeRangeMutableCore(ITimeRange immutable) : base(SdmxStructureType.GetFromEnum(SdmxStructureEnumType.TimeRange)) { if (immutable.StartDate != null) { this.startDate = immutable.StartDate.Date; } if (immutable.EndDate != null) { this.endDate = immutable.EndDate.Date; } this._isIsRange = immutable.Range; this.isStartInclusive = immutable.StartInclusive; this.isEndInclusive = immutable.EndInclusive; }
public static ITimeRange Join(this ITimeRange value1, ITimeRange value) { if (!value.IsValid() || !value1.IsValid()) throw new Exception("Invalid time range."); DateTime? newFromDate = value.FromDate > value1.FromDate ? value.FromDate : value1.FromDate; DateTime? newToDate = value.ToDate.HasValue ? (value1.ToDate.HasValue ? (value.ToDate < value1.ToDate ? value.ToDate : value1.ToDate) : value.ToDate) : value1.ToDate; TimeRange range = new TimeRange() { FromDate = newFromDate, ToDate = newToDate }; return range.IsValid() ? range : new TimeRange(); }
public void IntersectionPeriodsTimePeriodTest() { DateTime now = ClockProxy.Clock.Now; TimeRange timeRange1 = new TimeRange(new DateTime(now.Year, now.Month, 8), new DateTime(now.Year, now.Month, 18)); TimeRange timeRange2 = new TimeRange(new DateTime(now.Year, now.Month, 10), new DateTime(now.Year, now.Month, 11)); TimeRange timeRange3 = new TimeRange(new DateTime(now.Year, now.Month, 13), new DateTime(now.Year, now.Month, 15)); TimeRange timeRange4 = new TimeRange(new DateTime(now.Year, now.Month, 9), new DateTime(now.Year, now.Month, 13)); TimeRange timeRange5 = new TimeRange(new DateTime(now.Year, now.Month, 15), new DateTime(now.Year, now.Month, 17)); TimePeriodCollection timePeriods = new TimePeriodCollection(); timePeriods.Add(timeRange1); timePeriods.Add(timeRange2); timePeriods.Add(timeRange3); timePeriods.Add(timeRange4); timePeriods.Add(timeRange5); Assert.Equal(5, timePeriods.IntersectionPeriods(timeRange1).Count); Assert.Equal(3, timePeriods.IntersectionPeriods(timeRange2).Count); Assert.Equal(4, timePeriods.IntersectionPeriods(timeRange3).Count); Assert.Equal(4, timePeriods.IntersectionPeriods(timeRange4).Count); Assert.Equal(3, timePeriods.IntersectionPeriods(timeRange5).Count); ITimeRange test1 = timeRange1.Copy(new TimeSpan(100, 0, 0, 0).Negate()); ITimePeriodCollection insidePeriods1 = timePeriods.IntersectionPeriods(test1); Assert.Equal(0, insidePeriods1.Count); ITimeRange test2 = timeRange1.Copy(new TimeSpan(100, 0, 0, 0)); ITimePeriodCollection insidePeriods2 = timePeriods.IntersectionPeriods(test2); Assert.Equal(0, insidePeriods2.Count); TimeRange test3 = new TimeRange(new DateTime(now.Year, now.Month, 9), new DateTime(now.Year, now.Month, 11)); ITimePeriodCollection insidePeriods3 = timePeriods.IntersectionPeriods(test3); Assert.Equal(3, insidePeriods3.Count); TimeRange test4 = new TimeRange(new DateTime(now.Year, now.Month, 14), new DateTime(now.Year, now.Month, 17)); ITimePeriodCollection insidePeriods4 = timePeriods.IntersectionPeriods(test4); Assert.Equal(3, insidePeriods4.Count); } // IntersectionPeriodsTimePeriodTest
internal static IList <ITimeRange> GetLocalDailySlices(ITimeRange overallTimeRange, TimeZoneInfo tz = null) { if (overallTimeRange == null) { throw new ArgumentNullException(nameof(overallTimeRange), "overall time range must not be null"); } if (tz == null) { tz = CentralEuropeStandardTime.CentralEuropeStandardTimezoneInfo; } if (overallTimeRange.Start.Kind == DateTimeKind.Unspecified) { throw new ArgumentException("TimeRange start must not have DateTimeKind.Unspecified", nameof(overallTimeRange)); } if (overallTimeRange.End.Kind == DateTimeKind.Unspecified) { throw new ArgumentException("TimeRange end must not have DateTimeKind.Unspecified", nameof(overallTimeRange)); } IList <ITimeRange> result = new List <ITimeRange>(); if (!overallTimeRange.IsMoment) { result.Add(new TimeRange { Start = overallTimeRange.Start, End = overallTimeRange.Start.AddDaysDST(1) }); while (result.Last().End < overallTimeRange.End) { result.Add(new TimeRange { Start = result.Last().Start.AddDaysDST(1), End = result.Last().End.AddDaysDST(1) }); } } return(result); }
public override void Setup(DateTime newStart, DateTime newEnd) { base.Setup(newStart, newEnd); if (sequenceInterval is YearTimeRange) { var yearCount = (sequenceInterval as YearTimeRange).YearCount; sequenceInterval = new Years(newStart, yearCount); } else if (sequenceInterval is MonthTimeRange) { var monthCount = (sequenceInterval as MonthTimeRange).MonthCount; sequenceInterval = new Months(newStart, (YearMonth)newStart.Month, monthCount); } else { var duration = sequenceInterval.Duration + TimeSpec.MinPositiveDuration; sequenceInterval = new CalendarTimeRange(newStart, duration); } }
/// <summary> /// Sets StartTime and EndTime of a target range /// </summary> /// <param name="range">Target range</param> public void Convert(ITimeRange range) { DateTime now = DateTime.UtcNow; try { range.StartTime = DateTimeExtension.Max(MinValue, ConvertStartTime(now)); } catch (ArgumentOutOfRangeException) { range.StartTime = MinValue; } try { range.EndTime = DateTimeExtension.Min(MaxValue, ConvertEndTime(now)); } catch (ArgumentOutOfRangeException) { range.EndTime = MaxValue; } }
/// <summary> /// Test, if the single entries/intervals of the energieverbrauch array share the same duration and spacing in time. /// </summary> /// <param name="em">Energiemenge</param> /// <param name="reference">reference time frame</param> /// <param name="wev">Wertermittlungsverfahren</param> /// <param name="obis">OBIS-Kennzahl</param> /// <param name="me">Mengeneinheit</param> /// <param name="allowGaps">set true to allow gaps</param> /// <returns> /// True, if all energieverbrauch entries have the same length and their start and enddatum are evenly spaced. /// Also true, if there less than 2 entries in the energieverbrauch array. /// </returns> public static bool IsEvenlySpaced(this BO.Energiemenge em, ITimeRange reference, Wertermittlungsverfahren wev, string obis, Mengeneinheit me, bool allowGaps = false) { HashSet <TimeSpan> startEndDatumPeriods; using (MiniProfiler.Current.Step("finding time spans")) { startEndDatumPeriods = GetTimeSpans(em, wev, obis, me); } if (startEndDatumPeriods.Count < 2) { return(true); } if (allowGaps) { // each time difference must be a multiple of the smallest difference. using (MiniProfiler.Current.Step("Iterating over all time spans")) { var minDiff = startEndDatumPeriods.Min().TotalSeconds; foreach (var ts in startEndDatumPeriods) { if (Math.Abs(ts.TotalSeconds % minDiff) != 0) { // use profiler as logger: using (MiniProfiler.Current.Step( $"Found TimeSpan {ts} with a duration of {ts.TotalSeconds}. This is no multiple of {minDiff} => not evenly spaced.")) { return(false); } } } } return(true); } // there must be only 1 time difference between all the elements return(startEndDatumPeriods.Count <= 1); }
public static ITimeRange Join(this ITimeRange value1, ITimeRange value) { if (!value.IsValid() || !value1.IsValid()) { throw new Exception("Invalid time range."); } DateTime?newFromDate = value.FromDate > value1.FromDate ? value.FromDate : value1.FromDate; DateTime?newToDate = value.ToDate.HasValue ? (value1.ToDate.HasValue ? (value.ToDate < value1.ToDate ? value.ToDate : value1.ToDate) : value.ToDate) : value1.ToDate; TimeRange range = new TimeRange() { FromDate = newFromDate, ToDate = newToDate }; return(range.IsValid() ? range : new TimeRange()); }
public void GetIntersectionTest() { TimeRange readOnlyTimeRange = new TimeRange(start, end); Assert.Equal(readOnlyTimeRange.GetIntersection(readOnlyTimeRange), new TimeRange(readOnlyTimeRange)); TimeRange timeRange = new TimeRange(start, end); // before ITimeRange before1 = timeRange.GetIntersection(new TimeRange(start.AddHours(-2), start.AddHours(-1))); Assert.Null(before1); ITimeRange before2 = timeRange.GetIntersection(new TimeRange(start.AddMilliseconds(-1), start)); Assert.Equal(before2, new TimeRange(start)); ITimeRange before3 = timeRange.GetIntersection(new TimeRange(start.AddMilliseconds(-1), start.AddMilliseconds(1))); Assert.Equal(before3, new TimeRange(start, start.AddMilliseconds(1))); // after ITimeRange after1 = timeRange.GetIntersection(new TimeRange(end.AddHours(1), end.AddHours(2))); Assert.Null(after1); ITimeRange after2 = timeRange.GetIntersection(new TimeRange(end, end.AddMilliseconds(1))); Assert.Equal(after2, new TimeRange(end)); ITimeRange after3 = timeRange.GetIntersection(new TimeRange(end.AddMilliseconds(-1), end.AddMilliseconds(1))); Assert.Equal(after3, new TimeRange(end.AddMilliseconds(-1), end)); // intersect Assert.Equal(timeRange.GetIntersection(timeRange), timeRange); ITimeRange itersect1 = timeRange.GetIntersection(new TimeRange(start.AddMilliseconds(-1), end.AddMilliseconds(1))); Assert.Equal(itersect1, timeRange); ITimeRange itersect2 = timeRange.GetIntersection(new TimeRange(start.AddMilliseconds(1), end.AddMilliseconds(-1))); Assert.Equal(itersect2, new TimeRange(start.AddMilliseconds(1), end.AddMilliseconds(-1))); } // GetIntersectionTest
private void SetAssignmentRange() { if (ContractShift == null) { return; } if (WorkDay == null || WorkDay.ResourceShift == null) { return; } ITimeRange timeRange = ContractShift.WorkDayRange.GetIntersection(WorkDay.ResourceShift.WorkDayRange); if (timeRange == null) { return; } RangeFrom = new TimeSpan(timeRange.Start.Hour, timeRange.Start.Minute, 0); RangeUntil = new TimeSpan(timeRange.End.Hour, timeRange.End.Minute, 0); }
public override ITimePeriod GetTimePeriod(DateTime baseDate) { var retrievedNumericValue = NumericValue.Match(Text).Value; var numericValue = int.Parse(retrievedNumericValue); var namedEntity = NamedEntity.Match(Text).Value; ITimeRange result = null; var lowerText = Text.ToLower(); if (namedEntity == "minute") { result = new Minutes(baseDate.AddMinutes(-numericValue), numericValue); } else if (namedEntity == "hour") { result = new Hours(baseDate.AddHours(-numericValue), numericValue); } else if (namedEntity == "day") { result = new Days(baseDate.AddDays(-numericValue), numericValue); } else if (namedEntity == "week") { result = new Weeks(baseDate.AddDays(-numericValue * 7), numericValue); } else if (namedEntity == "month") { var moment = baseDate.AddMonths(-numericValue); result = new Months(moment, (YearMonth)moment.Month, numericValue); } else if (namedEntity == "year") { result = new Years(baseDate.AddYears(-numericValue), numericValue); } return(result); }
} // GetTimeLineMoments // ---------------------------------------------------------------------- private ITimeLineMomentCollection GetTimeLineMoments(ICollection <ITimePeriod> momentPeriods) { TimeLineMomentCollection timeLineMoments = new TimeLineMomentCollection(); if (momentPeriods.Count == 0) { return(timeLineMoments); } // setup gap set with all start/end points ITimePeriodCollection intersections = new TimePeriodCollection(); foreach (ITimePeriod momentPeriod in momentPeriods) { if (momentPeriod.IsMoment) { continue; } // calculate the intersection between the periods ITimeRange intersection = limits.GetIntersection(momentPeriod); if (intersection == null || intersection.IsMoment) { continue; } if (periodMapper != null) { intersection = new TimeRange(MapPeriodStart(intersection.Start), MapPeriodEnd(intersection.End)); } intersections.Add(intersection); } timeLineMoments.AddAll(intersections); return(timeLineMoments); } // GetTimeLineMoments
public static bool ValidateTimeRange <T>(this List <T> ranges) where T : ITimeRange { for (int counter = 0; counter < ranges.Count; counter++) { ITimeRange range = ranges[counter]; if (!range.ValidateTimeRange()) { return(false); } for (int subCounter = counter + 1; subCounter < ranges.Count; subCounter++) { ITimeRange subRange = ranges[subCounter]; if ((subRange.StartTime <= range.StartTime & range.StartTime <= subRange.EndTime) || (subRange.StartTime < range.EndTime & range.EndTime <= subRange.EndTime) || (range.StartTime <= subRange.StartTime && range.EndTime >= subRange.EndTime)) { return(false); } } } return(true); }
/////////////////////////////////////////////////////////////////////////////////////////////////// ////////////BUILD FROM MUTABLE OBJECT ////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////// #region Constructors and Destructors /// <summary> /// Initializes a new instance of the <see cref="KeyValuesCore"/> class. /// </summary> /// <param name="mutable"> /// The mutable. /// </param> /// <param name="parent"> /// The parent. /// </param> public KeyValuesCore(IKeyValuesMutable mutable, ISdmxStructure parent) : base(SdmxStructureType.GetFromEnum(SdmxStructureEnumType.KeyValues), parent) { this.values = new List<string>(); this.caseCadeList = new List<string>(); this.id = mutable.Id; this.values.AddRange(mutable.KeyValues); foreach (string value in this.values) { if (mutable.IsCascadeValue(value)) { this.caseCadeList.Add(value); } } if (mutable.TimeRange != null) { this.timeRange = new TimeRangeCore(mutable.TimeRange, this); } Validate(); }
/////////////////////////////////////////////////////////////////////////////////////////////////// ////////////BUILD FROM V2.1 SCHEMA ////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> /// Initializes a new instance of the <see cref="KeyValuesCore"/> class. /// </summary> /// <param name="keyValueType"> /// The key value type. /// </param> /// <param name="parent"> /// The parent. /// </param> public KeyValuesCore(ComponentValueSetType keyValueType, ISdmxStructure parent) : base(SdmxStructureType.GetFromEnum(SdmxStructureEnumType.KeyValues), parent) { this.values = new List<string>(); this.caseCadeList = new List<string>(); this.id = keyValueType.id; if (keyValueType.Value != null) { foreach (SimpleValueType dataKeyType in keyValueType.Value) { this.values.Add(dataKeyType.TypedValue); if (dataKeyType.cascadeValues) { this.caseCadeList.Add(dataKeyType.TypedValue); } } } if (keyValueType.TimeRange != null) { this.timeRange = new TimeRangeCore(keyValueType.TimeRange, this); } Validate(); }
static void Main(string[] args) { if (!EventLog.SourceExists(evtLogSrc)) { EventLog.CreateEventSource(evtLogSrc, "Application"); } try { var runStartTime = DateTime.Now; EventLog.WriteEntry(evtLogSrc, string.Format("Run started {0}.", runStartTime.ToString()), EventLogEntryType.Information); string groupPrefix = ""; int cycleOffset = -1; string accountsLstNm = "Accounts"; string ratesLstNm = "Rates"; string fixedConsumptionsLstNm = "Fixed Consumptions"; string consumptionsLstNm = "Consumptions"; string chargesLstNm = "Charges"; string billingPeriodStr = "1m"; bool isCycleOpen = false; bool? incremental = null; string lastRunFileName = "billease_last_run.log"; DateTime cycleCalibrationDate = new DateTime(DateTime.Now.Year, DateTime.Now.Month, 1, 0, 0, 0, DateTimeKind.Local); Dictionary <string, List <KeyValuePair <string, string> > > listColumnsToCopy = new Dictionary <string, List <KeyValuePair <string, string> > >(); listColumnsToCopy.Add("Account", new List <KeyValuePair <string, string> >()); listColumnsToCopy.Add("Rate", new List <KeyValuePair <string, string> >()); listColumnsToCopy.Add("Consumption", new List <KeyValuePair <string, string> >()); var options = new OptionSet() { { "p|prefix_of_group=", v => groupPrefix = v } , { "o|offset_of_cycle=", v => cycleOffset = int.Parse(v) } , { "b|billing_period=", v => billingPeriodStr = v } , { "d|cycle_calibration_date=", v => cycleCalibrationDate = DateTime.ParseExact(v, "yyyy-MM-dd", CultureInfo.InvariantCulture) } , { "a|accounts_list_name=", v => accountsLstNm = v } , { "r|rates_list_name=", v => ratesLstNm = v } , { "f|fixed_consumptions_list_name=", v => fixedConsumptionsLstNm = v } , { "c|consumptions_list_name=", v => consumptionsLstNm = v } , { "h|charges_list_name=", v => chargesLstNm = v } , { "A|account_columns_to_copy=", v => { var src = v; var dst = v; if (v.Contains(":")) { src = v.Substring(0, v.IndexOf(":")); dst = v.Substring(v.IndexOf(":") + 1); } listColumnsToCopy["Account"].Add(new KeyValuePair <string, string>(src, dst)); } } , { "R|rate_columns_to_copy=", v => { var src = v; var dst = v; if (v.Contains(":")) { src = v.Substring(0, v.IndexOf(":")); dst = v.Substring(v.IndexOf(":") + 1); } listColumnsToCopy["Rate"].Add(new KeyValuePair <string, string>(src, dst)); } } , { "C|consumption_columns_to_copy=", v => { var src = v; var dst = v; if (v.Contains(":")) { src = v.Substring(0, v.IndexOf(":")); dst = v.Substring(v.IndexOf(":") + 1); } listColumnsToCopy["Consumption"].Add(new KeyValuePair <string, string>(src, dst)); } } , { "O|is_cycle_open=", v => isCycleOpen = Convert.ToBoolean(v) } , { "i|incremental=", v => incremental = Convert.ToBoolean(v) } , { "l|last_run_log_file_name=", v => lastRunFileName = v } }; List <String> extraArgs = options.Parse(args); if (incremental == null) { incremental = isCycleOpen; } ServicePointManager.ServerCertificateValidationCallback = MyCertHandler; var cc = new ClientContext(extraArgs[0]); cc.Credentials = System.Net.CredentialCache.DefaultCredentials; Match billingPeriodMatch = Regex.Match(billingPeriodStr, @"(\d)([mdy])"); int billingPeriod = 0; string billingPeriodUOM = null; if (billingPeriodMatch.Success) { billingPeriod = Int32.Parse(billingPeriodMatch.Groups[1].Value); billingPeriodUOM = billingPeriodMatch.Groups[2].Value; } var billingCycleStart = DateTime.Now; TimeSpan s = billingCycleStart - cycleCalibrationDate; switch (billingPeriodUOM) { case "d": billingCycleStart = cycleCalibrationDate.AddDays(s.TotalDays - (s.TotalDays % billingPeriod) + cycleOffset * billingPeriod); break; case "m": int monthDiff = (billingCycleStart.Year - cycleCalibrationDate.Year) * 12 + billingCycleStart.Month - cycleCalibrationDate.Month; billingCycleStart = cycleCalibrationDate.AddMonths(monthDiff - (monthDiff % billingPeriod) + cycleOffset * billingPeriod); break; case "y": int yearDiff = (int)s.TotalDays / 365; billingCycleStart = cycleCalibrationDate.AddYears(yearDiff - (yearDiff % billingPeriod) + cycleOffset * billingPeriod); break; } DateTime nextBillingcycleStart = DateTime.Now; switch (billingPeriodUOM) { case "d": nextBillingcycleStart = billingCycleStart.AddDays(billingPeriod); break; case "m": nextBillingcycleStart = billingCycleStart.AddMonths(billingPeriod); break; case "y": nextBillingcycleStart = billingCycleStart.AddYears(billingPeriod); break; } TimeRange billingRange = new TimeRange(billingCycleStart, nextBillingcycleStart); // get last run timestamp var lastRunTs = new DateTime(1970, 01, 01); try { string[] lines = System.IO.File.ReadAllLines(lastRunFileName); DateTime lastRunCycle = DateTime.Parse(lines[0]); if (lastRunCycle.Date == billingCycleStart.Date) { lastRunTs = DateTime.Parse(lines[1]); } } catch { } // delete consumptions associated with deleted fixed consumptions var query = new CamlQuery(); query.ViewXml = string.Format(@"<View><Query> <Where> <And> <Eq> <FieldRef Name='Cycle' /> <Value Type='DateTime'>{0}</Value> </Eq> <And> <IsNull> <FieldRef Name='Fixed_x0020_Consumption_x0020_Re' /> </IsNull> <Geq> <FieldRef Name='Fixed_x0020_Consumption_x0020_Re' LookupId='TRUE' /> <Value Type=”Lookup”>0</Value> </Geq> </And> </And> </Where> </Query></View>", billingCycleStart.ToString("yyyy-MM-dd")); var consumptionLst = cc.Web.Lists.GetByTitle(consumptionsLstNm); var consumptionFC = consumptionLst.Fields; var consumptionDeletionLIC = consumptionLst.GetItems(query); cc.Load(consumptionFC); cc.Load(consumptionDeletionLIC); cc.ExecuteQuery(); while (consumptionDeletionLIC.Count > 0) { var consumptionLI = consumptionDeletionLIC[0]; consumptionLI.DeleteObject(); cc.ExecuteQuery(); } // delete charges associated with deleted consumptions query = new CamlQuery(); query.ViewXml = string.Format(@"<View><Query> <Where> <And> <Eq> <FieldRef Name='Cycle' /> <Value Type='DateTime'>{0}</Value> </Eq> <And> <IsNull> <FieldRef Name='Consumption_x0020_Ref' /> </IsNull> <Geq> <FieldRef Name='Consumption_x0020_Ref' LookupId='TRUE' /> <Value Type=”Lookup”>0</Value> </Geq> </And> </And> </Where> </Query></View>", billingCycleStart.ToString("yyyy-MM-dd")); var chgLst = cc.Web.Lists.GetByTitle(chargesLstNm); var chargesDeletionLIC = chgLst.GetItems(query); cc.Load(chargesDeletionLIC); cc.ExecuteQuery(); while (chargesDeletionLIC.Count > 0) { var chargeLI = chargesDeletionLIC[0]; chargeLI.DeleteObject(); cc.ExecuteQuery(); } // populate or update consumptions from fixed consumptions query = new CamlQuery(); query.ViewXml = string.Format(@" <View><Query> <Where> <And> <Or> <IsNull> <FieldRef Name='Service_x0020_Start' /> </IsNull> <Lt> <FieldRef Name='Service_x0020_Start' /> <Value Type='DateTime'>{0}</Value> </Lt> </Or> <Or> <IsNull> <FieldRef Name='Service_x0020_End' /> </IsNull> <Gt> <FieldRef Name='Service_x0020_End' /> <Value Type='DateTime'>{1}</Value> </Gt> </Or> </And> </Where> </Query></View>", nextBillingcycleStart.ToString("yyyy-MM-dd"), billingCycleStart.ToString("yyyy-MM-dd")); var fixedConsumptionsLst = cc.Web.Lists.GetByTitle(fixedConsumptionsLstNm); var fixedConsumptionLIC = fixedConsumptionsLst.GetItems(query); FieldCollection fixedConsumptionFC = fixedConsumptionsLst.Fields; cc.Load(fixedConsumptionFC); cc.Load(fixedConsumptionLIC); try { cc.ExecuteQuery(); foreach (var fixedConsumptionLI in fixedConsumptionLIC) { try { // check if consumption exists for the current billing cycle var consumptionItemQuery = new CamlQuery(); consumptionItemQuery.ViewXml = string.Format(@" <View><Query> <Where> <And> <Eq> <FieldRef Name='Fixed_x0020_Consumption_x0020_Re' LookupId='TRUE' /> <Value Type='Lookup'>{0}</Value> </Eq> <Eq> <FieldRef Name='Cycle' /> <Value Type='DateTime'>{1}</Value> </Eq> </And> </Where> </Query></View>", fixedConsumptionLI["ID"], billingCycleStart.ToString("yyyy-MM-dd")); var _consumptionLIC = consumptionLst.GetItems(consumptionItemQuery); cc.Load(_consumptionLIC); cc.ExecuteQuery(); ListItem consumptionItem; if (_consumptionLIC.Count > 0) { if (((DateTime)fixedConsumptionLI["Modified"]) < ((DateTime)_consumptionLIC[0]["Modified"])) { continue; } consumptionItem = _consumptionLIC[0]; } else { ListItemCreationInformation itemCreateInfo = new ListItemCreationInformation(); consumptionItem = consumptionLst.AddItem(itemCreateInfo); } foreach (Field field in fixedConsumptionFC) { if (field.FromBaseType && field.InternalName != "Title") { continue; } if (consumptionFC.FirstOrDefault(f => (!f.FromBaseType || f.InternalName == "Title") && f.InternalName == field.InternalName ) == null) { continue; } consumptionItem[field.InternalName] = fixedConsumptionLI[field.InternalName]; } // calculate proration try { if (fixedConsumptionLI["Prorated"] != null && fixedConsumptionLI["Prorated"].ToString().Contains("Yes") ) { DateTime serviceStart = DateTime.MinValue; DateTime serviceEnd = DateTime.MaxValue; if (fixedConsumptionLI["Service_x0020_Start"] != null) { serviceStart = ((DateTime)fixedConsumptionLI["Service_x0020_Start"]).ToLocalTime(); } if (fixedConsumptionLI["Service_x0020_End"] != null) { serviceEnd = ((DateTime)fixedConsumptionLI["Service_x0020_End"]).ToLocalTime(); } TimeRange serviceRange = new TimeRange(serviceStart, serviceEnd); ITimeRange overlap = serviceRange.GetIntersection(billingRange); double portion = overlap.Duration.TotalDays / billingRange.Duration.TotalDays; if (fixedConsumptionLI["Quantity"] != null) { var proratedQty = ((double)fixedConsumptionLI["Quantity"]) * portion; if (fixedConsumptionLI["Prorated"].ToString() != "Yes") { proratedQty = Convert.ToInt32(proratedQty); } consumptionItem["Quantity"] = proratedQty; } if (fixedConsumptionLI["Amount"] != null) { consumptionItem["Amount"] = ((double)fixedConsumptionLI["Amount"]) * portion; } } } catch { EventLog.WriteEntry(evtLogSrc, string.Format("Error calculating proration for fixed consumption with ID={0}", fixedConsumptionLI["ID"]), EventLogEntryType.Error); } consumptionItem["Cycle"] = billingCycleStart; FieldLookupValue lookup = new FieldLookupValue(); lookup.LookupId = (int)fixedConsumptionLI["ID"]; consumptionItem["Fixed_x0020_Consumption_x0020_Re"] = lookup; consumptionItem.Update(); cc.ExecuteQuery(); } catch (Exception ex) { EventLog.WriteEntry(evtLogSrc, string.Format("Error creating consumption from fixed consumption with ID {0}.\n{1}", (int)fixedConsumptionLI["ID"], ex.ToString()), EventLogEntryType.Error); } } } catch (Exception ex) { EventLog.WriteEntry(evtLogSrc, string.Format("Error creating consumption from fixed consumption.\n{0}", ex.ToString()), EventLogEntryType.Error); } // set incremental to false if there are updated accounts or rates since last run, foreach (var lstNm in new string[] { ratesLstNm, accountsLstNm }) { if (incremental != false) { query = new CamlQuery(); query.ViewXml = string.Format(@" <View> <Query> <Where> <Gt> <FieldRef Name='Modified' /> <Value IncludeTimeValue='true' Type='DateTime'>{0}</Value> </Gt> </Where> </Query> <RowLimit>1</RowLimit> </View>", lastRunTs.ToString("yyyy-MM-ddTHH:mm:ssZ")); var lst = cc.Web.Lists.GetByTitle(lstNm); var lic = lst.GetItems(query); cc.Load(lic); cc.ExecuteQuery(); if (lic.Count > 0) { incremental = false; } } } // populate or update charge from consumption query = new CamlQuery(); string viewXml = null; if (incremental == false) { viewXml = string.Format(@" <View><Query> <Where> <Eq> <FieldRef Name='Cycle' /> <Value Type='DateTime'>{0}</Value> </Eq> </Where> </Query></View>", billingCycleStart.ToString("yyyy-MM-dd")); } else { viewXml = string.Format(@" <View><Query> <Where> <And> <Eq> <FieldRef Name='Cycle' /> <Value Type='DateTime'>{0}</Value> </Eq> <Gt> <FieldRef Name='Modified' /> <Value IncludeTimeValue='true' Type='DateTime'>{1}</Value> </Gt> </And> </Where> </Query></View>", billingCycleStart.ToString("yyyy-MM-dd"), lastRunTs.ToString("yyyy-MM-ddTHH:mm:ssZ")); } query.ViewXml = viewXml; var consumptionLIC = consumptionLst.GetItems(query); cc.Load(consumptionLIC, items => items.IncludeWithDefaultProperties( item => item["HasUniqueRoleAssignments"] )); cc.Load(cc.Web.RoleDefinitions); var gc = cc.Web.SiteGroups; cc.Load(gc); cc.ExecuteQuery(); var restReadRD = cc.Web.RoleDefinitions.GetByName("Restricted Read"); var readRD = cc.Web.RoleDefinitions.GetByName("Read"); foreach (var consumptionLI in consumptionLIC) { ListItem chgItem; // check if charges exists var chgItemQuery = new CamlQuery(); chgItemQuery.ViewXml = string.Format(@" <View><Query> <Where> <Eq> <FieldRef Name='Consumption_x0020_Ref' LookupId='TRUE' /> <Value Type='Lookup'>{0}</Value> </Eq> </Where> </Query></View>", consumptionLI["ID"]); var chgLIC = chgLst.GetItems(chgItemQuery); cc.Load(chgLIC); cc.ExecuteQuery(); if (chgLIC.Count > 0) { chgItem = chgLIC[0]; if (isCycleOpen && incremental != false && ((DateTime)consumptionLI["Modified"]) < ((DateTime)chgItem["Modified"])) { continue; } chgItem.ResetRoleInheritance(); cc.ExecuteQuery(); } else { // create new charges item ListItemCreationInformation itemCreateInfo = new ListItemCreationInformation(); chgItem = chgLst.AddItem(itemCreateInfo); } // get org item var orgItemQuery = new CamlQuery(); orgItemQuery.ViewXml = string.Format(@" <View><Query> <Where> <Eq> <FieldRef Name='ID' /> <Value Type='Counter'>{0}</Value> </Eq> </Where> </Query></View>", ((FieldLookupValue)consumptionLI["Account"]).LookupId); var orgLst = cc.Web.Lists.GetByTitle(accountsLstNm); var orgLIC = orgLst.GetItems(orgItemQuery); cc.Load(orgLIC); // get rate item var rateItemQuery = new CamlQuery(); rateItemQuery.ViewXml = string.Format(@"<View><Query> <Where> <Eq> <FieldRef Name='ID' /> <Value Type='Counter'>{0}</Value> </Eq> </Where> </Query></View>", ((FieldLookupValue)consumptionLI["Rate"]).LookupId); var rateLst = cc.Web.Lists.GetByTitle(ratesLstNm); var rateLIC = rateLst.GetItems(rateItemQuery); cc.Load(rateLIC); cc.ExecuteQuery(); var orgItem = orgLIC.First(); var rateItem = rateLIC.First(); chgItem["Account"] = orgItem["Title"]; chgItem["Title"] = consumptionLI["Title"]; chgItem["Cycle"] = consumptionLI["Cycle"]; chgItem["Unit_x0020_Price"] = rateItem["Unit_x0020_Price"]; chgItem["Denominator"] = rateItem["Denominator"]; chgItem["UOM"] = rateItem["UOM"]; chgItem["Quantity"] = consumptionLI["Quantity"]; FieldLookupValue lookup = new FieldLookupValue(); lookup.LookupId = (int)consumptionLI["ID"]; chgItem["Consumption_x0020_Ref"] = lookup; // the order of list enumeration is important foreach (var lstNm in new string[] { "Account", "Rate", "Consumption" }) { KeyValuePair <string, List <KeyValuePair <string, string> > > listColumnToCopy = new KeyValuePair <string, List <KeyValuePair <string, string> > >(lstNm, listColumnsToCopy[lstNm]); if (listColumnToCopy.Value.Count <= 0) { continue; } ListItem item = null; switch (listColumnToCopy.Key) { case "Account": item = orgItem; break; case "Rate": item = rateItem; break; case "Consumption": item = consumptionLI; break; } foreach (var columnNVP in listColumnToCopy.Value) { try { if (item[columnNVP.Key] != null) { chgItem[columnNVP.Value] = item[columnNVP.Key]; } } catch { EventLog.WriteEntry(evtLogSrc, string.Format(@"Cannot copy column {0} in list {1} for consumption ID={2}", columnNVP.Key, listColumnToCopy.Key, consumptionLI["ID"]), EventLogEntryType.Error); } } } if (consumptionLI["Amount"] != null) { chgItem["Amount"] = consumptionLI["Amount"]; } else if (consumptionLI["Quantity"] != null && rateItem["Denominator"] != null && rateItem["Unit_x0020_Price"] != null && rateItem["Denominator"] != null && (double)rateItem["Denominator"] > 0) { var normalizedQty = (double)consumptionLI["Quantity"] / (double)rateItem["Denominator"]; try { if (rateItem["Round_x0020_Up"] != null && rateItem["Round_x0020_Up"] as Nullable <bool> == true) { normalizedQty = Math.Ceiling((double)consumptionLI["Quantity"] / (double)rateItem["Denominator"]); } } catch { EventLog.WriteEntry(evtLogSrc, string.Format("Error calculate round up for rate ID={0}, consumption ID={1}", rateItem["ID"], consumptionLI["ID"]), EventLogEntryType.Error); } chgItem["Amount"] = (double)rateItem["Unit_x0020_Price"] * normalizedQty; } if (chgItem.FieldValues.ContainsKey("Amount")) { chgItem.Update(); cc.ExecuteQuery(); } else { EventLog.WriteEntry(evtLogSrc, "Cannot calculate amount for consumption item " + consumptionLI["ID"], EventLogEntryType.Error); } if (!isCycleOpen) { if (!consumptionLI.HasUniqueRoleAssignments) { consumptionLI.BreakRoleInheritance(true, false); cc.ExecuteQuery(); } cc.Load(consumptionLI.RoleAssignments, items => items.Include( ra => ra.RoleDefinitionBindings.Include( rdb => rdb.Name ) )); cc.ExecuteQuery(); foreach (var ra in consumptionLI.RoleAssignments) { bool addRead = false; foreach (var rdbo in ra.RoleDefinitionBindings) { if (rdbo.Name == "Contribute") { ra.RoleDefinitionBindings.Remove(rdbo); addRead = true; } } if (addRead) { ra.RoleDefinitionBindings.Add(readRD); } ra.Update(); } cc.ExecuteQuery(); } } var chargesLst = cc.Web.Lists.GetByTitle("Charges"); var chargesLIC = chargesLst.GetItems(query); cc.Load(chargesLIC, items => items.Include( item => item["Account"] , item => item["HasUniqueRoleAssignments"] )); cc.ExecuteQuery(); foreach (var chargeLI in chargesLIC) { if (!chargeLI.HasUniqueRoleAssignments) { chargeLI.BreakRoleInheritance(true, false); } foreach (var g in gc) { if (g.LoginName == (groupPrefix + chargeLI["Account"].ToString())) { var rdb = new RoleDefinitionBindingCollection(cc); rdb.Add(restReadRD); chargeLI.RoleAssignments.Add(g, rdb); break; } } cc.ExecuteQuery(); } var runEndTime = DateTime.Now; EventLog.WriteEntry(evtLogSrc, string.Format("Run ended {0}, lasting {1} minutes.", runEndTime.ToString(), (runEndTime - runStartTime).TotalMinutes.ToString("0.00")), EventLogEntryType.Information); System.IO.File.Delete(lastRunFileName); System.IO.File.WriteAllLines(lastRunFileName, new string[] { billingCycleStart.ToShortDateString(), runStartTime.ToString() }); } catch (Exception ex) { EventLog.WriteEntry(evtLogSrc, string.Format("{0}\n", ex.ToString()), EventLogEntryType.Error); throw; } }
public static bool IsJoin(this ITimeRange value1, ITimeRange value) { return !value.Join(value1).IsEmpty(); }
public static TimeSpan GetDuration(this Verbrauch v) { ITimeRange tr = v.GetTimeRange(); return(tr.Duration); }
public override ITimePeriod GetTimePeriod(DateTime baseDate) { var date = baseDate.Date; var time = baseDate.TimeOfDay; var namedEntity = string.Empty; ITimeRange result = null; var lowerText = Text.ToLower(); if (lowerText == "today") { result = new Day(date); } else if (lowerText == "tonight") { result = GetTimeOfDayPeriod(TimeOfDay.Night, date); } else if (lowerText == "last night") { result = GetTimeOfDayPeriod(TimeOfDay.Night, date.AddDays(-1)); } else if (lowerText.StartsWith("yesterday")) { if (lowerText == "yesterday") { result = new Day(date.AddDays(-1)); } else if (lowerText == "yesterday morning") { result = GetTimeOfDayPeriod(TimeOfDay.Morning, date.AddDays(-1)); } else if (lowerText == "yesterday afternoon") { result = GetTimeOfDayPeriod(TimeOfDay.Afternoon, date.AddDays(-1)); } } else if (lowerText.StartsWith("tomorrow")) { if (lowerText == "tomorrow") { result = new Day(date.AddDays(1)); } else if (lowerText == "tomorrow morning") { result = GetTimeOfDayPeriod(TimeOfDay.Morning, date.AddDays(1)); } else if (lowerText == "tomorrow afternoon") { result = GetTimeOfDayPeriod(TimeOfDay.Afternoon, date.AddDays(1)); } else if (lowerText == "tomorrow night") { result = GetTimeOfDayPeriod(TimeOfDay.Night, date.AddDays(1)); } } else if (lowerText.StartsWith("next ") || lowerText.StartsWith("last ") || lowerText.StartsWith("this")) { var pieces = lowerText.Split(' '); if (pieces.Length == 2) { var inPast = pieces[0] == "last"; var inFuture = pieces[0] == "next"; namedEntity = pieces[1]; if (namedEntity == "week") { result = new Week(date); if (inPast) { result = (result as Week).GetPreviousWeek(); } else if (inFuture) { result = (result as Week).GetNextWeek(); } } else if (namedEntity == "month") { result = new Month(date); if (inPast) { result = (result as Month).GetPreviousMonth(); } else if (inFuture) { result = (result as Month).GetNextMonth(); } } else if (namedEntity == "year") { result = new Year(date); if (inPast) { result = (result as Year).GetPreviousYear(); } else if (inFuture) { result = (result as Year).GetNextYear(); } } } } else if (NamedDate.IsMatch(Text)) { namedEntity = NamedDate.Match(Text).Value; } //Handle named entities (eg. "Wednesday" or "January") if (!string.IsNullOrEmpty(namedEntity)) { var inPast = lowerText.StartsWith("last "); //TODO: Support "this" named entity (eg. "this March" is the March in the baseDate year) if (DateComponent.GetWeekDayFromName(namedEntity) != -1) { var moment = DateComponent.GetNextDateFromWeekDay(namedEntity, date); result = new Day(moment); if (inPast) { result = new Day(moment.AddDays(-7)); } } else if (DateComponent.GetMonthFromName(namedEntity) != -1) { var moment = DateComponent.GetNextDateFromMonth(namedEntity, date); result = new Month(moment); if (inPast) { result = new Month(moment.AddMonths(-12)); } } } return(result); }
/// <summary> /// Gets all submitted answers in a time range. /// </summary> /// <param name="timeRange">The time range for which to retrieve answers.</param> /// <returns></returns> private async Task<IEnumerable<SubmittedAnswer>> GetAnswersAsync(ITimeRange timeRange) { var start = new BsonDateTime(timeRange.Start); var end = new BsonDateTime(timeRange.End); return await _repository.Find(a => a.SubmitDateTime > start && a.SubmitDateTime < end); }
/// <summary> /// Gets amount of answers in a given time range. /// </summary> /// <param name="timeRange"></param> /// <returns></returns> public async Task<int> GetAmountOfAnswersAsync(ITimeRange timeRange) { var answers = await GetAnswersAsync(timeRange); return answers.Count(); }
public void OnAvailableRangeChanged(ITimeRange availableRange) { if (_infoListener != null) { _infoListener.OnAvailableRangeChanged(availableRange); } }
public static DateTimeOffset GetCenterTime(this ITimeRange item) { return(item.Timestamp.AddTicks(item.TimeRange.Ticks / 2)); }
public static bool OverlapsWith(this Verbrauch v1, ITimeRange tr2) { return(new TimeRange(v1.Startdatum, v1.Enddatum).OverlapsWith(tr2)); }
/// <summary> /// Returns a <see cref="PlausibilityReport"/> that compares <paramref name="emReference"/> with <paramref name="emOther"/>. /// within the interval defined in <paramref name="timeframe"/>. /// </summary> /// <param name="emReference">reference Energiemenge (reference = used for normalisation)</param> /// <param name="emOther">other Energiemenge</param> /// <param name="timeframe">time frame to be analysed. If null, the overlap of <paramref name="emReference"/> and <paramref name="emOther"/> is used.</param> /// <param name="ignoreLocation">By default (false) an ArgumentException is thrown if the <see cref="BO4E.BO.Energiemenge.LokationsId"/> do not match. Setting this flag suppresses the error.</param> /// <returns>a <see cref="PlausibilityReport"/></returns> public static PlausibilityReport GetPlausibilityReport(this BO4E.BO.Energiemenge emReference, BO4E.BO.Energiemenge emOther, ITimeRange timeframe = null, bool ignoreLocation = false) { using (MiniProfiler.Current.Step(nameof(GetPlausibilityReport))) { TimeRange trReference = emReference.GetTimeRange(); TimeRange trOther = emOther.GetTimeRange(); if (timeframe == null) { ITimeRange overlap = trReference.GetIntersection(trOther); if (!ignoreLocation) { if (!(emReference.LokationsId == emOther.LokationsId && emReference.LokationsTyp == emOther.LokationsTyp)) { throw new ArgumentException($"locations do not match! '{emReference.LokationsId}' ({emReference.LokationsTyp}) != '{emOther.LokationsId}' ({emOther.LokationsTyp})"); } } timeframe = overlap; } Tuple <decimal, Mengeneinheit> consumptionReference; Tuple <decimal, Mengeneinheit> consumptionOtherRaw; using (MiniProfiler.Current.Step("Get Consumptions for overlap:")) { consumptionReference = emReference.GetConsumption(timeframe); consumptionOtherRaw = emOther.GetConsumption(timeframe); } Tuple <decimal, Mengeneinheit> consumptionOther; if (consumptionReference.Item2 != consumptionOtherRaw.Item2) { // unit mismatch if (consumptionReference.Item2.IsConvertibleTo(consumptionOtherRaw.Item2)) { consumptionOther = new Tuple <decimal, Mengeneinheit>(consumptionOtherRaw.Item1 * consumptionOtherRaw.Item2.GetConversionFactor(consumptionReference.Item2), consumptionReference.Item2); } else { throw new ArgumentException($"The unit {consumptionOtherRaw.Item2} is not comparable to {consumptionReference.Item2}!"); } } else { consumptionOther = consumptionOtherRaw; } decimal absoluteDeviation = consumptionOther.Item1 - consumptionReference.Item1; decimal?relativeDeviation; try { relativeDeviation = absoluteDeviation / consumptionReference.Item1; } catch (DivideByZeroException) { relativeDeviation = null; } Verbrauch vReference = emReference.Energieverbrauch.FirstOrDefault(); // copies obiskennzahl, wertermittlungsverfahren... vReference.Wert = consumptionReference.Item1; vReference.Einheit = consumptionReference.Item2; vReference.Startdatum = timeframe.Start; vReference.Enddatum = timeframe.End; Verbrauch vOther = emOther.Energieverbrauch.FirstOrDefault(); // copies obiskennzahl, wertermittlungsverfahren... vOther.Wert = consumptionOther.Item1; vOther.Einheit = consumptionOther.Item2; vOther.Startdatum = timeframe.Start; vOther.Enddatum = timeframe.End; var pr = new PlausibilityReport() { LokationsId = emReference.LokationsId, ReferenceTimeFrame = new BO4E.COM.Zeitraum() { Startdatum = timeframe.Start, Enddatum = timeframe.End }, VerbrauchReference = vReference, VerbrauchOther = vOther, AbsoluteDeviation = Math.Abs(absoluteDeviation), AbsoluteDeviationEinheit = consumptionReference.Item2 }; if (relativeDeviation.HasValue) { pr.RelativeDeviation = Math.Round(relativeDeviation.Value, 4); } else { pr.RelativeDeviation = null; } return(pr); } }
public void OnAvailableRangeChanged(ITimeRange availableRange) { _availableRangeValuesUs = availableRange.GetCurrentBoundsUs(_availableRangeValuesUs); Log.Debug(Tag, "availableRange [" + availableRange.IsStatic + ", " + _availableRangeValuesUs[0] + ", " + _availableRangeValuesUs[1] + "]"); }
/// <summary> /// Gets the most studied objectives based on amount of answers. /// </summary> /// <param name="timeRange"></param> /// <returns>Top three studied objectives</returns> public async Task<IEnumerable<LearningObjective>> GetTopObjectivesAsync(ITimeRange timeRange) { const int amount = 3; var answers = await GetAnswersAsync(timeRange); return answers.GroupBy(a => a.LearningObjective) .OrderByDescending(l => l.Count()) .Select(l => new LearningObjective { Name = l.Key }) .Take(amount); }
/// <summary> /// Most difficulty is calculated by which learning objective had the lowest shared difficulty level. /// </summary> /// <remarks> /// Assumptions are that: /// 1.) Difficulty is relative over all domains. /// 2.) Difficulty is properly calibrated /// /// Note: unfortunately but logically this seems to return the easiest learning goal studied. /// </remarks> /// <param name="timeRange"></param> /// <returns></returns> public async Task<LearningObjective> GetMostDifficultAsync(ITimeRange timeRange) { var answers = await GetAnswersAsync(timeRange); double testDouble; var result = answers.GroupBy(answer => answer.LearningObjective).Select(objectiveAnswers => new { Name = objectiveAnswers.Key, Difficulty = objectiveAnswers.Where(a => double.TryParse(a.Difficulty, out testDouble)) .Average(a => double.Parse(a.Difficulty)) }) .OrderBy(d => d.Difficulty) .FirstOrDefault(); return result == null ? null : new LearningObjective { Name = result.Name }; }
public void OnAvailableRangeChanged(int p0, ITimeRange p1) { // Do nothing. }
public static bool ValidateTimeRange(this ITimeRange range) { return(range.StartTime < range.EndTime); }
public static HashSet <Verbrauch> Merge(this Verbrauch v1, Verbrauch v2, bool redundant, Boolean biased) { HashSet <Verbrauch> result = new HashSet <Verbrauch>(); if (v1.Obiskennzahl == v2.Obiskennzahl && v1.Wertermittlungsverfahren == v2.Wertermittlungsverfahren && v1.Einheit == v2.Einheit) { if (v1.OverlapsWith(v2)) { // don't wanna deal with time running backwards. //Debug.Assert(v1.enddatum >= v1.startdatum); //Debug.Assert(v2.enddatum >= v2.startdatum); TimeRange tr1 = new TimeRange(v1.Startdatum, v1.Enddatum); TimeRange tr2 = new TimeRange(v2.Startdatum, v2.Enddatum); ITimeRange overlap = v1.GetIntersection(v2); if (v1.Einheit.IsExtensive()) { Verbrauch vmerge = new Verbrauch() { Obiskennzahl = v1.Obiskennzahl, Einheit = v1.Einheit, Wertermittlungsverfahren = v1.Wertermittlungsverfahren }; if (redundant) { decimal exclusiveV1Wert = (decimal)(tr1.Duration.TotalSeconds - overlap.Duration.TotalSeconds) * v1.Wert / ((decimal)tr1.Duration.TotalSeconds); decimal exclusiveV2Wert = (decimal)(tr2.Duration.TotalSeconds - overlap.Duration.TotalSeconds) * v2.Wert / ((decimal)tr2.Duration.TotalSeconds); decimal overlapV1Wert = ((decimal)overlap.Duration.TotalSeconds * v1.Wert) / (decimal)(tr1.Duration.TotalSeconds); decimal overlapV2Wert = ((decimal)overlap.Duration.TotalSeconds * v2.Wert) / (decimal)(tr2.Duration.TotalSeconds); if (biased == true) { // biased ==> assume that v2 is contained in v1 vmerge.Startdatum = v1.Startdatum; vmerge.Enddatum = v1.Enddatum; if (exclusiveV1Wert == 0.0M && exclusiveV2Wert == 0.0M && overlapV1Wert == overlapV2Wert) { vmerge.Wert = overlapV1Wert; } else { vmerge.Wert = v1.Wert - overlapV2Wert; // overlapV1Wert; } } else if (biased == false) { vmerge.Startdatum = v1.Startdatum; vmerge.Enddatum = v2.Startdatum; vmerge.Wert = v1.Wert - overlapV2Wert; } else // biased null { vmerge.Startdatum = v1.Startdatum < v2.Startdatum ? v1.Startdatum : v2.Startdatum; vmerge.Enddatum = v1.Enddatum > v2.Enddatum ? v1.Enddatum : v2.Enddatum; if (overlapV1Wert != overlapV2Wert) { throw new ArgumentException("The inequality is unsolvable."); } vmerge.Wert = exclusiveV1Wert + overlapV1Wert + exclusiveV2Wert; } } else { vmerge.Startdatum = v1.Startdatum < v2.Startdatum ? v1.Startdatum : v2.Startdatum; vmerge.Enddatum = v1.Enddatum > v2.Enddatum ? v1.Enddatum : v2.Enddatum; vmerge.Wert = v1.Wert + v2.Wert; } result.Add(vmerge); } else { Verbrauch vmerge1 = new Verbrauch() { Obiskennzahl = v1.Obiskennzahl, Einheit = v1.Einheit, Wertermittlungsverfahren = v1.Wertermittlungsverfahren, Startdatum = v1.Startdatum < v2.Startdatum ? v1.Startdatum : v2.Startdatum, Enddatum = overlap.Start, Wert = v1.Startdatum < v2.Startdatum ? v1.Wert : v2.Wert }; Verbrauch vmerge2 = new Verbrauch() { Obiskennzahl = v1.Obiskennzahl, Einheit = v1.Einheit, Wertermittlungsverfahren = v1.Wertermittlungsverfahren, Startdatum = overlap.Start, Enddatum = overlap.End }; if (redundant) { if (v1.Wert != v2.Wert) { throw new ArgumentException($"Data cannot be redundant if values ({v1.Wert}{v1.Einheit} vs. {v2.Wert}{v2.Einheit}) don't match for interval [{vmerge2.Startdatum}, {vmerge2.Enddatum})."); } vmerge2.Wert = v1.Wert; } else { vmerge2.Wert = v1.Wert + v2.Wert; } Verbrauch vmerge3 = new Verbrauch() { Obiskennzahl = v1.Obiskennzahl, Einheit = v1.Einheit, Wertermittlungsverfahren = v1.Wertermittlungsverfahren, Startdatum = overlap.End, Enddatum = v1.Enddatum > v2.Enddatum ? v1.Enddatum : v2.Enddatum, Wert = v1.Enddatum > v2.Enddatum ? v1.Wert : v2.Wert }; result.Add(vmerge1); result.Add(vmerge2); result.Add(vmerge3); } } else if (v1.Startdatum == v2.Enddatum || v2.Startdatum == v1.Enddatum) { DateTime start = v1.Startdatum < v2.Startdatum ? v1.Startdatum : v2.Startdatum; DateTime stop = v1.Enddatum > v2.Enddatum ? v1.Enddatum : v2.Enddatum; Verbrauch vmerge = new Verbrauch() { Obiskennzahl = v1.Obiskennzahl, Einheit = v1.Einheit, Wertermittlungsverfahren = v1.Wertermittlungsverfahren, Startdatum = start, Enddatum = stop }; if (v1.Einheit.IsExtensive()) { vmerge.Wert = v1.Wert + v2.Wert; result.Add(vmerge); } else if (v1.Wert == v2.Wert) // implicitly intensive { vmerge.Wert = v1.Wert; result.Add(vmerge); } else { // merging intensive verbrauch with different values is not possible. result.Add(v1); result.Add(v2); } } else { // laaaangweilig ;) result.Add(v1); result.Add(v2); } } else { // laaaangweilig ;) result.Add(v1); result.Add(v2); } result.RemoveWhere(v => v.Einheit.IsIntensive() && new TimeRange(v.Startdatum, v.Enddatum).Duration.TotalMilliseconds == 0); return(result); }
/// <summary> /// Calculates total progress by summing the progress of all submitted answers. /// </summary> /// <param name="timeRange"></param> /// <returns></returns> public async Task<int> GetTotalProgressAsync(ITimeRange timeRange) { var answers = await GetAnswersAsync(timeRange); return answers.Sum(a => a.Progress); }
public static ITimeRange GetIntersection(this Verbrauch v1, ITimeRange tr2) { return(new TimeRange(v1.Startdatum, v1.Enddatum).GetIntersection(tr2)); }
/// <summary> /// Generate a <see cref="CompletenessReport"/> for the given refenrence time frame <paramref name="reference"/> /// </summary> /// <param name="em">Energiemenge</param> /// <param name="reference">reference time frame</param> /// <returns></returns> public static CompletenessReport GetCompletenessReport(this BO4E.BO.Energiemenge em, ITimeRange reference) { var combis = em.GetWevObisMeCombinations(); if (combis.Count != 1) { string errorMessage; decimal?coverage; if (combis.Count == 0) { errorMessage = $"Cannot use autoconfigured method because there are no values."; coverage = 0; } else { errorMessage = $"Cannot use autoconfigured method because there are {combis.Count}>1 distinct (wertermittlungsverfahren, obis, einheit) tuple present: {JsonConvert.SerializeObject(combis, new StringEnumConverter())}"; coverage = null; } return(new CompletenessReport() { LokationsId = em.LokationsId, ReferenceTimeFrame = new Zeitraum() { Startdatum = reference.Start, Enddatum = reference.End }, Coverage = coverage, ErrorMessage = errorMessage }); } var combi = combis.First(); return(em.GetCompletenessReport(reference, combi.Item1, combi.Item2, combi.Item3)); }
public static DateTimeOffset GetEndTime(this ITimeRange item) { return(item.Timestamp + item.TimeRange); }
/// <summary> /// Generate a <see cref="CompletenessReport"/> for the given parameters. /// </summary> /// <param name="em">Energiemenge</param> /// <param name="reference">reference time frame</param> /// <param name="wev">Wertermittlungsverfahren</param> /// <param name="obiskennzahl">OBIS Kennzahl</param> /// <param name="einheit">Mengeneinheit</param> /// <returns>the completeness report</returns> public static CompletenessReport GetCompletenessReport(this BO4E.BO.Energiemenge em, ITimeRange reference, Wertermittlungsverfahren wev, string obiskennzahl, Mengeneinheit einheit) { CompletenessReport result; using (MiniProfiler.Current.Step("create completeness report skeleton + find the coverage")) { result = new CompletenessReport { LokationsId = em.LokationsId, Einheit = einheit, Coverage = GetCoverage(em, reference, wev, obiskennzahl, einheit), wertermittlungsverfahren = wev, Obiskennzahl = obiskennzahl, ReferenceTimeFrame = new Zeitraum { Startdatum = DateTime.SpecifyKind(reference.Start, DateTimeKind.Utc), Enddatum = DateTime.SpecifyKind(reference.End, DateTimeKind.Utc) }, }; } if (em.Energieverbrauch != null && em.Energieverbrauch.Count > 0) { /*using (MiniProfiler.Current.Step("populating time slices of/with missing/null values")) * { * result.values = em.GetMissingTimeRanges(reference, wev, obis, einheit) * .Select(mtr => new CompletenessReport.BasicVerbrauch * { * startdatum = DateTime.SpecifyKind(mtr.Start, DateTimeKind.Utc), * enddatum = DateTime.SpecifyKind(mtr.End, DateTimeKind.Utc), * wert = null * }).ToList<CompletenessReport.BasicVerbrauch>(); * } * using (MiniProfiler.Current.Step("populating time slices existing values")) * { * result.values.AddRange( * em.energieverbrauch * //.AsParallel<Verbrauch>() * .Where(v => v.obiskennzahl == obis && v.einheit == einheit && v.wertermittlungsverfahren == wev) * .Select(v => new CompletenessReport.BasicVerbrauch * { * startdatum = DateTime.SpecifyKind(v.startdatum, DateTimeKind.Utc), * enddatum = DateTime.SpecifyKind(v.enddatum, DateTimeKind.Utc), * wert = v.wert * }) * .ToList<CompletenessReport.BasicVerbrauch>()); * }*/ using (MiniProfiler.Current.Step("Setting aggregated gaps")) { var nonNullValues = new TimePeriodCollection(em.Energieverbrauch.Select(v => new TimeRange(v.Startdatum, v.Enddatum))); ITimeRange limits; if (result.ReferenceTimeFrame != null && result.ReferenceTimeFrame.Startdatum.HasValue && result.ReferenceTimeFrame.Enddatum.HasValue) { limits = new TimeRange(result.ReferenceTimeFrame.Startdatum.Value, result.ReferenceTimeFrame.Enddatum.Value); } else { limits = null; } var gaps = (new TimeGapCalculator <TimeRange>()).GetGaps(nonNullValues, limits: limits); result.Gaps = gaps.Select(gap => new CompletenessReport.BasicVerbrauch() { Startdatum = gap.Start, Enddatum = gap.End, Wert = null }).ToList(); } /*using (MiniProfiler.Current.Step("sorting result")) * { * result.values.Sort(new BasicVerbrauchDateTimeComparer()); * }*/ if (em.IsPure(checkUserProperties: true)) { try { foreach (var kvp in em.Energieverbrauch.Where(v => v.UserProperties != null).SelectMany(v => v.UserProperties)) { if (result.UserProperties == null) { result.UserProperties = new Dictionary <string, JToken>(); } if (!result.UserProperties.ContainsKey(kvp.Key)) { result.UserProperties.Add(kvp.Key, kvp.Value); } } } catch (InvalidOperationException) { // ok, there's no Verbrauch with user properties. } } } /*else * { * result.coverage = null; * result._errorMessage = "energieverbrauch is empty"; * }*/ return(result); }
public static ITimeRange OffsetBy(this ITimeRange range, TimeSpan offset) { return(Timestamp.Create(range.Timestamp - offset, range.TimeRange)); }
private FProcessingSlot FindProcessingSlot(List <ITimeRange> processingPositions, ITimeRange workingQueueSlot, long jobDuration) { var processingIsPossible = processingPositions.FirstOrDefault(processing => SlotComparerBasic(workingQueueSlot, processing, jobDuration)); if (processingIsPossible == null) { return(null); } var earliestProcessingStart = (new[] { processingIsPossible.Start, workingQueueSlot.Start }).Max(); return(new FProcessingSlot(earliestProcessingStart, earliestProcessingStart + jobDuration)); }
public void OnAvailableRangeChanged(int p0, ITimeRange p1) { // do nothing }
public PossibleProcessingPosition GetSuitableQueueingPositionFromProposals(ProposalForCapabilityProvider proposalForCapabilityProvider, long jobDuration) { var possibleProcessingPosition = new PossibleProcessingPosition(proposalForCapabilityProvider.GetCapabilityProvider); var setupDuration = proposalForCapabilityProvider.GetCapabilityProvider.ResourceSetups.Sum(x => x.SetupTime); var mainResources = proposalForCapabilityProvider.GetResources(usedInSetup: true, usedInProcess: true); var possibleMainQueuingPositions = GetQueueingPositions(proposalForCapabilityProvider, mainResources, jobDuration); var setupResources = proposalForCapabilityProvider.GetResources(usedInSetup: true, usedInProcess: false); var possibleSetupQueuingPositions = GetQueueingPositions(proposalForCapabilityProvider, setupResources, jobDuration); var processingResources = proposalForCapabilityProvider.GetResources(usedInSetup: false, usedInProcess: true); var possibleProcessingQueuingPositions = GetQueueingPositions(proposalForCapabilityProvider, processingResources, jobDuration); // Apporach 1. // 1. Durchlaufe alle MainScopes // S ->S<---->S<--> <--------- // R ->S S|xxx| <------- ---- ------ // W -------> |xxx| <------- ------------ // Reduziere den Möglichen Zeitaum der Main Ressourcen // R1 ---- | |----- ------ // R2 ------| | ------- // E1 ------| |-------------| inf| // Prüfe ob Bearbeitungsressourcen notwendig sind // --> Nein --> Continue // --> JA --> Reduziere den Möglichen Bearbeitungsraum mit Werker // E1 ------| |-------------| inf| // W ----------| |------ ------| inf| // E2 ---------| |------ ------| inf| // prüfe ob setup notwenig ist // --> Nein --> Return // --> Ja --> Passe den notwendigen setup raum an // E1 ------| |-------------| inf| // W ----------| |------ ------| inf| // E2 --------- |xxx|------ ------| inf| // E3 ------| |--------------------| inf| // prüfe auf setup ressourcen. // S -| |---| |--| |---------| // E3 ------| |--------------------| inf| // E4 -------| |--------------------| inf| // Von allen möglichen Setups innerhalb des scopes Nimm das Letzte aus E4. // Minimiere den Zeitraum zwischen SetupEnde und Bearbeitungsstart // Approach 2 // 1. Nimm über alle MainResourcen die kleine ProcessingStartzeit // 2. Prüfe ob ein setup notwenig ist und ermittle alle start und endwerte --> sind bereits da // 3. Wenn Setup notwendig, prüfe ob alle anderen resourcen zu den Setups und Processing Starts frei sind // --> ja Lücke gefunden // --> nein nimm die ProcessingStartzeit und rechne + 1 // goto 2. --> flieg raus aus dem Slot und nimm den nächsten slot, wenn Zeit nicht mehr reicht // goto 1. mit einer größeren Pr foreach (var mainScope in possibleMainQueuingPositions) { ITimeRange setupSlot = null; ITimeRange processingSlot = null; /* * CASE WITH SETUP */ if (mainScope.IsRequieringSetup) { possibleProcessingPosition.RequireSetup = true; long earliestProcessingStart = mainScope.Scope.Start + setupDuration; long earliestSetupStart = mainScope.Scope.Start; setupSlot = new FSetupSlot(earliestSetupStart, earliestProcessingStart); processingSlot = new FProcessingSlot(start: earliestProcessingStart, end: earliestProcessingStart + jobDuration); var mainProcessingSlots = new List <ITimeRange>(); if (setupResources.Count != 0) // Setup RESOURCE Is Required. { // Machine includes Setup time in the Queuing Position if required. var setupIsPossible = possibleSetupQueuingPositions.FirstOrDefault(setup => SlotComparerSetup(mainScope.Scope, setup.Scope, jobDuration, setupDuration)); if (setupIsPossible == null) { continue; } earliestSetupStart = (new[] { setupIsPossible.Scope.Start, mainScope.Scope.Start }).Max(); earliestProcessingStart = earliestSetupStart + setupDuration; setupSlot = new FSetupSlot(start: earliestSetupStart, end: earliestProcessingStart); processingSlot = new FProcessingSlot(start: earliestProcessingStart, end: earliestProcessingStart + jobDuration); /* * CASE 1 ONLY MAIN RESOURCE AND SETUP RESSOURCE // WITH SETUP */ if (processingResources.Count == 0) { mainProcessingSlots = new List <ITimeRange> { setupSlot, processingSlot }; mainResources.ForEach(resourceRef => possibleProcessingPosition.Add(resourceRef, CreateScopeConfirmation(mainProcessingSlots, earliestSetupStart), earliestProcessingStart)); setupResources.ForEach(resourceRef => possibleProcessingPosition.Add(resourceRef, CreateScopeConfirmation(setupSlot, earliestSetupStart))); break; } } /* * CASE 2 ONLY MAIN RESOURCE // WITH SETUP */ if (processingResources.Count == 0) // { mainProcessingSlots = new List <ITimeRange> { setupSlot, processingSlot }; mainResources.ForEach(resourceRef => possibleProcessingPosition.Add(resourceRef, CreateScopeConfirmation(mainProcessingSlots, earliestSetupStart), earliestProcessingStart)); break; } var processingScope = new FScope(start: earliestProcessingStart, end: mainScope.Scope.End); // seek for worker to process operation var processingResourceSlot = FindProcessingSlot(possibleProcessingQueuingPositions.Where(x => x.IsQueueAble) .Select(x => x.Scope).ToList(), processingScope, jobDuration); // set if a new is found if (processingResourceSlot == null) { continue; } processingSlot = new FProcessingSlot(start: processingResourceSlot.Start, end: processingResourceSlot.End); mainProcessingSlots = new List <ITimeRange> { setupSlot, processingSlot }; mainResources.ForEach(x => possibleProcessingPosition.Add(x, CreateScopeConfirmation(mainProcessingSlots, earliestSetupStart))); processingResources.ForEach(x => possibleProcessingPosition.Add(x, CreateScopeConfirmation(processingSlot, earliestSetupStart), processingSlot.Start)); if (setupResources.Count > 0) { setupResources.ForEach(x => possibleProcessingPosition.Add(x, CreateScopeConfirmation(new List <ITimeRange> { setupSlot }, earliestSetupStart))); } break; } else { /* * CASE NoSetup */ ITimeRange mainSlot = null; if (processingResources.Count == 0) { mainSlot = new FProcessingSlot(start: mainScope.Scope.Start, end: mainScope.Scope.Start + jobDuration); mainResources.ForEach(x => possibleProcessingPosition.Add(x, CreateScopeConfirmation(mainSlot, mainSlot.Start), mainSlot.Start)); break; } processingSlot = FindProcessingSlot(possibleProcessingQueuingPositions.Where(x => x.IsQueueAble) .Select(x => x.Scope).ToList(), mainScope.Scope, jobDuration); // set if a new is found if (processingSlot == null) { continue; } mainSlot = new FProcessingSlot(start: processingSlot.Start, end: processingSlot.Start + jobDuration); mainResources.ForEach(x => possibleProcessingPosition.Add(x, CreateScopeConfirmation(mainSlot, mainSlot.Start))); processingResources.ForEach(x => possibleProcessingPosition.Add(x, CreateScopeConfirmation(mainSlot, mainSlot.Start), mainSlot.Start)); break; } } return(possibleProcessingPosition); }