public void RunningClock()
{
var receivedUdp = new List <string>();
var settings = new ClockSettings()
{
IsRunning = true
};
var options = ClockServerOptions.Default.Value;
using (var receiver = new UdpClient(2000, AddressFamily.InterNetwork))
{
receiver.JoinMulticastGroup(IPAddress.Parse(options.Multicast.IPAddress), ClockServer.GetLocalIPAddress());
var state = new State {
u = receiver, l = receivedUdp
};
using var t = Task.Factory.StartNew(() => Receiver(receiver, state), CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default);
using var target = new ClockServer(
Options.Create(new ClockServerOptions()
{
Multicast = new MulticastOptions { IntervalSeconds = 1, IPAddress = "239.50.50.20", IsEnabled = true, PortNumber = 2000 },
Polling = new PollingOptions { IsEnabled = true, PortNumber = 2500 },
StartTime = TimeSpan.FromHours(5.5),
Speed = 6,
}));
{
}
target.Start(settings);
Assert.IsTrue(target.IsRunning);
Thread.Sleep(10000);
target.Stop();
receiver.Close();
t.Wait();
}
Assert.IsTrue(receivedUdp.Count > 0);
}
private void NewClockCommand_Executed(object sender, ExecutedRoutedEventArgs e)
{
ClockSettings panelSettings = new ClockSettings();
ClockDlg dlgWindow = new ClockDlg(panelSettings);
InitiateNewGaugeDlg(dlgWindow, panelSettings);
}
public void ClockStatusSerilizeAndDeSerialize()
{
var target = new ClockSettings()
{
DurationHours = 15.5,
ExpectedResumeTime = string.Empty,
IsElapsed = true,
IsRunning = true,
Message = string.Empty,
Mode = "1",
Name = "Test",
OverriddenElapsedTime = string.Empty,
AdministratorPassword = "******",
PauseReason = "NoReason",
PauseTime = string.Empty,
ShouldRestart = false,
ShowRealTimeWhenPaused = true,
Speed = 5.5,
StartTime = "06:00",
StartWeekday = "Monday"
};
var json = JsonSerializer.Serialize(target);
var actual = JsonSerializer.Deserialize <ClockSettings>(json);
Assert.IsNotNull(actual);
Assert.AreEqual(target.DurationHours, actual.DurationHours);
}
public XGameInstaller(MiscSettings miscSettings, ClockSettings clockSettings, TimerSettings timerSettings, PlayerDataModel playerDataModel, BreaktimeSettings breaktimeSettings)
{
_miscSettings = miscSettings;
_clockSettings = clockSettings;
_timerSettings = timerSettings;
_playerDataModel = playerDataModel;
_breaktimeSettings = breaktimeSettings;
}
public void Start(ClockSettings settings)
{
this.Stop();
this.settings = settings;
this.sensorId = -1;
this.time = DateTime.Now;
this.timer = new System.Timers.Timer();
this.timer.Interval = this.random.Next(settings.MinInterval, settings.MaxInterval);
this.timer.Elapsed += (_, __) => this.Invoke();
this.timer.Start();
}
private IDictionary <InvokeType, int> GetWeights(ClockSettings settings)
{
var weights = new Dictionary <InvokeType, int>
{
{ InvokeType.Success, settings.TriggerSuccessWeight },
{ InvokeType.DoNotTrigger, settings.DoNotTriggerWeight },
{ InvokeType.WrongSensor, settings.SetWrongSensorIdWeight },
{ InvokeType.WrongDeltaTime, settings.SetWrongDeltaTimeWeight },
{ InvokeType.MultipleSensors, settings.TriggerMultipleWeight }
};
return(weights.Where(w => w.Value != 0).ToDictionary(w => w.Key, w => w.Value));
}
public void OnCommand(Command cmd)
{
switch(cmd.MessageId)
{
case Command.COMMAND_RECIEVE_SETTINGS:
// Parse the settings
m_settings = Newtonsoft.Json.JsonConvert.DeserializeObject<ClockSettings>(cmd.Message);
// Update the UI
UpdateClockSettingsUI();
break;
}
}
public void OnCommand(Command cmd)
{
switch (cmd.MessageId)
{
case Command.COMMAND_RECIEVE_SETTINGS:
// Parse the settings
m_settings = Newtonsoft.Json.JsonConvert.DeserializeObject <ClockSettings>(cmd.Message);
// Update the UI
UpdateClockSettingsUI();
break;
}
}
public IHttpActionResult DeleteClockSettings(long id)
{
ClockSettings clockSettings = db.ClockSettings.Find(id);
if (clockSettings == null)
{
return(NotFound());
}
db.ClockSettings.Remove(clockSettings);
db.SaveChanges();
return(Ok(clockSettings));
}
public IHttpActionResult GetClockSettings()
{
// db.Configuration.ProxyCreationEnabled = false;
string uid = User.Identity.GetUserId();
ClockSettings clockSettings = db.ClockSettings.SingleOrDefault(z => z.UserId == uid);
if (clockSettings == null)
{
var cs = new ClockSettings {
UserId = uid
};
db.ClockSettings.Add(cs);
db.SaveChanges();
}
return(Ok(db.ClockSettings.SingleOrDefault(z => z.UserId == uid)));
}
public IActionResult Update(
[SwaggerParameter("Clock name", Required = true)] string?clock,
[FromQuery, SwaggerParameter("API-key", Required = true)] string?apiKey,
[FromQuery, SwaggerParameter("User Name", Required = true)] string?user,
[FromBody, SwaggerRequestBody("Clock settings", Required = true)] ClockSettings settings)
{
if (settings is null || string.IsNullOrWhiteSpace(clock))
{
return(BadRequest());
}
if (Servers.Exists(clock) && !IsAdministrator(apiKey, clock, settings.Password))
{
return(Unauthorized());
}
Servers.Instance(clock).Update(settings.AsSettings(), RemoteIpAddress, user);
return(Ok());
}
public IActionResult Update(
[SwaggerParameter("Clock name", Required = true)] string?clock,
[FromQuery, SwaggerParameter("Username", Required = true)] string?user,
[FromQuery, SwaggerParameter("Administrator password", Required = true)] string?password,
[FromBody, SwaggerRequestBody("Clock settings", Required = true)] ClockSettings settings)
{
if (settings is null || string.IsNullOrWhiteSpace(clock))
{
return(BadRequest(SettingsErrorMessage(clock)));
}
if (Servers.Exists(clock) && !IsAdministrator(clock, password))
{
return(Unauthorized(AdministratorUnauthorizedErrorMessage()));
}
if (Servers.Instance(clock).Update(user, password, settings.AsSettings(), RemoteIpAddress))
{
return(Ok());
}
return(Unauthorized(UserUnauthorizedErrorMessage()));
}
public Command CommandRecieved(Command command)
{
switch(command.MessageId)
{
case Command.COMMAND_RECIEVE_SETTINGS:
{
m_settings = Newtonsoft.Json.JsonConvert.DeserializeObject<ClockSettings>(command.Message);
break;
}
case Command.COMMAND_GET_SETTINGS:
{
// Send the settings
Command settingsCommand = new Command();
settingsCommand.MessageId = Command.COMMAND_RECIEVE_SETTINGS;
settingsCommand.Program = GlowCommon.GlowPrograms.Clock;
settingsCommand.Message = Newtonsoft.Json.JsonConvert.SerializeObject(m_settings);
return settingsCommand;
}
}
return null;
}
public IHttpActionResult PutClockSettings(ClockSettings clockSettings)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
clockSettings.UserId = User.Identity.GetUserId();
clockSettings.ScheduleId = clockSettings.Schedule.Id;
db.Entry(clockSettings).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
throw;
}
return(StatusCode(HttpStatusCode.NoContent));
}
public Command CommandRecieved(Command command)
{
switch (command.MessageId)
{
case Command.COMMAND_RECIEVE_SETTINGS:
{
m_settings = Newtonsoft.Json.JsonConvert.DeserializeObject <ClockSettings>(command.Message);
break;
}
case Command.COMMAND_GET_SETTINGS:
{
// Send the settings
Command settingsCommand = new Command();
settingsCommand.MessageId = Command.COMMAND_RECIEVE_SETTINGS;
settingsCommand.Program = GlowCommon.GlowPrograms.Clock;
settingsCommand.Message = Newtonsoft.Json.JsonConvert.SerializeObject(m_settings);
return(settingsCommand);
}
}
return(null);
}
public async Task <HttpResponseMessage> Update(string clockName, string?userName, ClockSettings settings) =>
await Http.PostAsJsonAsync($"api/clocks/{clockName}/update?apiKey={ApiKey}&user={userName}", settings).ConfigureAwait(false);
public async Task <HttpResponseMessage> UpdateSettings(string clockName, string?userName, string?administratorPassword, ClockSettings settings) =>
await Http.PostAsJsonAsync($"api/clocks/{clockName}/settings?user={userName}&password={administratorPassword}", settings).ConfigureAwait(false);
public void Construct(ClockSettings settings)
{
_settings = settings;
}
public Clock(MainWindow mainWindow, ClockSettings panelSettings)
: base(mainWindow, panelSettings)
{
this.panelSettings = panelSettings;
}
public ClockDlg(ClockSettings panelSettings)
: base(panelSettings)
{
InitializeComponent();
ApplyBindings();
}
protected override void Init(PanelSettings panelSettings)
{
this.panelSettings = base.panelSettings as ClockSettings;
}
