public async Task <IHttpActionResult> PostAlertSetting(AlertSetting alertSetting)
{
int writeLevel = Util.GetResourcePermission("Master Data", Util.ReourceOperations.Write);
if (writeLevel != 2)
{
ModelState.AddModelError("Access Level", "Unauthorized create access.");
}
var ch = db.AlertSettings.Where(s => s.EngineModelID == alertSetting.EngineModelID && s.ChannelID == alertSetting.ChannelID).FirstOrDefault();
if (ch != null)
{
ModelState.AddModelError("Duplicate", "Duplicate Channel Number for same model.");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.AlertSettings.Add(alertSetting);
await db.SaveChangesAsync();
return(CreatedAtRoute("DefaultApi", new { id = alertSetting.Id }, alertSetting));
}
public async Task <IHttpActionResult> GetAlertSetting(Guid id)
{
AlertSetting alertSetting = await db.AlertSettings.FindAsync(id);
if (alertSetting == null)
{
return(NotFound());
}
return(Ok(alertSetting));
}
public async Task <IHttpActionResult> PutAlertSetting(Guid id, AlertSetting alertSetting)
{
int writeLevel = Util.GetResourcePermission("Master Data", Util.ReourceOperations.Write);
if (writeLevel != 2)
{
ModelState.AddModelError("Access Level", "Unauthorized update access.");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != alertSetting.Id)
{
return(BadRequest());
}
DbEntityEntry entry = db.Entry(alertSetting);
entry.State = EntityState.Modified;
// Marking properties to update by compareing default object
AlertSetting defaultSetting = new AlertSetting();
entry = Util.GetUpdatedProperties(defaultSetting, alertSetting, entry);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AlertSettingExists(alertSetting.EngineModelID, alertSetting.ChannelID))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public static void BuildAlertDef()
{
using FacilityContext context = new FacilityContext();
AlertSetting alarm = new AlertSetting();
alarm.Name = "Alarm";
alarm.Frequency = 1.0;
alarm.Notification = NotificationType.EMAIL;
alarm.AlertAction = AlertAction.ALARM;
AlertSetting warn = new AlertSetting();
warn.Name = "Warning";
warn.Frequency = 4;
warn.Notification = NotificationType.EMAIL;
warn.AlertAction = AlertAction.WARN;
AlertSetting SoftWarning = new AlertSetting();
SoftWarning.Name = "Soft Warning";
SoftWarning.Frequency = 24;
SoftWarning.Notification = NotificationType.EMAIL;
SoftWarning.AlertAction = AlertAction.SOFTWARN;
AlertSetting Maintenance = new AlertSetting();
Maintenance.Name = "Maintenance";
Maintenance.Frequency = 0;
Maintenance.AlertAction = AlertAction.MAINTENANCE;
Maintenance.Notification = NotificationType.WEBSITE;
AlertSetting none = new AlertSetting();
none.Name = "Nothing";
none.Frequency = 0;
none.Notification = NotificationType.NONE;
none.AlertAction = AlertAction.NOTHING;
context.AlertSettings.Add(alarm);
context.AlertSettings.Add(warn);
context.AlertSettings.Add(Maintenance);
context.AlertSettings.Add(SoftWarning);
context.AlertSettings.Add(none);
context.SaveChanges();
Console.WriteLine("Should be done");
Console.ReadKey();
}
public async Task <IHttpActionResult> DeleteAlertSetting(Guid id)
{
int deleteLevel = Util.GetResourcePermission("Master Data", Util.ReourceOperations.Delete);
if (deleteLevel != 2)
{
ModelState.AddModelError("Access Level", "Unauthorized delete access.");
}
AlertSetting alertSetting = await db.AlertSettings.FindAsync(id);
if (alertSetting == null)
{
return(NotFound());
}
db.AlertSettings.Remove(alertSetting);
await db.SaveChangesAsync();
return(Ok(alertSetting));
}
public async Task <bool> Handle(MonitorBoxAlertCommand request, CancellationToken cancellationToken)
{
bool sendEmail = false;
this._logger.LogWarning("Recieved MonitorBoxAlertCommand");
var registers = request.AlertRegisters;
var reading = request.Device.LastRead;
var alert = reading.MonitorBoxAlert;
var statReg = request.AllReg;
StringBuilder builder = new StringBuilder();
this._messageBuilder.StartMessage();
foreach (var analog in registers.OfType <AnalogChannel>())
{
bool modified = false;
var reg = await this._context.Registers.OfType <AnalogChannel>()
.Include(e => e.SensorType)
.SingleOrDefaultAsync(e => e.Id == analog.Id);
if (reg != null)
{
if (!reg.Bypass)
{
AlertSetting action;
var analogAlert = ((AnalogAlert)alert[reg.PropertyMap]);
string alertName = "";
switch (analogAlert)
{
case AnalogAlert.ALARM1:
action = this._alertSettings.SingleOrDefault(e => e.AlertAction == reg.Alarm1Action);
alertName = "Warning";
break;
case AnalogAlert.ALARM2:
action = this._alertSettings.SingleOrDefault(e => e.AlertAction == reg.Alarm2Action);
alertName = "Alarm 1";
break;
case AnalogAlert.ALARM3:
action = this._alertSettings.SingleOrDefault(e => e.AlertAction == reg.Alarm3Action);
alertName = "Alarm 2";
break;
case AnalogAlert.NONE:
action = this._alertSettings.SingleOrDefault(e => e.AlertAction == AlertAction.NOTHING);
break;
default:
action = null;
break;
}
if (action.Notification == NotificationType.EMAIL)
{
if (reg.LastAlert.HasValue)
{
if (reg.PreviousAlert != analogAlert)
{
this._messageBuilder.AppendAlert(reg.Name, alertName, ((double)reading[reg.PropertyMap]).ToString());
reg.LastAlert = DateTime.Now;
reg.PreviousAlert = analogAlert;
modified = true;
sendEmail = true;
this._context.Entry <AnalogChannel>(reg).State = EntityState.Modified;
}
else
{
if ((DateTime.Now - reg.LastAlert.Value).TotalMinutes >= action.Frequency)
{
this._messageBuilder.AppendAlert(reg.Name, alertName, ((double)reading[reg.PropertyMap]).ToString());
reg.LastAlert = DateTime.Now;
reg.PreviousAlert = analogAlert;
modified = true;
sendEmail = true;
this._context.Entry <AnalogChannel>(reg).State = EntityState.Modified;
}
}
}
else
{
this._messageBuilder.AppendAlert(reg.Name, alertName, ((double)reading[reg.PropertyMap]).ToString());
reg.LastAlert = DateTime.Now;
reg.PreviousAlert = analogAlert;
modified = true;
sendEmail = true;
this._context.Entry <AnalogChannel>(reg).State = EntityState.Modified;
}
}
if (modified)
{
await this._context.SaveChangesAsync();
}
}
}
}
foreach (var digital in registers.OfType <DigitalInputChannel>())
{
bool modified = false;
var reg = await this._context.Registers.OfType <DigitalInputChannel>()
.SingleOrDefaultAsync(e => e.Id == digital.Id);
if (reg != null)
{
if (!reg.Bypass)
{
AlertSetting action = this._alertSettings.SingleOrDefault(e => e.AlertAction == reg.AlarmAction);
if (action.Notification == NotificationType.EMAIL)
{
if (reg.LastAlert.HasValue)
{
if ((DateTime.Now - reg.LastAlert.Value).TotalMinutes >= action.Frequency)
{
this._messageBuilder.AppendAlert(reg.Name, "Alarm", "Tripped");
reg.LastAlert = DateTime.Now;
modified = true;
sendEmail = true;
this._context.Entry <DigitalInputChannel>(reg).State = EntityState.Modified;
}
}
else
{
this._messageBuilder.AppendAlert(reg.Name, "Alarm", "Tripped");
reg.LastAlert = DateTime.Now;
modified = true;
sendEmail = true;
this._context.Entry <DigitalInputChannel>(reg).State = EntityState.Modified;
}
}
if (modified)
{
await this._context.SaveChangesAsync();
}
}
}
}
if (sendEmail)
{
foreach (var analog in statReg.OfType <AnalogChannel>())
{
this._messageBuilder.AppendStatus(analog.Name, ((double)reading[analog.PropertyMap]).ToString());
}
foreach (var digital in statReg.OfType <DigitalInputChannel>())
{
var trigger = (bool)reading[digital.PropertyMap];
string value;
if (digital.Logic == LogicType.HIGH)
{
value = (trigger) ? "Tripped" : "Okay";
}
else
{
value = (!trigger) ? "Tripped" : "Okay";
}
this._messageBuilder.AppendStatus(digital.Name, value);
}
await this._emailService.SendMessageAsync(this._messageBuilder.FinishMessage());
}
return(true);
}
public void refreshSetting()
{
this._setting = null;
}
public static void Main(string[] args)
{
try
{
//Configure the Logger
Logging.ConfigureLogger();
//Load the configuration from appsettings.json
Config.LoadAppSettings();
//load the cities list
CitiesConfig.LoadCitiesList();
//Initialize DB
using (BSMContext context = new BSMContext(Config.DBConnection))
{
if (context.Database.EnsureCreated())
{
Log.Information("Database schemas initialized");
}
var adminuser = context.Users.FirstOrDefault(u => u.LoginID.Equals("admin", StringComparison.OrdinalIgnoreCase));
if (adminuser == null)
{
adminuser = new Common.Model.User();
adminuser.LoginID = "admin";
adminuser.Name = "admin";
adminuser.Title = "Administrator";
adminuser.IsAdmin = true;
PasswordHasher <User> hasher = new PasswordHasher <User>();
string hashedPass = hasher.HashPassword(adminuser, "admin");
adminuser.Password = hashedPass;
adminuser.PasswordChangedAt = DateTime.Now;
adminuser.CreatedAt = DateTime.Now;
context.Users.Add(adminuser);
context.SaveChanges();
Log.Information("admin user is created in system");
}
var alertsetting = context.AlertSettings.FirstOrDefault();
if (alertsetting == null)
{
alertsetting = new AlertSetting();
alertsetting.TiltThreshold = null;
alertsetting.SkewingThreshold = null;
alertsetting.SpeedThreshold = null;
alertsetting.TempThreshold = null;
context.AlertSettings.Add(alertsetting);
context.SaveChanges();
Log.Information("alert settings is configured");
}
Log.Information("Database initialized: {0}", context.DataSourceString);
}
//start up the udp server
if (Config.UdpEnabled)
{
UdpServer udpserver = new UdpServer();
udpserver.Init();
}
else
{
Log.Information("UDP server is disabled, will not start up to listen on udp port");
}
//Start the web server host (include websocket)
CreateWebHostBuilder(args).Build().Run();
}
catch (Exception ex)
{
Log.Error(ex, "Error when startup the service");
}
}
