}//public String GetAlert
public async Task <bool> Save()
{
using (FlightProcessorConnection CN = new FlightProcessorConnection()) {
//Add to Portal Alert table, to record SMS
PortalAlert ThisAlert = new PortalAlert {
AccountID = _Flight.AccountID,
AlertCategory = _AlertCategory,
AlertMessage = _AlertMessage,
AlertType = _AlertType,
Altitude = (int)_Flight.Altitude,
ApprovalID = _Flight.GetBase().ApprovalID,
CreatedOn = DateTime.UtcNow,
DroneID = _Flight.GetBase().DroneID,
FlightDataID = _Flight.LastProcessedID,
FlightReadTime = _Flight.LastFlightDate,
Latitude = _Flight.GetBase().Latitude,
Longitude = _Flight.GetBase().Longitude,
PilotID = _Flight.GetBase().PilotID,
FlightID = _Flight.GetBase().ID
};
CN.PortalAlert.Add(ThisAlert);
await CN.SaveChangesAsync();
if (_AlertType == "Critical")
{
await AlertQueue.AddToSmsQueue(ThisAlert);
}
}
return(true);
}
private static async Task <bool> fnLoadPendingData()
{
using (FlightProcessorConnection cn = new FlightProcessorConnection()) {
var Query = from d in cn.DroneData
where (d.IsProcessed == null || d.IsProcessed == 0) && d.DroneDataId > _LastDroneDataID
orderby d.DroneDataId ascending
select d;
if (await Query.AnyAsync())
{
List <DroneData> Data = await Query.Take(50).ToListAsync();
lock (_locker) {
PendingDroneData.AddRange(Data);
}
_LastDroneDataID = Data.Last().DroneDataId;
//a mininum pause for next read
await Task.Delay(200);
}
else
{
//if no record pending, then wait for 2 second before next read
await Task.Delay(2000);
}//if(await Query.AnyAsync())
}
return(true);
}//private static async void fnLoadPendingData()
private async Task LoadExtDroneFlight()
{
using (FlightProcessorConnection Info = new FlightProcessorConnection()) {
var Query = from d in Info.MSTR_Drone
where d.DroneId == _DroneID
select new {
AccountID = d.AccountID,
DroneName = d.DroneName
};
if (await Query.AnyAsync())
{
var Data = await Query.FirstAsync();
_ExtDroneFlight.DroneName = Data.DroneName;
_ExtDroneFlight.AccountID = Data.AccountID == null ? 0 : (int)Data.AccountID;
_ExtDroneFlight.AccountName = await Info.MSTR_Account
.Where(e => e.AccountId == _ExtDroneFlight.AccountID)
.Select(e => e.Name)
.FirstOrDefaultAsync();
}
int PilotID = (int)_ExtDroneFlight.GetBase().PilotID;
var Query2 = from d in Info.MSTR_User
where d.UserId == PilotID
select d.FirstName + " " + d.LastName;
if (await Query2.AnyAsync())
{
_ExtDroneFlight.PilotName = await Query2.FirstOrDefaultAsync();
}
}
}//LoadExtDroneFlight
public async Task <bool> SendSMS(List <String> SMSNumbers)
{
FlightProcessorConnection CN = new FlightProcessorConnection();
if (_AlertType == "Critical")
{
foreach (String SMSNumber in SMSNumbers)
{
PortalAlertEmail Notification = new PortalAlertEmail {
Attachments = null,
Body = _AlertMessage,
CreatedOn = DateTime.UtcNow,
EmailID = 0,
EmailSubject = $"SMS - {_AlertCategory}",
EmailURL = null,
FromAddress = null,
IsSend = 0,
SendOn = null,
SendStatus = null,
SendType = "SMS",
ToAddress = SMSNumber,
UserID = 0
};
CN.PortalAlertEmail.Add(Notification);
} //foreach (String SMSNumber in SMSNumbers)
await CN.SaveChangesAsync();
} //if(_AlertType == "Critical")
return(true);
}
private void frmMain_Load(object sender, EventArgs e)
{
using (FlightProcessorConnection cn = new FlightProcessorConnection()) {
this.Text += " [" + cn.Database.Connection.Database + "]";
}
_timer1.Interval = 2000;
_timer1.Elapsed += new System.Timers.ElapsedEventHandler(_timerEvent1);
_timer1.Enabled = true;
_timer2.Interval = 2000; //every 10 second
_timer2.Elapsed += new System.Timers.ElapsedEventHandler(_timerEvent2);
_timer2.Enabled = true;
ThreadDBActions = new Thread(new ThreadStart(fnThreadDBActions));
ThreadDBActions.IsBackground = true;
ThreadDBActions.Start();
ThreadSendAlertQueue = new Thread(new ThreadStart(fnSendAlertQueue));
ThreadSendAlertQueue.IsBackground = true;
ThreadSendAlertQueue.Start();
ResetFlightsGrid();
gridFlights.AutoSizeCells();
ResetNotificationGrid();
gridNotifications.AutoSizeCells();
WorkerProcess.OnTaskError += ShowExceptions;
WorkerProcess.OnDbEntityException += ShowEntityErrors;
WorkerProcess.StartProcessor();
}
public async Task LoadFlightApprovals()
{
DateTime ReadDate = new DateTime(_ReadTime.Year, _ReadTime.Month, _ReadTime.Day);
using (FlightProcessorConnection cn = new FlightProcessorConnection()) {
var Query = from d in cn.GCA_Approval
where
d.StartDate <= ReadDate &&
d.EndDate >= ReadDate &&
d.DroneID == _DroneID
orderby d.StartDate descending
select new FlightApproval {
ApprovalId = d.ApprovalID,
ApprovalName = d.ApprovalName,
EmailAddress = d.NotificationEmails,
Boundary = d.Coordinates,
SoftBoundary = d.InnerBoundaryCoord,
MaxAltitude = (Decimal)d.MaxAltitude,
MinAltitude = (Decimal)d.MinAltitude
};
if (await Query.AnyAsync())
{
FlightApprovals = await Query.ToListAsync <FlightApproval>();
}
}
}
public async Task <DroneFlight> GenerateFlight()
{
using (FlightProcessorConnection cn = new FlightProcessorConnection()) {
var Query = from d in cn.DroneFlight
where d.BBFlightID == _BBFlightID &&
d.DroneID == _DroneID
select d;
if (await Query.AnyAsync())
{
_DroneFlight = await Query.FirstAsync();
_FlightMapData.FlightID = _FlightID = _DroneFlight.ID;
await LoadFlightDetails();
}
else
{
//Load information about the flight from
await SetFlightInformation();
//Add flight information to database
cn.DroneFlight.Add(_DroneFlight);
await cn.SaveChangesAsync();
_FlightMapData.FlightID = _FlightID = _DroneFlight.ID;
}//if(await Query.AnyAsync())
_ExtDroneFlight = new ExtDroneFight(_DroneFlight);
}
//Load Approvals for the Flight
await LoadFlightApprovals();
await LoadExtDroneFlight();
return(_DroneFlight);
}
public async Task <bool> Update_MSTR_Drone()
{
try {
using (FlightProcessorConnection cn = new FlightProcessorConnection()) {
MSTR_Drone mSTR_Drone = await cn.MSTR_Drone.Where(w => w.DroneId == (int)_DroneFlight.DroneID).FirstOrDefaultAsync();
if (mSTR_Drone != null)
{
mSTR_Drone.LastFlightID = _DroneFlight.ID;
mSTR_Drone.FlightTime = _DroneFlight.FlightDate;
cn.Entry(mSTR_Drone).State = EntityState.Modified;
await cn.SaveChangesAsync();
}
}
return(true);
} catch (System.Data.Entity.Validation.DbEntityValidationException e) {
OnDbEntityException?.Invoke(e);
} catch (Exception ex) {
OnTaskError?.Invoke(new TaskExceptionInfo {
TaskException = ex,
TaskName = "Task - Update_MSTR_Drone()"
});
}
return(false);
}
}//LoadExtDroneFlight
private async Task LoadFlightDetails()
{
using (FlightProcessorConnection cn = new FlightProcessorConnection()) {
var Query = from e in cn.FlightMapData
where e.FlightID == _DroneFlight.ID
group e by e.FlightID into gr
select new {
MinSatellites = gr.Min(g => g.Satellites),
MaxSatellites = gr.Max(g => g.Satellites),
TotalSatellites = gr.Sum(g => g.Satellites),
CountSatellites = gr.Count(g => g.Satellites > 0),
MinAltitude = gr.Min(g => g.Altitude),
MaxAltitude = gr.Max(g => g.Altitude),
TotalAltitude = gr.Sum(g => g.Altitude),
CountAltitude = gr.Count(g => g.Altitude > 0),
MinSpeed = gr.Min(g => g.Speed),
MaxSpeed = gr.Max(g => g.Speed),
TotalSpeed = gr.Sum(g => g.Speed),
CountSpeed = gr.Count(g => g.Speed > 0),
};
if (await Query.AnyAsync())
{
var Data = await Query.FirstAsync();
SatelliteSummary.Reset((Double)Data.TotalSatellites, Data.CountSatellites, (Double)Data.MinSatellites, (Double)Data.MaxSatellites);
AltitudeSummary.Reset((Double)Data.TotalAltitude, Data.CountAltitude, (Double)Data.MinAltitude, (Double)Data.MaxAltitude);
SpeedSummary.Reset((Double)Data.TotalSpeed, Data.CountSpeed, (Double)Data.MinSpeed, (Double)Data.MaxSpeed);
}
var Query2 = from e in cn.FlightMapData
where e.FlightID == _DroneFlight.ID
orderby e.FlightMapDataID descending
select new {
TotalDistace = e.Distance,
TotalFlightTime = e.TotalFlightTime
};
if (await Query2.AnyAsync())
{
var Data = Query2.FirstOrDefault();
_TotalDistance = (Decimal)Data.TotalDistace;
_TotalFlightTime = (Decimal)Data.TotalFlightTime;
}
IsAlertedBoundary = (bool)_DroneFlight.IsFlightOutside; //is alert generated for outside boundary;
IsAlertedSoftBoundary = (_DroneFlight.IsFlightSoftFence == 1); //is alert generated for outside soft boundary;
IsAlertedAltitudeLimit = _DroneFlight.HigherLimit == 1; //is alert generated for heighter limit exeed;
IsAlertedProximityWarning = _DroneFlight.IsDistanceWarning == 1; //is alert generated for proximity warnning;
IsAlertedProximityCritical = _DroneFlight.IsDistanceCritical == 1; //is alert generated for proximity critical message;
//Load the status of Alert Generated to set variables
}
}
public static async Task <bool> AddToSmsQueue(PortalAlert alert)
{
//Load default Numbers, if not loaded already
lock (_lockSMSNumbers) {
if (_GlobalSmsNumbers == null)
{
if (!GetSmsNumbers())
{
_GlobalSmsNumbers = new List <String>();
}
}
}
//Add the SMS Number of local pilot
List <String> LocalSmsNumbers = _GlobalSmsNumbers.ToList();
int PilotID = (int)alert.PilotID;
using (FlightProcessorConnection cn = new FlightProcessorConnection()) {
String PilotSMSNumber = await cn.MSTR_User
.Where(w => w.UserId == PilotID)
.Select(s => s.MobileNo)
.FirstOrDefaultAsync();
if (!String.IsNullOrWhiteSpace(PilotSMSNumber))
{
LocalSmsNumbers.Add(FixCellNumber(PilotSMSNumber));
}
foreach (var CellNumber in LocalSmsNumbers)
{
PortalAlertEmail portalAlertEmail = new PortalAlertEmail {
CreatedOn = DateTime.UtcNow,
Attachments = null,
Body = alert.AlertMessage,
SendType = "SMS",
ToAddress = CellNumber,
IsSend = 0,
SendStatus = "Waiting",
UserID = PilotID,
SendOn = null
};
cn.PortalAlertEmail.Add(portalAlertEmail);
}
try {
await cn.SaveChangesAsync();
return(true);
} catch {
}
}
return(false);
}
public static async Task <bool> AddToEmailQueue(PortalAlertEmail portalAlertEmail)
{
if (!String.IsNullOrEmpty(portalAlertEmail.ToAddress))
{
portalAlertEmail.ToAddress = portalAlertEmail.ToAddress + ";";
}
portalAlertEmail.ToAddress += String.Join(";", GlobalEmailIDs);
using (FlightProcessorConnection cn = new FlightProcessorConnection()) {
cn.PortalAlertEmail.Add(portalAlertEmail);
await cn.SaveChangesAsync();
}
return(true);
}
public async Task <DroneFlight> SetFlightInformation()
{
_SetDroneFlightData();
using (FlightProcessorConnection cn = new FlightProcessorConnection()) {
var Query = from ds in cn.MSTR_Drone_Setup
where ds.DroneId == _DroneID
select ds.PilotUserId;
if (await Query.AnyAsync())
{
_DroneFlight.GSCID = _DroneFlight.PilotID = await Query.FirstOrDefaultAsync();
}
}
return(_DroneFlight);
}
private static bool GetSmsNumbers()
{
List <String> cellNumbers = new List <String>();
using (FlightProcessorConnection cn = new FlightProcessorConnection()) {
var Query = from sms in cn.SMSTable
select sms.CellNumber;
if (Query.Any())
{
cellNumbers = Query.ToList();
_GlobalSmsNumbers = new List <String>();
cellNumbers.ForEach((num) => _GlobalSmsNumbers.Add(FixCellNumber(num)));
return(true);
}
}
return(false);
}
public static async Task <bool> SendQueue()
{
PortalAlertEmail portalAlertEmail;
AlertSendStatus stat = null;
if (!alertQueue.Any())
{
return(false);
}
//Lock que items for safe threading
lock (_lockerQueue) {
portalAlertEmail = alertQueue[0];
alertQueue.RemoveAt(0);
}
switch (portalAlertEmail.SendType.ToLower())
{
case "sms":
stat = await SendSMS(portalAlertEmail);
break;
case "email":
stat = SendEmail(portalAlertEmail);
break;
}
if (stat != null)
{
portalAlertEmail.IsSend = (byte)(stat.IsSend ? 1 : 0);
portalAlertEmail.SendOn = DateTime.UtcNow;
portalAlertEmail.SendStatus = stat.ProviderMessage;
using (FlightProcessorConnection cn = new FlightProcessorConnection()) {
var entry = cn.Entry(portalAlertEmail);
entry.State = EntityState.Modified;
await cn.SaveChangesAsync();
}
lock (_lockerResetQueue) {
alertQueueProcessed.Add(portalAlertEmail);
}
return(true);
}
return(false);
}
public static async Task <bool> LoadQueue()
{
using (FlightProcessorConnection cn = new FlightProcessorConnection()) {
var Query = from alert in cn.PortalAlertEmail
where alert.EmailID > _LastLoadedAlertID && alert.IsSend == 0
orderby alert.EmailID ascending
select alert;
if (await Query.AnyAsync())
{
var QueItems = await Query.ToListAsync();
lock (_lockerQueue) {
QueItems.ForEach((item) => {
_LastLoadedAlertID = item.EmailID;
alertQueue.Add(item);
});
}
}
}
return(true);
}
private async static Task <bool> fnThreadUpdateDroneData()
{
List <int> PendingRemovedDroneDataIDs;
lock (_locker) {
if (RemovedDroneDataIDs.Count < 1)
{
return(false);
}
PendingRemovedDroneDataIDs = RemovedDroneDataIDs.ToList();
RemovedDroneDataIDs.Clear();
}
using (var update = new FlightProcessorConnection()) {
var Records = update.DroneData.Where(e => PendingRemovedDroneDataIDs.Contains(e.DroneDataId)).ToList();
Records.ForEach(e => e.IsProcessed = 1);
await update.SaveChangesAsync();
}
return(true);
} //private async static Task<bool> fnThreadUpdateDroneData()
public async Task <bool> UpdateFlightsToDB()
{
try {
_DroneFlight.MaxSpeed = (Decimal)SpeedSummary.Max;
_DroneFlight.MaxAltitude = (Decimal)AltitudeSummary.Max;
_DroneFlight.FlightHours = (int)_FlightMapData.TotalFlightTime;
_DroneFlight.FlightDistance = (Decimal)Math.Round((Double)_FlightMapData.Distance, 0);
using (var update = new FlightProcessorConnection()) {
var entry = update.Entry(_DroneFlight);
entry.State = EntityState.Modified;
await update.SaveChangesAsync();
}
return(true);
} catch (System.Data.Entity.Validation.DbEntityValidationException e) {
OnDbEntityException?.Invoke(e);
} catch (Exception ex) {
OnTaskError?.Invoke(new TaskExceptionInfo {
TaskException = ex, TaskName = "UpdateFlightsToDB()"
});
}
return(false);
}
public async Task <bool> UpdateFlight()
{
if (Proximities != null)
{
_FlightMapData.OtherFlightIDs = Newtonsoft.Json.JsonConvert.SerializeObject(GetSimpleProximity());
}
try {
using (FlightProcessorConnection cn = new FlightProcessorConnection()) {
cn.FlightMapData.Add(_FlightMapData);
cn.Entry(_DroneFlight).State = EntityState.Modified;
await cn.SaveChangesAsync();
}
return(true);
} catch (System.Data.Entity.Validation.DbEntityValidationException e) {
OnDbEntityException?.Invoke(e);
} catch (Exception ex) {
OnTaskError?.Invoke(new TaskExceptionInfo {
TaskException = ex,
TaskName = "Task - UpdateFlight()"
});
}
return(false);
}
