public RepeatsPickerPage()
: base("RepeatsPicker")
{
InitializeComponent();
DataContext = this;
Repeats repeats = NavigationParameter <Repeats>(_name, DefaultRepeats);
switch (repeats)
{
case Repeats.Monthly:
MonthlyRadioButton.IsChecked = true;
break;
case Repeats.Weekly:
WeeklyRadioButton.IsChecked = true;
break;
case Repeats.Daily:
DailyRadioButton.IsChecked = true;
break;
case Repeats.None:
OnceRadioButton.IsChecked = true;
break;
default: // DaysOfWeek
DaysOfWeekRadioButton.IsChecked = true;
UpdateButtons(repeats);
break;
}
}
private static List <DayOfWeek> DaysOfWeek(this Repeats repeats)
{
List <DayOfWeek> daysOfWeek = new List <DayOfWeek>();
if ((repeats & Repeats.Monday) != 0)
{
daysOfWeek.Add(DayOfWeek.Monday);
}
if ((repeats & Repeats.Tuesday) != 0)
{
daysOfWeek.Add(DayOfWeek.Tuesday);
}
if ((repeats & Repeats.Wednesday) != 0)
{
daysOfWeek.Add(DayOfWeek.Wednesday);
}
if ((repeats & Repeats.Thursday) != 0)
{
daysOfWeek.Add(DayOfWeek.Thursday);
}
if ((repeats & Repeats.Friday) != 0)
{
daysOfWeek.Add(DayOfWeek.Friday);
}
if ((repeats & Repeats.Saturday) != 0)
{
daysOfWeek.Add(DayOfWeek.Saturday);
}
if ((repeats & Repeats.Sunday) != 0)
{
daysOfWeek.Add(DayOfWeek.Sunday);
}
return(daysOfWeek);
}
public ActionResult <Repeats> Get()
{
var repeats = new Repeats();
repeats.Num.AddRange(new List <int> {
5, 4, 3, 2, 1
});
return(repeats);
}
private void UpdateButtons(Repeats repeats)
{
SetDayOfWeek(DayOfWeek.Monday, (repeats & Repeats.Monday) != 0);
SetDayOfWeek(DayOfWeek.Tuesday, (repeats & Repeats.Tuesday) != 0);
SetDayOfWeek(DayOfWeek.Wednesday, (repeats & Repeats.Wednesday) != 0);
SetDayOfWeek(DayOfWeek.Thursday, (repeats & Repeats.Thursday) != 0);
SetDayOfWeek(DayOfWeek.Friday, (repeats & Repeats.Friday) != 0);
SetDayOfWeek(DayOfWeek.Saturday, (repeats & Repeats.Saturday) != 0);
SetDayOfWeek(DayOfWeek.Sunday, (repeats & Repeats.Sunday) != 0);
}
protected override object Save()
{
if (DailyRadioButton.IsChecked ?? false)
{
return(Repeats.Daily);
}
else if (DaysOfWeekRadioButton.IsChecked ?? false)
{
Repeats repeats = Repeats.None;
if (IsSetDayOfWeek(DayOfWeek.Monday))
{
repeats |= Repeats.Monday;
}
if (IsSetDayOfWeek(DayOfWeek.Tuesday))
{
repeats |= Repeats.Tuesday;
}
if (IsSetDayOfWeek(DayOfWeek.Wednesday))
{
repeats |= Repeats.Wednesday;
}
if (IsSetDayOfWeek(DayOfWeek.Thursday))
{
repeats |= Repeats.Thursday;
}
if (IsSetDayOfWeek(DayOfWeek.Friday))
{
repeats |= Repeats.Friday;
}
if (IsSetDayOfWeek(DayOfWeek.Saturday))
{
repeats |= Repeats.Saturday;
}
if (IsSetDayOfWeek(DayOfWeek.Sunday))
{
repeats |= Repeats.Sunday;
}
return(repeats);
}
else if (WeeklyRadioButton.IsChecked ?? false)
{
return(Repeats.Weekly);
}
else if (MonthlyRadioButton.IsChecked ?? false)
{
return(Repeats.Monthly);
}
return(Repeats.None);
}
public static RecurrenceInterval Interval(this Repeats repeats)
{
switch (repeats)
{
case Repeats.Monthly: return(RecurrenceInterval.Monthly);
case Repeats.Weekly: return(RecurrenceInterval.Weekly);
case Repeats.Daily: return(RecurrenceInterval.Daily);
case Repeats.None: return(RecurrenceInterval.None);
default /* DaysOfWeek */: return(RecurrenceInterval.Weekly);
}
}
public override String ToString()
{
var builder = new StringBuilder();
builder.Append("Model: "); builder.AppendLine(ModelFileName);
builder.Append("Solver: "); builder.AppendLine(SolverName);
builder.Append("Config: "); builder.AppendLine(ConfigFileName);
// ReSharper disable SpecifyACultureInStringConversionExplicitly
builder.Append("Duration: "); builder.AppendLine(Duration.ToString());
builder.Append("Samples: "); builder.AppendLine(Samples.ToString());
builder.Append("Runs: "); builder.AppendLine(Repeats.ToString());
// ReSharper restore SpecifyACultureInStringConversionExplicitly
builder.Append("Working Directory: "); builder.AppendLine(WorkingDirectory);
return(builder.ToString());
}
public List <DateTime> ReminderDates()
{
List <DateTime> dates;
if (HasReminder)
{
dates = Repeats.Dates(DueDate.Value, IsCompleted);
for (int i = 0; i < dates.Count; i++)
{
dates[i] = dates[i] - Reminder.Value;
}
}
else
{
dates = new List <DateTime>();
}
return(dates);
}
public static List <DateTime> Dates(this Repeats repeats, DateTime startDate, bool skipFirst = false)
{
List <DateTime> dates = new List <DateTime>();
switch (repeats)
{
case Repeats.Monthly:
dates.Add(skipFirst ? startDate.AddMonths(1) : startDate);
return(dates);
case Repeats.Weekly:
dates.Add(skipFirst ? startDate.AddDays(_daysInWeek) : startDate);
return(dates);
case Repeats.Daily:
dates.Add(skipFirst ? startDate.AddDays(1) : startDate);
return(dates);
case Repeats.None:
if (!skipFirst)
{
dates.Add(startDate);
}
return(dates);
default /* DaysOfWeek */:
List <DayOfWeek> list = repeats.DaysOfWeek();
for (int i = 0; i < _daysInWeek; i++)
{
DateTime date = startDate.AddDays(i);
if (list.Contains(date.DayOfWeek))
{
dates.Add(date);
}
}
if (skipFirst && dates.Count > 0)
{
dates[0] = dates[0].AddDays(_daysInWeek);
}
return(dates);
}
}
public static DateTime ActualDate(this Repeats repeats, DateTime startDate)
{
switch (repeats)
{
case Repeats.Monthly:
while (startDate.Date < DateTime.Today)
{
startDate = startDate.AddMonths(1);
}
return(startDate);
case Repeats.Weekly:
while (startDate.Date < DateTime.Today)
{
startDate = startDate.AddDays(_daysInWeek);
}
return(startDate);
case Repeats.Daily:
return(DateTime.Today.SetTime(startDate));
case Repeats.None:
return(startDate);
default /* DaysOfWeek */:
if (startDate.Date < DateTime.Today)
{
startDate = DateTime.Today.SetTime(startDate);
}
List <DayOfWeek> list = repeats.DaysOfWeek();
for (int i = 0; i < _daysInWeek; i++)
{
DateTime date = startDate.AddDays(i);
if (list.Contains(date.DayOfWeek))
{
return(date);
}
}
return(startDate);
}
}
protected override byte[] GetSaveData()
{
StringBuilder Result = new StringBuilder();
Result.AppendLine(Delay.ToString());
Result.AppendLine(Repeats.ToString());
Result.AppendLine(Proxy?.ToString() ?? "");
Result.AppendLine(OutputFilePath);
Result.AppendLine(OutputFormat);
Result.AppendLine(Filter);
Result.AppendLine(Format);
Result.AppendLine(Threads.ToString());
Result.AppendLine(MoreSettings.Count.ToString());
foreach (var v in MoreSettings)
{
Result.AppendLine(string.Format("{0}|{1}", v.Key, v.Value));
}
Result.AppendLine(URLs.Count.ToString());
foreach (var v in URLs)
{
Result.AppendLine(v);
}
return(Encoding.UTF8.GetBytes(Result.ToString()));
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
if (value is Repeats)
{
Repeats repeats = (Repeats)value;
if (repeats == Repeats.Monthly)
{
return(AppResources.RepeatsMonthly);
}
else if (repeats == Repeats.Weekly)
{
return(AppResources.RepeatsWeekly);
}
else if (repeats == Repeats.Weekends)
{
return(AppResources.RepeatsWeekends);
}
else if (repeats == Repeats.Weekdays)
{
return(AppResources.RepeatsWeekdays);
}
else if (repeats == Repeats.Daily)
{
return(AppResources.RepeatsDaily);
}
else
{
string[] dayNames = CultureInfo.CurrentCulture.DateTimeFormat.DayNames;
switch (repeats)
{
case Repeats.Monday: return(dayNames[(int)DayOfWeek.Monday]);
case Repeats.Tuesday: return(dayNames[(int)DayOfWeek.Tuesday]);
case Repeats.Wednesday: return(dayNames[(int)DayOfWeek.Wednesday]);
case Repeats.Thursday: return(dayNames[(int)DayOfWeek.Thursday]);
case Repeats.Friday: return(dayNames[(int)DayOfWeek.Friday]);
case Repeats.Saturday: return(dayNames[(int)DayOfWeek.Saturday]);
case Repeats.Sunday: return(dayNames[(int)DayOfWeek.Sunday]);
}
dayNames = CultureInfo.CurrentCulture.DateTimeFormat.ShortestDayNames;
List <string> list = new List <string>();
if ((repeats & Repeats.Weekdays) == Repeats.Weekdays)
{
list.Add(AppResources.RepeatsWeekdays);
}
else
{
if ((repeats & Repeats.Monday) != 0)
{
list.Add(dayNames[(int)DayOfWeek.Monday]);
}
if ((repeats & Repeats.Tuesday) != 0)
{
list.Add(dayNames[(int)DayOfWeek.Tuesday]);
}
if ((repeats & Repeats.Wednesday) != 0)
{
list.Add(dayNames[(int)DayOfWeek.Wednesday]);
}
if ((repeats & Repeats.Thursday) != 0)
{
list.Add(dayNames[(int)DayOfWeek.Thursday]);
}
if ((repeats & Repeats.Friday) != 0)
{
list.Add(dayNames[(int)DayOfWeek.Friday]);
}
}
if ((repeats & Repeats.Weekends) == Repeats.Weekends)
{
list.Add(AppResources.RepeatsWeekends);
}
else
{
if ((repeats & Repeats.Saturday) != 0)
{
list.Add(dayNames[(int)DayOfWeek.Saturday]);
}
if ((repeats & Repeats.Sunday) != 0)
{
list.Add(dayNames[(int)DayOfWeek.Sunday]);
}
}
if (list.Count > 0)
{
return(string.Join(", ", list));
}
}
}
return(AppResources.RepeatsOnce);
}
/// <summary>
/// Gets called by the logic of the <see cref="CommandAttribute" />.
/// </summary>
private async Task <int> OnExecuteAsync()
{
if (UseIpV6)
{
UseIpV4 = false;
}
if (Endless)
{
Repeats = int.MaxValue;
}
Console.WriteLine($"Starting pinging host {Host} on {ResolvedProtocol} port(s) {PortRange} {(Endless ? "infinite" : Repeats.ToString())} times:");
var reachablePorts = 0;
var closedPorts = 0;
var hostIp = "-";
if (ResvoleAddress)
{
// we have to perform address resolution
var entry = await Dns.GetHostEntryAsync(Host);
if (entry.AddressList.Any())
{
var target = UseIpV4 ? AddressFamily.InterNetwork : AddressFamily.InterNetworkV6;
hostIp = entry.AddressList.FirstOrDefault(he => he.AddressFamily == target)?.ToString() ?? "?";
}
}
// start the process
var currentPack = 0;
for (var i = 0; i < Repeats; ++i)
{
var portOpen = true;
Ports.ToList().ForEach(
port =>
{
try
{
portOpen &= NetworkUtil.IsPortOpened(Host, port, Timeout, UseUdp);
reachablePorts += portOpen ? 1 : 0;
closedPorts += portOpen ? 0 : 1;
var printResult = portOpen ? "OPEN" : "CLOSED";
if (Detailed && !portOpen)
{
printResult += $" ({NetworkUtil.LastCheckResult.ToString()})";
}
Console.Write("#{0,4} -> Pinging host {1} (IP:{2}) on {5} port {3} with timeout {4}: ", ++currentPack, Host, hostIp, port, Timeout, ResolvedProtocol);
Console.ForegroundColor = portOpen ? ConsoleColor.DarkGreen : ConsoleColor.DarkRed;
Console.WriteLine(printResult);
Console.ResetColor();
}
catch (Exception ex)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine($"#{++currentPack,4} Error pinging host {Host}: {ex.Message}");
Console.ResetColor();
}
});
if (!AutoStop || !portOpen)
{
if (WaitTime > 0)
{
await Task.Delay(WaitTime);
}
}
else
{
break;
}
}
Console.WriteLine("Finished pinging host {0} (IP:{1}). {2} pings sent ({3} OPEN, {4} CLOSED)", Host, hostIp, currentPack, reachablePorts, closedPorts);
if (ReportFailedOnExit)
{
// return error level 1 if all pings where closed and 0 if any of them was open
return(reachablePorts > 0 ? 0 : 1);
}
if (ReportSucceededOnExit)
{
// return the amount of opened pings as the error level
return(reachablePorts);
}
return(0);
}
public ParameterToken this[int key] => Repeats.ElementAtOrDefault(key) ?? Empty;
