private static bool TestIPAddress(MOE.Common.Models.Signal Signal)
{
IPAddress ip;
bool hasValidIP = true;
hasValidIP = IPAddress.TryParse(Signal.IPAddress, out ip);
if (Signal.IPAddress == "0")
{
hasValidIP = false;
}
//test to see if the address is reachable
if (hasValidIP)
{
Ping pingSender = new Ping();
PingOptions pingOptions = new PingOptions();
// Use the default Ttl value which is 128,
// but change the fragmentation behavior.
pingOptions.DontFragment = true;
// Create a buffer of 32 bytes of data to be transmitted.
string data = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
byte[] buffer = Encoding.ASCII.GetBytes(data);
int timeout = 120;
PingReply reply = pingSender.Send(Signal.IPAddress, timeout, buffer, pingOptions);
if (reply.Status != IPStatus.Success)
{
hasValidIP = false;
}
}
return(hasValidIP);
}
public void AddOrUpdate(MOE.Common.Models.Signal signal)
{
MOE.Common.Models.Signal g = (from r in db.Signals
where r.SignalID == signal.SignalID
select r).FirstOrDefault();
if (g == null)
{
db.Signals.Add(signal);
try
{
db.SaveChanges();
}
catch (Exception ex)
{
MOE.Common.Models.Repositories.IApplicationEventRepository repository =
MOE.Common.Models.Repositories.ApplicationEventRepositoryFactory.Create();
MOE.Common.Models.ApplicationEvent error = new ApplicationEvent();
error.ApplicationName = "MOE.Common";
error.Class = "Models.Repository.SignalRepository";
error.Function = "AddOrUpdate";
error.Description = ex.Message;
error.SeverityLevel = ApplicationEvent.SeverityLevels.High;
error.Timestamp = DateTime.Now;
repository.Add(error);
throw;
}
}
else
{
Update(signal);
//throw new Exception("Signal already exists in the database");
}
}
public SignalModelHelper(MOE.Common.Models.Signal signal)
{
Signal = signal;
Approaches = GetApproachesForSignal();
LaneGroups = GetLaneGroupsForSignal();
Detectors = GetDetectorsForSignal();
}
// This is where the magic happens
//: void doStuff(String url, String data)
void DoStuff(MOE.Common.Models.Signal signal, String data)
{
XmlDocument xml = new XmlDocument();
xml.LoadXml(data);
SaveToDB(xml, signal.SignalID);
}
public void Remove(string id)
{
MOE.Common.Models.Signal g = db.Signals.Find(id);
if (g != null)
{
db.Signals.Remove(g);
db.SaveChanges();
}
}
public void Remove(MOE.Common.Models.Signal signal)
{
MOE.Common.Models.Signal g = (from r in db.Signals
where r.SignalID == signal.SignalID
select r).FirstOrDefault();
if (g != null)
{
db.Signals.Remove(g);
db.SaveChanges();
}
}
async Task ProcessAsync(MOE.Common.Models.Signal signal, string data)
{
await _semaphore.WaitAsync();
try
{
await Task.Run(() =>
{
DoStuff(signal, data);
});
}
finally
{
_semaphore.Release();
}
}
async Task ProcessAsync(MOE.Common.Models.Signal signal, XmlDocument xml)
{
await _semaphore.WaitAsync();
try
{
await Task.Run(() =>
{
DoStuff(signal, xml);
});
}
finally
{
_semaphore.Release();
}
}
public static MOE.Common.Models.Signal CopySignal(MOE.Common.Models.Signal incommingSignal, string newSignalID)
{
Models.SPM db = new SPM();
MOE.Common.Models.Signal newSignal = new Models.Signal();
newSignal.IPAddress = "10.10.10.10";
newSignal.PrimaryName = incommingSignal.PrimaryName;
newSignal.SecondaryName = incommingSignal.SecondaryName;
newSignal.Longitude = incommingSignal.Longitude;
newSignal.Latitude = incommingSignal.Latitude;
newSignal.RegionID = incommingSignal.RegionID;
newSignal.ControllerTypeID = incommingSignal.ControllerTypeID;
newSignal.Enabled = incommingSignal.Enabled;
newSignal.Approaches = new List <Models.Approach>();
//Models.Repositories.ISignalsRepository signalRepository =
// Models.Repositories.SignalsRepositoryFactory.Create();
//signalRepository.AddOrUpdate(newSignal);
//Models.Repositories.IApproachRepository approachRepository =
// Models.Repositories.ApproachRepositoryFactory.Create();
foreach (Models.Approach a in incommingSignal.Approaches)
{
Approach aForNewSignal = Models.Approach.CopyApproachForSignal(a.ApproachID); //this does the db.Save inside.
newSignal.Approaches.Add(aForNewSignal);
//approachRepository.AddOrUpdate(aForNewSignal);
}
newSignal.SignalID = newSignalID;
//try
//{
// db.SaveChanges();
//}
//catch (Exception ex)
//{
// Models.Repositories.IApplicationEventRepository eventRepository =
// Models.Repositories.ApplicationEventRepositoryFactory.Create();
// ApplicationEvent error = new ApplicationEvent();
// error.ApplicationName = "MOE.Common";
// error.Class = "Models.Signal.cs";
// error.Function = "CopySignal";
// error.Description = ex.Message;
// error.SeverityLevel = ApplicationEvent.SeverityLevels.Medium;
// error.Timestamp = DateTime.Now;
// eventRepository.Add(error);
// throw;
//}
return(newSignal);
}
public static bool CheckIfIPAddressIsValid(MOE.Common.Models.Signal signal)
{
bool hasValidIP = false;
IPAddress ip;
if (signal.IPAddress == "0")
{
return(false);
}
if (signal.IPAddress == "0.0.0.0")
{
return(false);
}
//test to see if the address is reachable
if (IPAddress.TryParse(signal.IPAddress, out ip))
{
Ping pingSender = new Ping();
PingOptions pingOptions = new PingOptions();
// Use the default Ttl value which is 128,
// but change the fragmentation behavior.
pingOptions.DontFragment = true;
// Create a buffer of 32 bytes of data to be transmitted.
string data = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
byte[] buffer = Encoding.ASCII.GetBytes(data);
int timeout = 120;
try
{
PingReply reply = pingSender.Send(signal.IPAddress, timeout, buffer, pingOptions);
if (reply != null && reply.Status == IPStatus.Success)
{
hasValidIP = true;
}
}
catch
{
hasValidIP = false;
}
}
return(hasValidIP);
}
/// <summary>
/// Generates PCD charts for upstream and downstream detectors based on
/// a Link Pivot Link
/// </summary>
/// <param name="upstreamSignalID"></param>
/// <param name="upstreamDirection"></param>
/// <param name="downstreamSignalID"></param>
/// <param name="downstreamDirection"></param>
/// <param name="delta"></param>
/// <param name="startDate"></param>
/// <param name="endDate"></param>
/// <param name="maxYAxis"></param>
public LinkPivotPCDDisplay(string upstreamSignalID, string upstreamDirection,
string downstreamSignalID, string downstreamDirection, int delta,
DateTime startDate, DateTime endDate, int maxYAxis)
{
MOE.Common.Models.Repositories.ISignalsRepository signalRepository =
MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
MOE.Common.Models.Signal upstreamSignal = signalRepository.GetSignalBySignalID(upstreamSignalID);
MOE.Common.Models.Signal downstreamSignal = signalRepository.GetSignalBySignalID(downstreamSignalID);
MOE.Common.Models.Approach upApproachToAnalyze = GetApproachToAnalyze(upstreamSignal, upstreamDirection);
MOE.Common.Models.Approach downApproachToAnalyze = GetApproachToAnalyze(downstreamSignal, downstreamDirection);
if (upApproachToAnalyze != null)
{
GeneratePCD(upApproachToAnalyze, delta, startDate, endDate, true, maxYAxis);
}
if (downApproachToAnalyze != null)
{
GeneratePCD(downApproachToAnalyze, delta, startDate, endDate, false, maxYAxis);
}
}
public async void QueueItemAsync(MOE.Common.Models.Signal signal, string data)
{
var task = ProcessAsync(signal, data);
lock (_lock)
_pending.Add(task);
try
{
await task;
}
catch
{
if (!task.IsCanceled && !task.IsFaulted)
{
throw; // not the task's exception, rethrow
}
// don't remove faulted/cancelled tasks from the list
return;
}
// remove successfully completed tasks from the list
lock (_lock)
_pending.Remove(task);
}
public void Update(MOE.Common.Models.Signal incomingSignal)
{
MOE.Common.Models.Signal signalFromDatabase = (from r in db.Signals
where r.SignalID == incomingSignal.SignalID
select r).FirstOrDefault();
if (signalFromDatabase != null)
{
db.Entry(signalFromDatabase).CurrentValues.SetValues(incomingSignal);
if (incomingSignal.Approaches != null)
{
foreach (MOE.Common.Models.Approach a in incomingSignal.Approaches)
{
var approach = signalFromDatabase.Approaches.Where(app => app.ApproachID == a.ApproachID).FirstOrDefault();
if (approach != null)
{
if (!a.Equals(approach))
{
db.Entry(approach).CurrentValues.SetValues(a);
}
}
else
{
signalFromDatabase.Approaches.Add(a);
}
if (a.Detectors != null)
{
foreach (MOE.Common.Models.Detector newDetector in a.Detectors)
{
var detectorFromDatabase = signalFromDatabase.GetDetectorsForSignal().Where(d => d.ID == newDetector.ID).FirstOrDefault();
if (newDetector.DetectionTypes == null)
{
newDetector.DetectionTypes = db.DetectionTypes.Where(x => newDetector.DetectionTypeIDs.Contains(x.DetectionTypeID)).ToList();
}
if (detectorFromDatabase != null)
{
if (!newDetector.Equals(detectorFromDatabase))
{
if (detectorFromDatabase.DetectionTypes == null)
{
detectorFromDatabase.DetectionTypes = new List <DetectionType>();
}
var deletedDetectionTypes = detectorFromDatabase.DetectionTypes
.Except(newDetector.DetectionTypes).ToList <DetectionType>();
var addedDetectionTypes = newDetector.DetectionTypes
.Except(detectorFromDatabase.DetectionTypes).ToList <DetectionType>();
deletedDetectionTypes.ForEach(delDet => detectorFromDatabase.DetectionTypes.Remove(delDet));
foreach (DetectionType n in addedDetectionTypes)
{
if (db.Entry(n).State == EntityState.Detached)
{
db.DetectionTypes.Attach(n);
}
detectorFromDatabase.DetectionTypes.Add(n);
}
//var detectionTypes = db.DetectionTypes.Where(x => gd.DetectionTypeIDs.Contains(x.DetectionTypeID)).ToList();
//graphDetector.DetectionTypes = detectionTypes;
//graphDetector.DetectionTypeIDs = gd.DetectionTypeIDs;
db.Entry(detectorFromDatabase).CurrentValues.SetValues(newDetector);
}
}
else
{
if (newDetector.DetectionTypes == null)
{
newDetector.DetectionTypes = db.DetectionTypes.Where(x => newDetector.DetectionTypeIDs.Contains(x.DetectionTypeID)).ToList();
}
approach.Detectors.Add(newDetector);
}
}
}
}
}
}
else
{
foreach (Models.Approach a in incomingSignal.Approaches)
{
foreach (Models.Detector gd in a.Detectors)
{
gd.DetectionTypes = db.DetectionTypes.Where(x => gd.DetectionTypeIDs.Contains(x.DetectionTypeID)).ToList();
}
}
db.Signals.Add(incomingSignal);
}
try
{
db.SaveChanges();
}
catch (DbEntityValidationException e)
{
foreach (var eve in e.EntityValidationErrors)
{
Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
eve.Entry.Entity.GetType().Name, eve.Entry.State);
foreach (var ve in eve.ValidationErrors)
{
Console.WriteLine("- Property: \"{0}\", Error: \"{1}\"",
ve.PropertyName, ve.ErrorMessage);
}
}
throw;
}
}
// This is where the magic happens
//: void doStuff(String url, String data)
void DoStuff(MOE.Common.Models.Signal signal, XmlDocument xml)
{
SaveToDB(xml, signal.SignalID);
}
private void SetMetrics(MOE.Common.Models.Signal signal)
{
MetricTypes = signal.GetAvailableMetrics();
}
