async Task ExecuteLoadPeriodCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
Periods.Clear();
var periods = await DataStoreP.GetPeriodsAsync(true);
foreach (var period in periods)
{
Periods.Add(period);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
finally
{
IsBusy = false;
}
}
public async void LoadGpnAsync()
{
if (string.IsNullOrEmpty(GpnFile))
{
return;
}
try
{
GpnLoadDateTime = null;
IsBusy = true;
Periods.Clear();
BusyText = "Untis Datei laden...";
Result = await UntisExporter.ParseFileAsync(GpnFile);
foreach (var period in Result.Periods)
{
Periods.Add(period);
}
GpnLoadDateTime = DateTime.Now;
}
catch (Exception e)
{
await dialogCoordinator.ShowMessageAsync(this, "Fehler beim Laden der Untis-Datei", e.Message, MessageDialogStyle.Affirmative);
Result = null;
}
finally
{
IsBusy = false;
BusyText = "";
}
}
public override IEnumerable <IPeriod> Evaluate(IDateTime referenceDate, DateTime periodStart, DateTime periodEnd, bool includeReferenceDateInResults)
{
// Create a recurrence pattern suitable for use during evaluation.
IRecurrencePattern pattern = ProcessRecurrencePattern(referenceDate);
// Enforce evaluation restrictions on the pattern.
EnforceEvaluationRestrictions(pattern);
var periods = new HashSet <IPeriod>();
foreach (DateTime dt in GetDates(referenceDate, periodStart, periodEnd, -1, pattern, includeReferenceDateInResults))
{
// Create a period from the date/time.
IPeriod p = CreatePeriod(dt, referenceDate);
if (!periods.Contains(p))
{
periods.Add(p);
}
}
Periods.Clear();
foreach (var period in periods)
{
if (!Periods.Contains(period))
{
Periods.Add(period);
}
}
return(Periods);
}
/// <summary>
/// Evaluates this event to determine the dates and times for which the event occurs.
/// This method only evaluates events which occur between <paramref name="FromDate"/>
/// and <paramref name="ToDate"/>; therefore, if you require a list of events which
/// occur outside of this range, you must specify a <paramref name="FromDate"/> and
/// <paramref name="ToDate"/> which encapsulate the date(s) of interest.
/// <note type="caution">
/// For events with very complex recurrence rules, this method may be a bottleneck
/// during processing time, especially when this method in called for a large number
/// of events, in sequence, or for a very large time span.
/// </note>
/// </summary>
/// <param name="FromDate">The beginning date of the range to evaluate.</param>
/// <param name="ToDate">The end date of the range to evaluate.</param>
/// <returns></returns>
internal override List<Period> Evaluate(iCalDateTime FromDate, iCalDateTime ToDate)
{
// Add the event itself, before recurrence rules are evaluated
// NOTE: this fixes a bug where (if evaluated multiple times)
// a period can be added to the Periods collection multiple times.
Period period = new Period(DTStart, Duration);
// Ensure the period does not already exist in our collection
if (!Periods.Contains(period))
Periods.Add(period);
// Evaluate recurrences normally
base.Evaluate(FromDate, ToDate);
// Ensure each period has a duration
foreach(Period p in Periods)
{
if (p.EndTime == null)
{
p.Duration = Duration;
if (p.Duration != null)
p.EndTime = p.StartTime + Duration;
else p.EndTime = p.StartTime;
}
// Ensure the Kind of time is consistent with DTStart
p.EndTime.IsUniversalTime = DTStart.IsUniversalTime;
}
return Periods;
}
/// <summary>
/// Evaulates the RRule component, and adds each specified Period
/// to the <see cref="Periods"/> collection.
/// </summary>
/// <param name="periodStart">The beginning date of the range to evaluate.</param>
/// <param name="periodEnd">The end date of the range to evaluate.</param>
virtual protected void EvaluateRRule(IDateTime referenceDate, DateTime periodStart, DateTime periodEnd, bool includeReferenceDateInResults)
{
// Handle RRULEs
if (Recurrable.RecurrenceRules != null &&
Recurrable.RecurrenceRules.Count > 0)
{
foreach (IRecurrencePattern rrule in Recurrable.RecurrenceRules)
{
IEvaluator evaluator = rrule.GetService(typeof(IEvaluator)) as IEvaluator;
if (evaluator != null)
{
IList <IPeriod> periods = evaluator.Evaluate(referenceDate, periodStart, periodEnd, includeReferenceDateInResults);
foreach (IPeriod p in periods)
{
if (!Periods.Contains(p))
{
Periods.Add(p);
}
}
}
}
}
else if (includeReferenceDateInResults)
{
// If no RRULEs were found, then we still need to add
// the initial reference date to the results.
IPeriod p = new Period(referenceDate.Copy <IDateTime>());
if (!Periods.Contains(p))
{
Periods.Add(p);
}
}
}
public override IList <IPeriod> Evaluate(IDateTime referenceDate, DateTime periodStart, DateTime periodEnd, bool includeReferenceDateInResults)
{
// Create a recurrence pattern suitable for use during evaluation.
IRecurrencePattern pattern = ProcessRecurrencePattern(referenceDate);
// Enforce evaluation restrictions on the pattern.
EnforceEvaluationRestrictions(pattern);
Periods.Clear();
foreach (DateTime dt in GetDates(referenceDate, periodStart, periodEnd, -1, pattern, includeReferenceDateInResults))
{
// Turn each resulting date/time into an IDateTime and associate it
// with the reference date.
IDateTime newDt = new iCalDateTime(dt, referenceDate.TZID);
// NOTE: fixes bug #2938007 - hasTime missing
newDt.HasTime = referenceDate.HasTime;
newDt.AssociateWith(referenceDate);
// Create a period from the new date/time.
IPeriod p = new Period(newDt);
if (!Periods.Contains(p))
{
Periods.Add(p);
}
}
return(Periods);
}
/// <summary>
/// Gets the next report number for this foundry
/// </summary>
/// <param name="ctx">Context under which to give the report number</param>
/// <returns></returns>
public String getNextReportNumber(RadiographyContext ctx)
{
//period logic - first check whether which is the current period or we need to create a new period
if (NextResetDate < DateTime.Now)
{
//end date the current period, and create a new period
if (CurrentPeriod != null)
{
CurrentPeriod.EndDate = NextResetDate;
}
var newPeriod = new Period
{
StartDate = NextResetDate,
Foundry = this,
FoundryID = ID,
};
Periods.Add(newPeriod);
//set the next reset date to one year hence
NextResetDate = NextResetDate.AddYears(1);
//for ctx to get these changes
ctx.Foundries.AttachAsModified(this, ctx);
ctx.Periods.Add(newPeriod);
ctx.SaveChanges();
}
//fetch immediately from the database, otherwise convert.toint32 will fail
var reports = ctx.RGReports.Where(p => p.ReportNo.StartsWith(this.ReportNumberPrefix) && p.ReportDate > CurrentPeriod.StartDate).ToList();
var lastNumber = !reports.Any() ? 0 : reports.Max(p => Convert.ToInt32(p.ReportNo.Replace(ReportNumberPrefix, "")));
return(String.Concat(ReportNumberPrefix, Convert.ToString(lastNumber + 1)));
}
/// <summary>
/// Evaluates this event to determine the dates and times for which the event occurs.
/// This method only evaluates events which occur between <paramref name="FromDate"/>
/// and <paramref name="ToDate"/>; therefore, if you require a list of events which
/// occur outside of this range, you must specify a <paramref name="FromDate"/> and
/// <paramref name="ToDate"/> which encapsulate the date(s) of interest.
/// <note type="caution">
/// For events with very complex recurrence rules, this method may be a bottleneck
/// during processing time, especially when this method in called for a large number
/// of events, in sequence, or for a very large time span.
/// </summary>
/// <param name="FromDate">The beginning date of the range to evaluate.</param>
/// <param name="ToDate">The end date of the range to evaluate.</param>
/// <returns></returns>
public override List <Period> Evaluate(Date_Time FromDate, Date_Time ToDate)
{
// Add the event itself, before recurrence rules are evaluated
// NOTE: this fixes a bug where (if evaluated multiple times)
// a period can be added to the Periods collection multiple times.
Period period = new Period(DTStart, Duration);
// Ensure the period does not already exist in our collection
if (!Periods.Contains(period))
{
Periods.Add(period);
}
// Evaluate recurrences normally
base.Evaluate(FromDate, ToDate);
// Ensure each period has a duration
foreach (Period p in Periods)
{
if (p.EndTime == null)
{
p.Duration = Duration;
p.EndTime = p.StartTime + Duration;
}
// Ensure the Kind of time is consistent with DTStart
else if (p.EndTime.Kind != DTStart.Kind)
{
p.EndTime.Value = DateTime.SpecifyKind(p.EndTime.Value, DTStart.Kind);;
}
}
return(Periods);
}
/// <summary>
/// Evalates the RDate component, and adds each specified DateTime or
/// Period to the <see cref="Periods"/> collection.
/// </summary>
/// <param name="FromDate">The beginning date of the range to evaluate.</param>
/// <param name="ToDate">The end date of the range to evaluate.</param>
virtual protected void EvaluateRDate(Date_Time FromDate, Date_Time ToDate)
{
// Handle RDATEs
if (RDate != null)
{
foreach (RDate rdate in RDate)
{
ArrayList Items = rdate.Evaluate(DTStart, FromDate, ToDate);
foreach (object obj in Items)
{
Period p = null;
if (obj is Period)
{
p = (Period)obj;
}
else if (obj is Date_Time)
{
p = new Period((Date_Time)obj);
}
if (p != null && !Periods.Contains(p))
{
Periods.Add(p);
}
}
}
}
}
/// <summary>
/// Evaluates this event to determine the dates and times for which the event occurs.
/// This method only evaluates events which occur between <paramref name="FromDate"/>
/// and <paramref name="ToDate"/>; therefore, if you require a list of events which
/// occur outside of this range, you must specify a <paramref name="FromDate"/> and
/// <paramref name="ToDate"/> which encapsulate the date(s) of interest.
/// <note type="caution">
/// For events with very complex recurrence rules, this method may be a bottleneck
/// during processing time, especially when this method in called for a large number
/// of events, in sequence, or for a very large time span.
/// </summary>
/// <param name="FromDate">The beginning date of the range to evaluate.</param>
/// <param name="ToDate">The end date of the range to evaluate.</param>
/// <returns></returns>
public override List <Period> Evaluate(Date_Time FromDate, Date_Time ToDate)
{
// Add the event itself, before recurrence rules are evaluated
// NOTE: this fixes a bug where (if evaluated multiple times)
// a period can be added to the Periods collection multiple times.
Period period = new Period(DTStart, Duration);
if (!Periods.Contains(period))
{
Periods.Add(period);
}
// Evaluate recurrences normally
base.Evaluate(FromDate, ToDate);
// Ensure each period has a duration
foreach (Period p in Periods)
{
if (p.EndTime == null)
{
p.Duration = Duration;
p.EndTime = p.StartTime + Duration;
}
}
return(Periods);
}
/// <summary>
/// Evaluates this event to determine the dates and times for which the event occurs.
/// This method only evaluates events which occur between <paramref name="FromDate"/>
/// and <paramref name="ToDate"/>; therefore, if you require a list of events which
/// occur outside of this range, you must specify a <paramref name="FromDate"/> and
/// <paramref name="ToDate"/> which encapsulate the date(s) of interest.
/// <note type="caution">
/// For events with very complex recurrence rules, this method may be a bottleneck
/// during processing time, especially when this method in called for a large number
/// of events, in sequence, or for a very large time span.
/// </summary>
/// <param name="FromDate">The beginning date of the range to evaluate.</param>
/// <param name="ToDate">The end date of the range to evaluate.</param>
/// <returns></returns>
public override ArrayList Evaluate(Date_Time FromDate, Date_Time ToDate)
{
// Add the event itself, before recurrence rules are evaluated
DateTimes.Add(DTStart.Copy());
Periods.Add(new Period(DTStart, Duration));
// Evaluate recurrences normally
base.Evaluate(FromDate, ToDate);
// Remove DateTimes that already have a Period
for (int i = DateTimes.Count - 1; i >= 0; i--)
{
foreach (Period p in Periods)
{
if (p.StartTime == DateTimes[i])
{
DateTimes.RemoveAt(i);
}
}
}
// Convert each calculated Date_Time into a Period.
foreach (Date_Time dt in DateTimes)
{
Period p = new Period(dt, Duration);
if (!Periods.Contains(p))
{
Periods.Add(p);
}
}
Periods.Sort();
return(Periods);
}
private async Task LoadDate(IOutcomeReportServiceProvider provider)
{
if (IsBusy)
{
return;
}
IsBusy = true;
using (var service = provider.GetService())
{
var response = await service.GetAllPeriodsAsync(new ApplicationService.GetAllPeriodsRequest());
if (ReferenceEquals(response.Exception, null))
{
foreach (var vm in response.PeriodViewModels)
{
Periods.Add(vm);
}
}
else
{
System.Diagnostics.Debug.WriteLine(response.Exception);
}
}
IsBusy = false;
}
public PeriodListVM()
{
PeriodMgtAppLocalizedResources = new PeriodMgtAppLocalizedResources();
init();
Periods.Add(new PeriodDTOWithAction {
Id = 4, Name = "Test"
});
}
private void AddPeriodCmd()
{
var newPeriod = new Period();
MainContext.AddEntity(newPeriod);
Periods.Add(newPeriod);
SelectedPeriod = newPeriod;
}
private void Initialize()
{
Periods.Clear();
foreach (QuotePeriod period in Enum.GetValues(typeof(QuotePeriod)))
{
Periods.Add(CalculateChartData(period));
}
}
/// <summary>
/// Add period to search criteria.
/// </summary>
/// <param name="period">The period.</param>
public void Add(IPeriod period)
{
if (Periods.IsNull())
{
Periods = new PeriodList();
}
Periods.Add(period);
}
private void Periods_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
Periods.Clear();
foreach (PeriodViewModel period in MainViewModel.Instance.Parameters.Periods)
{
Periods.Add(period);
}
SelectedPeriod = Periods.FirstOrDefault();
}
public override List <Period> Evaluate(Date_Time FromDate, Date_Time ToDate)
{
// Add the event itself, before recurrence rules are evaluated
if (DTStart != null)
{
Periods.Add(new Period(DTStart));
}
return(base.Evaluate(FromDate, ToDate));
}
public MonthlyPeriod GetPeriod(int year, int month)
{
var period = Periods.Where(x => x.FirstDayOfMonth == new DateTime(year, month, 1)).SingleOrDefault();
if (period == null)
{
period = new MonthlyPeriod(year, month, this);
Periods.Add(period);
}
return(period);
}
public override List <Period> Evaluate(Date_Time FromDate, Date_Time ToDate)
{
// Add the todo itself, before recurrence rules are evaluated
Period startPeriod = new Period(DTStart);
if (DTStart != null &&
!Periods.Contains(startPeriod))
{
Periods.Add(startPeriod);
}
return(base.Evaluate(FromDate, ToDate));
}
public HoldingPeriodReturn(IEnumerable <Tuple <DateTime, DateTime> > periods, IEnumerable <Tuple <decimal, DateTime> > incomes)
{
foreach (var period in periods)
{
var addedPeriod = ReturnCalculationPeriod.Build(period.Item1, period.Item2, Id);
Periods.Add(addedPeriod);
}
foreach (var income in incomes)
{
var addedIncome = ReturnIncome.Build(income.Item1, income.Item2, Id);
Incomes.Add(addedIncome);
}
}
public async void Get()
{
var jData = await DataService.Get("VaccinePeriods");
if (jData == "ConnectionError")
{
StandardMessagesDisplay.NoConnectionToast();
}
else if (jData == "null")
{
StandardMessagesDisplay.NoDataDisplayMessage();
}
else if (jData == "Error")
{
StandardMessagesDisplay.Error();
}
else if (jData == "ErrorTracked")
{
StandardMessagesDisplay.ErrorTracked();
}
else
{
try
{
var data = JsonConvert.DeserializeObject <Dictionary <string, PeriodModel> >(jData);
if (data != null)
{
foreach (KeyValuePair <string, PeriodModel> item in data)
{
Periods?.Add(
new PeriodModel
{
FId = item.Key.ToString(),
Id = item.Value.Id,
StartDate = item.Value.StartDate,
EndDate = item.Value.EndDate,
PeriodName = item.Value.PeriodName
}
);
}
}
}
catch (Exception ex)
{
Crashes.TrackError(ex);
StandardMessagesDisplay.InputToast(ex.Message);
}
}
}
public void StartPeriod()
{
string periodName;
if (!ReadyToCapture)
{
return;
}
if (currentPeriod != null)
{
string msg = Catalog.GetString("Period recording already started");
App.Current.Dialogs.WarningMessage(msg, this);
return;
}
recbutton.Visible = false;
pausebutton.Visible = savebutton.Visible = stopbutton.Visible = true;
if (PeriodsNames != null && PeriodsNames.Count > Periods.Count)
{
periodName = PeriodsNames [Periods.Count];
}
else
{
periodName = (Periods.Count + 1).ToString();
}
currentPeriod = new Period {
Name = periodName
};
currentTimeNode = currentPeriod.Start(accumTime, periodName);
currentTimeNode.Stop = currentTimeNode.Start;
currentPeriodStart = DateTime.UtcNow;
timeoutID = GLib.Timeout.Add(20, UpdateTime);
if (Capturer != null)
{
if (Periods.Count == 0)
{
Capturer.Start();
}
else
{
Capturer.TogglePause();
}
}
periodlabel.Markup = currentPeriod.Name;
Capturing = true;
Periods.Add(currentPeriod);
Log.Debug("Start new period start=", currentTimeNode.Start.ToMSecondsString());
}
public override System.Collections.Generic.List <Period> Evaluate(iCalDateTime FromDate, iCalDateTime ToDate)
{
if (Start != null)
{
Period p = new Period(Start);
if (!Periods.Contains(p))
{
Periods.Add(p);
}
return(base.Evaluate(FromDate, ToDate));
}
return(new System.Collections.Generic.List <Period>());
}
/// <summary>
///
/// </summary>
/// <param name="periods"></param>
/// <param name="incomes"></param>
public HoldingPeriodReturn(IEnumerable <Tuple <DateTime, DateTime> > periods, IEnumerable <Tuple <decimal, DateTime> > incomes)
{
foreach (var period in periods)
{
Periods.Add(new ReturnCalculationPeriod {
DateFrom = period.Item1, DateTo = period.Item2, ReturnId = this.Id
});
}
foreach (var income in incomes)
{
Incomes.Add(new ReturnIncome {
Amount = income.Item1, Timestamp = income.Item2, ReturnId = this.Id
});
}
}
virtual public IPeriod GetNext(IDateTime referenceDate)
{
DateTime?dt = GetNextDate(referenceDate, referenceDate.Value, Pattern);
if (dt != null)
{
// Create a period from the date/time.
IPeriod p = CreatePeriod(dt.Value, referenceDate);
if (!Periods.Contains(p))
{
Periods.Add(p);
}
}
return(null);
}
public ValidityPeriod GetOrAddPeriod(int sequence)
{
var period = Periods.FirstOrDefault(p => p.Sequence == sequence);
if (period == null)
{
period = new ValidityPeriod
{
Sequence = sequence
};
Periods.Add(period);
}
return(period);
}
public override List <Period> Evaluate(Date_Time FromDate, Date_Time ToDate)
{
// TODO items can only recur if a start date is specified
if (DTStart != null)
{
// Add the todo itself, before recurrence rules are evaluated
Period startPeriod = new Period(DTStart);
if (DTStart != null &&
!Periods.Contains(startPeriod))
{
Periods.Add(startPeriod);
}
return(base.Evaluate(FromDate, ToDate));
}
return(new List <Period>());
}
public Period PostPeriod(Period period)
{
period.AccountId = Session.DefaultAccount.AccountId;
var item = Periods.FirstOrDefault(c => c.PeriodId == period.PeriodId);
if (item != null)
{
item = period;
return(item);
}
else
{
period.PeriodId = GeneratePeriodId();
Periods.Add(period);
return(period);
}
}
public Game(GameListItem item)
{
Id = item.Id;
DateStart = item.Date;
DateUpdate = item.UpdD;
Country = new Country {
Id = item.CntI, Title = item.CntN
};
League = new League {
Id = item.LeaI, Title = item.LeaN
};
Season = new Season {
Id = item.SeaI, Title = item.SeaN
};
Stage = new Stage {
Id = item.StgI, Title = item.StgN
};
Status = item.Stat;
TeamHome = new Team {
Id = item.THId, Title = item.THNm
};
TeamAway = new Team {
Id = item.TAId, Title = item.TANm
};
Periods.Add(new Score {
Away = item.Sc1A, Home = item.Sc1H, Id = 1, Name = "P1"
});
Periods.Add(new Score {
Away = item.Sc2A, Home = item.Sc2H, Id = 2, Name = "P2"
});
Periods.Add(new Score {
Away = item.Sc3A, Home = item.Sc3H, Id = 3, Name = "P3"
});
Periods.Add(new Score {
Away = item.Sc4A, Home = item.Sc4H, Id = 4, Name = "P4"
});
Periods.Add(new Score {
Away = item.ScOA, Home = item.ScOH, Id = 5, Name = "OT"
});
var total = new Score {
Away = item.ScTA, Home = item.ScTH, Id = 6, Name = "TT"
};
Periods.Add(total);
Total = total;
}