public void CopyFrom(object original)
{
if (original is null)
{
throw new ArgumentNullException(nameof(original));
}
var src = (Template)original;
Name = src.Name;
Description = src.Description;
foreach (var t in src.Tags)
{
Tags.Add(t);
}
foreach (var a in src.Alarms)
{
Alarms.Add(a);
}
foreach (var z in src.Archives)
{
Archives.Add(z);
}
foreach (var d in src.DeviceToTemplates)
{
DeviceToTemplates.Add(d);
}
}
public void CountAlarmsTest4()
{
int[] volume = { 42, 68, 35, 1, 70, 25, 79, 59, 63, 65, 6, 46, 82, 28, 62, 92, 96, 43, 28, 37, 92, 5, 3, 54, 93, 83, 22, 17, 19, 96, 48, 27, 72, 39, 70, 13, 68, 100, 36, 95, 4, 12, 23, 34, 74, 65, 42, 12, 54, 69 };
int s = 9999;
Assert.AreEqual(203, Alarms.CountAlarms(volume, s));
}
public AlarmsByRuleControllerTest()
{
ConfigData configData = new ConfigData(new Logger(Uptime.ProcessId, LogLevel.Info));
Config config = new Config(configData);
IServicesConfig servicesConfig = config.ServicesConfig;
Mock <IStorageAdapterClient> storageAdapterClient = new Mock <IStorageAdapterClient>();
this.log = new Mock <ILogger>();
this.storage = new StorageClient(servicesConfig, this.log.Object);
string dbName = servicesConfig.AlarmsConfig.DocumentDbDatabase;
string collName = servicesConfig.AlarmsConfig.DocumentDbCollection;
this.storage.CreateCollectionIfNotExistsAsync(dbName, collName);
this.sampleAlarms = this.getSampleAlarms();
foreach (Alarm sampleAlarm in this.sampleAlarms)
{
this.storage.UpsertDocumentAsync(
dbName,
collName,
this.AlarmToDocument(sampleAlarm));
}
Alarms alarmService = new Alarms(servicesConfig, this.storage, this.log.Object);
Rules rulesService = new Rules(storageAdapterClient.Object, this.log.Object, alarmService);
this.controller = new AlarmsByRuleController(alarmService, rulesService, this.log.Object);
}
public void CountAlarmsTest2()
{
int[] volume = { 5, 2, 4 };
int s = 3;
Assert.AreEqual(1, Alarms.CountAlarms(volume, s));
}
public AlarmClock()
{
InitializeComponent();
vm = Alarms.Instance;
vm.UpdateEndpoints();
DataContext = vm;
}
void Start()
{
alarms = GameObject.FindObjectOfType <Alarms>().GetComponent <Alarms>();
firemanInventory = GetComponent <Inventory>();
aiCharacterControl = GetComponent <AICharacterControl>();
CheckExtinguisher();
}
public void ConstructorTest()
{
var rules = new RuleApiModel[] { };
mockRules
.Setup(x => x.GetAllAsync())
.ReturnsAsync(rules);
mockWriter
.Setup(x => x.OpenAsync(It.IsAny <IStorageServiceConfig>()))
.Returns(Task.FromResult(0));
var unused = new Alarms(
logger,
new ServicesConfig {
AlarmsStorageServiceConfig = null
},
mockRules.Object,
mockRulesEvaluation.Object,
mockWriter.Object);
mockRules
.Verify(x => x.GetAllAsync(), Times.Once);
mockWriter
.Verify(x => x.OpenAsync(It.IsAny <IStorageServiceConfig>()), Times.Once);
}
public void UpdateNodes()
{
var changed = false;
for (var i = 0; i < Alarms.Count; ++i)
{
if (Alarms[i].Node == null)
{
Alarms[i].FetchNode(_nodes);
if (Alarms[i].Node != null)
{
continue;
}
_status.RemoveAt(i);
Alarms.RemoveAt(i--);
changed = true;
}
}
if (changed)
{
_pi.SavePluginConfig(_config);
}
}
public Screens()
{
Home = new Home();
Alarms = new Alarms();
Settings = new Settings();
StartScreen = new StartScreen();
}
public async Task <IHttpActionResult> PutAlarms(int id, Alarms alarms)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != alarms.Id)
{
return(BadRequest());
}
db.Entry(alarms).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AlarmsExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
/// <summary>
/// Finishes the Pinball object.
/// </summary>
public void Finish()
{
try
{
Log.Write("Finishing framework");
FinishMainThread();
Alarms.Finish();
Table.Finish();
Cabinet.Finish();
// WriteStatisticsToLog();
//ThreadInfoList.ThreadTerminates();
Log.Write("DirectOutput framework finished.");
Log.Write("Bye and thanks for using!");
}
catch (Exception E)
{
Log.Exception("A exception occured while finishing the DirectOutput framework.", E);
throw new Exception("DirectOutput framework has encountered while finishing.\n Inner exception: {0}".Build(E.Message), E);
}
}
/// <summary>
/// Creates a new instance of the <see cref="AlarmUserControl"/> class.
/// </summary>
public AlarmUserControl()
{
InitializeComponent();
m_dataContext = new Alarms(15);
m_dataContext.PropertyChanged += ViewModel_PropertyChanged;
this.DataContext = m_dataContext;
}
private void LoadAlarmSettingsVersion1()
{
LoadAlarmSettingsVersion0();
// WARNING: what if settings is somehow changed/removed between loading of previous version and
// loading of modification for the latest version below?
// we are trying to load setting for the first time => there is nothing
// when versioning will be supported check mechanism should be better
// or someone delted the settings.dat file for example.
if (Windows.Storage.ApplicationData.Current.LocalSettings.Values.ContainsKey(AlarmsKey) == false)
{
return;
}
var settingsStr = Windows.Storage.ApplicationData.Current.LocalSettings.Values[AlarmsKey] as string;
var alarmsJson = JsonValue.Parse(settingsStr).GetArray();
foreach (var alarmJsonValue in alarmsJson)
{
var alarmJson = alarmJsonValue.GetObject();
var alarmId = int.Parse(alarmJson[JsonId].GetString());
var alarmIgnoreHolidays = alarmJson[JsonIgnoreHolidays].GetBoolean();
var alarm = Alarms.Single(a => a.Id == alarmId);
// modification made to the version 1.
alarm.IgnoreHolidays = alarmIgnoreHolidays;
}
}
public void CountAlarmsTest3()
{
int[] volume = { 1 };
int s = 10000;
Assert.AreEqual(10000, Alarms.CountAlarms(volume, s));
}
public AlarmsByRuleControllerTest()
{
Mock <IStorageAdapterClient> storageAdapterClient = new Mock <IStorageAdapterClient>();
this.httpContextAccessor = new Mock <IHttpContextAccessor>();
this.logger = new Mock <ILogger <AlarmsByRuleController> >();
this.appConfigHelper = new Mock <IAppConfigurationClient>();
this.asaManager = new Mock <IAsaManagerClient>();
var config = new AppConfig();
this.storage = new StorageClient(config, new Mock <ILogger <StorageClient> >().Object);
this.storage.CreateCollectionIfNotExistsAsync(config.DeviceTelemetryService.Alarms.Database, string.Empty);
this.kustoQuery = new Mock <IKustoQueryClient>();
this.sampleAlarms = this.GetSampleAlarms();
foreach (Alarm sampleAlarm in this.sampleAlarms)
{
this.storage.UpsertDocumentAsync(
config.DeviceTelemetryService.Alarms.Database,
string.Empty,
this.AlarmToDocument(sampleAlarm));
}
Alarms alarmService = new Alarms(config, this.storage, new Mock <ILogger <Alarms> >().Object, this.httpContextAccessor.Object, this.appConfigHelper.Object, this.kustoQuery.Object);
Rules rulesService = new Rules(storageAdapterClient.Object, this.asaManager.Object, new Mock <ILogger <Rules> >().Object, alarmService, new Mock <IDiagnosticsClient>().Object);
this.controller = new AlarmsByRuleController(alarmService, rulesService, this.logger.Object, config);
}
void addAlarm(object o)
{
Ticker a = new Ticker();
a.Closed += new EventHandler(a_Closed);
a.PropertyChanged += new PropertyChangedEventHandler(a_PropertyChanged);
Alarms.Add(a);
}
public void TagIDReturnsBadrequest()
{
Alarms tag = null;
var controller = new PlantConfigurationController();
var actionResult = controller.AddTagId(tag);
Assert.IsInstanceOfType(actionResult, typeof(BadRequestErrorMessageResult));
}
public override void AddChild(iCalObject child)
{
if (child is Alarm)
{
Alarms.Add((Alarm)child);
}
base.AddChild(child);
}
public override void RemoveChild(iCalObject child)
{
if (child is Alarm)
{
Alarms.Remove((Alarm)child);
}
base.RemoveChild(child);
}
public ActionResult DeleteConfirmed(int id)
{
Alarms alarms = db.Alarms.Find(id);
db.Alarms.Remove(alarms);
db.SaveChanges();
return(RedirectToAction("Index"));
}
void ExecuteRefreshCommand()
{
Alarms.Clear();
foreach (var alarm in App.Alarms)
{
Alarms.Add(alarm);
}
}
public void SetAlarms(IEnumerable <Alarm> newAlarms)
{
Alarms.Clear();
foreach (var alarm in newAlarms)
{
Alarms.Add(alarm);
}
}
private static Boolean KawigiEdit_RunTest(int testNum, int[] p0, int p1, Boolean hasAnswer, int p2)
{
Console.Write("Test " + testNum + ": [" + "{");
for (int i = 0; p0.Length > i; ++i)
{
if (i > 0)
{
Console.Write(",");
}
Console.Write(p0[i]);
}
Console.Write("}" + "," + p1);
Console.WriteLine("]");
Alarms obj;
int answer;
obj = new Alarms();
DateTime startTime = DateTime.Now;
answer = obj.countAlarms(p0, p1);
DateTime endTime = DateTime.Now;
Boolean res;
res = true;
Console.WriteLine("Time: " + (endTime - startTime).TotalSeconds + " seconds");
if (hasAnswer)
{
Console.WriteLine("Desired answer:");
Console.WriteLine("\t" + p2);
}
Console.WriteLine("Your answer:");
Console.WriteLine("\t" + answer);
if (hasAnswer)
{
res = answer == p2;
}
if (!res)
{
Console.WriteLine("DOESN'T MATCH!!!!");
}
else if ((endTime - startTime).TotalSeconds >= 2)
{
Console.WriteLine("FAIL the timeout");
res = false;
}
else if (hasAnswer)
{
Console.WriteLine("Match :-)");
}
else
{
Console.WriteLine("OK, but is it right?");
}
Console.WriteLine("");
return(res);
}
//////////////////////////////////////////////////////////////////////////////////
public override bool Init()
{
base.Init();
WindowForm = new AlarmForm(this);
this.m_alarmas = new Alarms(this);
this.m_alarmas.CambioDeAlarma += ActualizarAlarma;
this.m_alarmas.Communication = this.GetGlobalParameter("Communication").ToString();
return(true);
}
public DataCollecter()
{
healer = ModulesManager.healer;
autoHaste = ModulesManager.autoHaste;
sio = ModulesManager.sio;
antyParalyse = ModulesManager.antyParalyse;
targeting = ModulesManager.targeting;
walker = ModulesManager.walker;
alarms = ModulesManager.alarms;
}
public override void ReverseInit(object returnedData)
{
base.ReverseInit(returnedData);
if ((bool)returnedData)
{
Alarms.Clear();
CreateLists();
}
}
public override MID processPackage(string package)
{
if (base.isCorrectType(package))
{
this.AlarmData = new Alarms().getAlarmFromPackage(package);
return(this);
}
return(this.nextTemplate.processPackage(package));
}
public async Task <IHttpActionResult> GetAlarms(int id)
{
Alarms alarms = await db.Alarms.FindAsync(id);
if (alarms == null)
{
return(NotFound());
}
return(Ok(alarms));
}
public ActionResult Edit([Bind(Include = "AlarmId,UserId,Longitide,Latitude,FileType,FileName,AlarmContent")] Alarms alarms)
{
if (ModelState.IsValid)
{
db.Entry(alarms).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.UserId = new SelectList(db.Users, "UserId", "UserName", alarms.UserId);
return(View(alarms));
}
public StopwatchItem GetAlarm(string key)
{
var item = Alarms.Where(i => i.Key == key).FirstOrDefault();
if (item == null)
{
throw new ArgumentException("No alarm found with key " + key, "key");
}
return(item);
}
/*
* Method attempts to load the alarms & timers config file, checking
* for file corruption, incorrect permissions, and for file existance;
* Method adds any found alarms or timers to the appropriate global
* List objects and returns 'true' if no errors are found or throws
* DANTException upon garbled data or no file found
*/
private void loadAlarmsTimers()
{
String[] rawFile;
int aCntr = 0, tCntr = 0;
if (chkCfg()) { return; }
rawFile = readCfg();
if (rawFile == null) {
throw new DANTException("Error reading cfg file");
}
foreach (String raw in rawFile) {
String[] rawFields;
//not sure how to fix this just yet; it might require
//a change in the config file at this point, also
Alarms tmpAlarm = new Alarms();
Timers tmpTimer = new Timers();
if (fileIODebugging) {
Console.WriteLine("raw: " + raw);
}
try {
rawFields = parseSavedFieldsLine(raw);
} catch {
if (fileIODebugging) {
Console.WriteLine("Error parsing saved fields " +
"line\n");
}
rawFields = null; //don't remember :|
throw new DANTException("Error parsing saved " +
"fields line\n");
}
if (rawFields == null) {
if (fileIODebugging) {
Console.WriteLine("null string");
}
continue;
} else if (rawFields[0].CompareTo("A") == 0) {
tmpAlarm = createTmpAlarm(rawFields);
activeAls.Add(tmpAlarm);
addAlarm(aCntr++);
} else if (rawFields[0].CompareTo("T") == 0) {
tmpTimer = createTmpTimer(rawFields);
activeTms.Add(tmpTimer);
addTimer(tCntr++);
} else {
MessageBox.Show("Issue parsing config file!",
"Cannot Parse DANT.cfg", MessageBoxButtons.OK,
MessageBoxIcon.Error);
throw new DANTException("Yet another issue trying to " +
"parse the config file!");
}
}
return;
}
/*
* Method creates a temporary Alarm entry to be utilized
* prior to pushing onto the list
*/
private Alarms createTmpAlarm(string[] fields)
{
if (fields[0] == null) { return null; }
if (fields[0].CompareTo("A") != 0) { return null; }
//the behavior above may not be needed after reimplemented
//from the calling code (where it would better live)
Alarms tmp = new Alarms();
tmp.name = fields[1];
tmp.setRunning(false);
tmp.ringAt = checkAlarmDay(convertSavedFields(fields));
tmp.soundBite = fields[5];
return tmp;
}
/*
* Method for adding a new alarm to the List and form objects through
* button click.
*/
private void btnAddAlarm_Click(object sender, EventArgs e)
{
//verify that name box is not still full of default value
if (txtAlarmName.Text.CompareTo("Alarm Name Here") == 0) {
MessageBox.Show("You must enter a valid name for the " +
"alarm that you are setting!");
throw new DANTException("Enter valid name for the alarm/" +
"timer being set");
}
//verify that numericUpDown selectors are not at 0,0,0
if (!legitTime((int)numAlarmHr.Value, (int)numAlarmMin.Value,
(int)numAlarmSec.Value, true)) {
throw new DANTException("At least one element must be " +
"nonzero");
}
Alarms tmpAlarm = new Alarms();
tmpAlarm.soundBite = soundByteSelection();
//check to see if alarm is for tomorrow, set other options
tmpAlarm.ringAt = checkAlarmDay((int)numAlarmHr.Value,
(int)numAlarmMin.Value,
(int)numAlarmSec.Value);
tmpAlarm.name = txtAlarmName.Text;
grayItemNameBoxNResetNumerics(true);
//add it to the list
activeAls.Add(tmpAlarm);
//add alarm to the 'active' alarms list in the checkboxlist
addAlarm(activeAls.IndexOf(tmpAlarm));
try {
saveAlarmsTimers();
} catch {
if (fileIODebugging) {
Console.WriteLine("Error saving alarms/timers\n");
}
throw new DANTException("Error saving alarms/timers\n");
}
}
