public ActionResult AddApproach(string id)
{
var signal = signalsRepository.GetSignalBySignalID(id);
Approach approach = GetNewApproach(signal);
approachRepository.AddOrUpdate(approach);
AddSelectListsToViewBag(signal);
return(PartialView(approach));
}
private void GetMetricsForSignal(string signalID)
{
MOE.Common.Models.Repositories.ISignalsRepository repository =
MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
var signal = repository.GetSignalBySignalID(signalID);
MetricsList = new List <SelectListItem>();
if (signal != null)
{
foreach (Models.MetricType m in signal.GetAvailableMetricsVisibleToWebsite())
{
if (m.ShowOnWebsite)
{
if (SelectedMetricID != null && SelectedMetricID == m.MetricID)
{
MetricsList.Add(new SelectListItem {
Value = m.MetricID.ToString(), Text = m.ChartName, Selected = true
});
}
else
{
MetricsList.Add(new SelectListItem {
Value = m.MetricID.ToString(), Text = m.ChartName
});
}
}
}
}
}
public double GetTMCVolume(DateTime startDate, DateTime endDate, string signalID, int Phase)
{
MOE.Common.Models.Repositories.ISignalsRepository repository =
MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
var signal = repository.GetSignalBySignalID(signalID);
List <Models.Detector> graphDetectors = signal.GetDetectorsForSignalByPhaseNumber(Phase);
List <int> tmcChannels = new List <int>();
foreach (Models.Detector gd in graphDetectors)
{
foreach (DetectionType dt in gd.DetectionTypes)
{
if (dt.DetectionTypeID == 4)
{
tmcChannels.Add(gd.DetChannel);
}
}
}
double count = (from cel in db.Controller_Event_Log
where cel.Timestamp >= startDate &&
cel.Timestamp < endDate &&
cel.SignalID == signalID &&
tmcChannels.Contains(cel.EventParam) &&
cel.EventCode == 82
select cel).Count();
return(count);
}
public MOE.Common.Business.TMC.TMCInfo CreateMetric()
{
base.LogMetricRun();
MOE.Common.Models.Repositories.ISignalsRepository repository =
MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
Common.Models.Signal signal = repository.GetSignalBySignalID(SignalID);
TmcInfo = new MOE.Common.Business.TMC.TMCInfo();
MOE.Common.Business.PlanCollection plans = new MOE.Common.Business.PlanCollection(StartDate, EndDate, SignalID);
MOE.Common.Models.Repositories.ILaneTypeRepository ltr = MOE.Common.Models.Repositories.LaneTypeRepositoryFactory.Create();
List <Common.Models.LaneType> laneTypes = ltr.GetAllLaneTypes();
MOE.Common.Models.Repositories.IMovementTypeRepository mtr = MOE.Common.Models.Repositories.MovementTypeRepositoryFactory.Create();
List <Common.Models.MovementType> movementTypes = mtr.GetAllMovementTypes();
MOE.Common.Models.Repositories.IDirectionTypeRepository dtr = MOE.Common.Models.Repositories.DirectionTypeRepositoryFactory.Create();
List <Common.Models.DirectionType> directions = dtr.GetAllDirections();
CreateLaneTypeCharts(signal, "Vehicle", laneTypes, movementTypes, directions, plans, TmcInfo);
CreateLaneTypeCharts(signal, "Exit", laneTypes, movementTypes, directions, plans, TmcInfo);
CreateLaneTypeCharts(signal, "Bike", laneTypes, movementTypes, directions, plans, TmcInfo);
return(TmcInfo);
}
public RLMSignalPhaseCollection(DateTime startDate, DateTime endDate, string signalID,
int binSize, double srlvSeconds)
{
int metricTypeID = 11;
MOE.Common.Models.Repositories.ISignalsRepository repository =
MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
var signal = repository.GetSignalBySignalID(signalID);
this.severeRedLightViolationsSeconds = srlvSeconds;
var approachesForMetric = signal.GetApproachesForSignalThatSupportMetric(metricTypeID);
//If there are phases in the database add the charts
if (approachesForMetric.Count() > 0)
{
foreach (MOE.Common.Models.Approach approach in approachesForMetric)
{
this.SignalPhaseList.Add(new MOE.Common.Business.RLMSignalPhase(
startDate, endDate, binSize, this.SevereRedLightViolationsSeconds,
metricTypeID, approach, false));
if (approach.PermissivePhaseNumber != null && approach.PermissivePhaseNumber > 0)
{
this.SignalPhaseList.Add(new MOE.Common.Business.RLMSignalPhase(
startDate, endDate, binSize, this.SevereRedLightViolationsSeconds,
metricTypeID, approach, true));
}
}
}
}
public SignalModelHelper(String SignalID)
{
MOE.Common.Models.Repositories.ISignalsRepository signals = MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
Signal = signals.GetSignalBySignalID(SignalID);
Approaches = GetApproachesForSignal();
LaneGroups = GetLaneGroupsForSignal();
Detectors = GetDetectorsForSignal();
}
public override List <string> CreateMetric()
{
base.CreateMetric();
MOE.Common.Models.Repositories.ISignalsRepository signalRepository =
MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
Signal = signalRepository.GetSignalBySignalID(SignalID);
this.MetricTypeID = 6;
Chart chart = new Chart();
string location = GetSignalLocation();
//SignalPhaseCollection signalphasecollection = new SignalPhaseCollection(
// StartDate,
// EndDate,
// SignalID,
// ShowVolumes,
// SelectedBinSize,
// MetricTypeID);
//If there are phases in the database add the charts
//if (signalphasecollection.SignalPhaseList.Count > 0)
//{
// foreach (MOE.Common.Business.SignalPhase signalPhase in signalphasecollection.SignalPhaseList)
// {
// if (signalPhase.Plans.PlanList.Count > 0)
// {
// chart = GetNewChart(signalPhase.Approach);
// AddDataToChart(chart, signalPhase);
// string chartName = CreateFileName();
// chart.ImageLocation = MetricFileLocation + chartName;
// chart.SaveImage(MetricFileLocation + chartName, System.Web.UI.DataVisualization.Charting.ChartImageFormat.Jpeg);
// ReturnList.Add(MetricWebPath + chartName);
// }
//}
List <Approach> metricApproaches = Signal.GetApproachesForSignalThatSupportMetric(this.MetricTypeID);
if (metricApproaches.Count > 0)
{
foreach (Approach approach in metricApproaches)
{
MOE.Common.Business.SignalPhase signalPhase = new SignalPhase(StartDate, EndDate, approach,
ShowVolumes, SelectedBinSize, MetricTypeID);
chart = GetNewChart(approach);
AddDataToChart(chart, signalPhase);
string chartName = CreateFileName();
chart.ImageLocation = MetricFileLocation + chartName;
chart.SaveImage(MetricFileLocation + chartName, System.Web.UI.DataVisualization.Charting.ChartImageFormat.Jpeg);
ReturnList.Add(MetricWebPath + chartName);
}
}
return(ReturnList);
}
/// <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 override List <string> CreateMetric()
{
base.CreateMetric();
List <string> returnString = new List <string>();
MOE.Common.Models.Repositories.ISignalsRepository sr = MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
MOE.Common.Models.Signal signal = sr.GetSignalBySignalID(SignalID);
//for (int x = 1; x < maxPhase + 1; x++)
List <Approach> metricApproaches = signal.GetApproachesForSignalThatSupportMetric(this.MetricTypeID);
if (metricApproaches.Count > 0)
{
foreach (Approach approach in metricApproaches)
{
//MOE.Common.Business.CustomReport.Phase phase = new MOE.Common.Business.CustomReport.Phase(detectors, x, SignalID, StartDate, EndDate, new List<int> { 1, 4, 5, 6, 7, 8, 9, 10, 61, 63, 64 }, 1);
MOE.Common.Business.CustomReport.Phase phase = new MOE.Common.Business.CustomReport.Phase(approach, StartDate, EndDate, new List <int> {
1, 4, 5, 6, 7, 8, 9, 10, 61, 63, 64
}, 1, false);
phase.ApproachDirection = approach.DirectionType.Description;
string location = GetSignalLocation();
string chartName = CreateFileName();
if (phase.PhaseNumber > 0)
{
GetChart(StartDate, EndDate, phase, location, FirstSecondsOfRed,
ShowFailLines, ShowAvgLines, ShowPercentFailLines, YAxisMax, chartName, returnString, false);
}
if (approach.PermissivePhaseNumber != null && approach.PermissivePhaseNumber > 0)
{
string permChartName = CreateFileName();
MOE.Common.Business.CustomReport.Phase permPhase = new MOE.Common.Business.CustomReport.Phase(approach, StartDate,
EndDate, new List <int> {
1, 4, 5, 6, 7, 8, 9, 10, 61, 63, 64
}, 1, true);
permPhase.ApproachDirection = approach.DirectionType.Description;
GetChart(StartDate, EndDate, permPhase, location, FirstSecondsOfRed,
ShowFailLines, ShowAvgLines, ShowPercentFailLines, YAxisMax, permChartName, returnString, true);
}
}
}
return(returnString);
}
public SignalInfoBoxViewModel(string signalID)
{
MOE.Common.Models.Repositories.ISignalsRepository repository =
MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
var signal = repository.GetSignalBySignalID(signalID);
SetTitle(signal);
SetDescription(signal);
SetMetrics(signal);
SignalID = signalID;
}
public ActionResult Create([Bind(Include = "SignalID,DirectionTypeID,Description,MPH,DecisionPoint,MovementDelay")] Approach approach)
{
ViewBag.DirectionType = new SelectList(directionRepository.GetAllDirections(), "DirectionTypeID", "Abbreviation");
if (ModelState.IsValid)
{
approachRepository.AddOrUpdate(approach);
approach.Signal = signalRepository.GetSignalBySignalID(approach.SignalID);
return(PartialView("~/Views/Signals/EditorTemplates/Approach.cshtml", approach));
}
return(PartialView(approach));
}
/// <summary>
/// Alternate Constructor for PDC type data.
/// </summary>
/// <param name="signalid"></param>
/// <param name="ApproachDirection"></param>
public RLMDetectorCollection(string signalID, string ApproachDirection)
{
MOE.Common.Models.Repositories.ISignalsRepository repository =
MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
var signal = repository.GetSignalBySignalID(signalID);
List <MOE.Common.Models.Detector> dets = signal.GetDetectorsForSignalThatSupportAMetricByApproachDirection(11, ApproachDirection);
foreach (MOE.Common.Models.Detector row in dets)
{
// MOE.Common.Business.Detector Detector = new Detector(row.DetectorID.ToString(), signalID, row.Det_Channel, row.Lane.LaneType, ApproachDirection);
MOE.Common.Business.Detector Detector = new Detector(row.DetectorID.ToString(), signalID, row.DetChannel, row.Approach);
DetectorsForRLM.Add(Detector);
}
}
public Signal(string signalID, DateTime startDate, DateTime endDate,
List <int> eventCodes, int startOfCycle)
{
_SignalID = signalID;
_StartDate = startDate;
_EndDate = endDate;
_EventCodes = eventCodes;
MOE.Common.Models.Repositories.ISignalsRepository repository =
MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
SignalModel = repository.GetSignalBySignalID(signalID);
_Detectors = SignalModel.GetDetectorsForSignal();
_Plans = new PlansBase(signalID, startDate, endDate);
GetPhases(startOfCycle);
}
static private int FindChannel(string SignalID, int Phase)
{
MOE.Common.Models.Repositories.ISignalsRepository smh = MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
MOE.Common.Models.Signal sig = smh.GetSignalBySignalID(SignalID);
var dets = sig.GetDetectorsForSignalByPhaseNumber(Phase);
if (dets.Count() > 0)
{
return(dets.FirstOrDefault().DetChannel);
}
else
{
return(0);
}
}
// GET: ConfigurationTable
public ActionResult Index(string SignalID)
{
MOE.Common.Models.Repositories.ISignalsRepository sr =
MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
var signal = sr.GetSignalBySignalID(SignalID);
List <MOE.Common.Business.Helpers.ConfigurationRecord> records =
new List <MOE.Common.Business.Helpers.ConfigurationRecord>();
foreach (MOE.Common.Models.Detector gd in signal.GetDetectorsForSignal())
{
MOE.Common.Business.Helpers.ConfigurationRecord r = new ConfigurationRecord(gd);
records.Add(r);
}
Models.SPMConfigurationTableViewModel model = new Models.SPMConfigurationTableViewModel();
model.Records = records;
return(PartialView("ConfigurationTable", model));
}
public ActionResult Create(string id)
{
MOE.Common.Models.Repositories.ISignalsRepository signalsRepository =
MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
Signal signal = signalsRepository.GetSignalBySignalID(id);
List <MOE.Common.Models.MetricType> allMetricTypes = metricTyperepository.GetAllToDisplayMetrics();
MOE.Common.Models.MetricComment mc =
new MetricComment();
mc.Signal = signal;
mc.AllMetricTypes = allMetricTypes;
if (mc.MetricTypeIDs != null)
{
mc.MetricTypes = metricTyperepository.GetMetricTypesByMetricComment(mc);
}
return(PartialView(mc));
}
public AdvancedSpeedDataExport(string signalId, string location, DateTime startDate, DateTime endDate,
int binSize, List <string> DayOfweek)
{
MOE.Common.Models.Repositories.ISignalsRepository repository =
MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
var signal = repository.GetSignalBySignalID(signalId);
//Get the dates that match the daytype for the given period
List <DateTime> dtList = new List <DateTime>();
DateTime tempDate = startDate;
while (tempDate <= endDate)
{
if (DayOfweek.Contains(tempDate.DayOfWeek.ToString()))
{
dtList.Add(tempDate);
}
tempDate = tempDate.AddDays(1);
}
var table = signal.GetDetectorsForSignalThatSupportAMetric(10);
foreach (MOE.Common.Models.Detector row in table)
{
string direction = row.Approach.DirectionType.Description;
Approaches.Add(direction, new List <SpeedExportAvgSpeed>());
}
//Create approach direction collections for each date in the list
foreach (DateTime dt in dtList)
{
DateTime dtEnd = new DateTime(dt.Year, dt.Month, dt.Day,
endDate.Hour, endDate.Minute, endDate.Second);
Business.SpeedExportApproachDirectionCollection approachDirectioncollection =
new SpeedExportApproachDirectionCollection(dt,
dtEnd, signalId, binSize);
foreach (SpeedExportApproachDirection sad in approachDirectioncollection.List)
{
foreach (SpeedExportAvgSpeed sea in sad.AvgSpeeds.Items)
{
Approaches[sad.Direction].Add(sea);
}
}
}
}
/// <summary>
/// Constructor Used for Split monitor
/// </summary>
/// <param name="phasenumber"></param>
/// <param name="signalID"></param>
/// <param name="CycleEventsTable"></param>
public AnalysisPhase(int phasenumber, string signalID, List <Models.Controller_Event_Log> CycleEventsTable)
{
MOE.Common.Models.Repositories.ISignalsRepository repository =
MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
var signal = repository.GetSignalBySignalID(signalID);
this.phaseNumber = phasenumber;
this.signalId = signalID;
this.IsOverlap = false;
List <Models.Controller_Event_Log> PedEvents = FindPedEvents(CycleEventsTable, phasenumber);
List <Models.Controller_Event_Log> PhaseEvents = FindPhaseEvents(CycleEventsTable, phasenumber);
Cycles = new AnalysisPhaseCycleCollection(phasenumber, signalId, PhaseEvents, PedEvents);
Models.Approach approach = signal.Approaches.Where(a => a.ProtectedPhaseNumber == phasenumber).FirstOrDefault();
if (approach != null)
{
this.Direction = approach.DirectionType.Description;
}
else
{
this.Direction = "Unknown";
}
}
//public SignalPhaseCollection( DateTime startDate, DateTime endDate, string signalID,
// bool showVolume, int binSize, int metricTypeID)
//{
// MOE.Common.Models.Repositories.ISignalsRepository repository =
// MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
// var signal = repository.GetSignalBySignalID(signalID);
// var detectors = signal.GetDetectorsForSignal();
// if (detectors.Count > 0)
// {
// foreach (Models.Detector detector in detectors)
// {
// int detChannel = detector.DetChannel;
// Double offset = detector.GetOffset();
// String direction = detector.Approach.DirectionType.Description;
// bool isOverlap = detector.Approach.IsProtectedPhaseOverlap;
// //Get the phase
// MOE.Common.Business.SignalPhase signalPhase = new MOE.Common.Business.SignalPhase(
// startDate, endDate, detector.Approach, showVolume, binSize, metricTypeID);
// this.SignalPhaseList.Add(signalPhase);
// }
// }
//}
public SignalPhaseCollection(DateTime startDate, DateTime endDate, string signalID,
bool showVolume, int binSize, int metricTypeID)
{
MOE.Common.Models.Repositories.ISignalsRepository repository =
MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
var signal = repository.GetSignalBySignalID(signalID);
List <Models.Approach> approaches = signal.GetApproachesForSignalThatSupportMetric(metricTypeID);
if (signal.Approaches != null && approaches.Count > 0)
{
Parallel.ForEach(approaches, approach =>
//foreach (Models.Approach approach in approaches)
{
String direction = approach.DirectionType.Description;
bool isOverlap = approach.IsProtectedPhaseOverlap;
int phaseNumber = approach.ProtectedPhaseNumber;
//double offset = approach.GetOffset();
//Get the phase
MOE.Common.Business.SignalPhase signalPhase = new MOE.Common.Business.SignalPhase(
startDate, endDate, approach, showVolume, binSize, metricTypeID);
//try not to add the same direction twice
var ExsitingPhases = from MOE.Common.Business.SignalPhase phase in this.SignalPhaseList
where phase.Approach.DirectionType.Description == signalPhase.Approach.DirectionType.Description
select phase;
if (ExsitingPhases.Count() < 1)
{
this.SignalPhaseList.Add(signalPhase);
}
});
this.signalPhaseList = signalPhaseList.OrderBy(s => s.Approach.ProtectedPhaseNumber).ToList();
}
}
public override List <string> CreateMetric()
{
base.CreateMetric();
string location = GetSignalLocation();
MOE.Common.Models.Repositories.ISignalsRepository sr = MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
Models.Signal signal = sr.GetSignalBySignalID(SignalID);
List <Approach> SpeedApproaches = signal.GetApproachesForSignalThatSupportMetric(10);
//If there are phases in the database add the charts
if (SpeedApproaches.Count > 0)
{
foreach (Approach approach in SpeedApproaches)
{
List <Models.Detector> speedDets = approach.GetDetectorsForMetricType(10);
foreach (Models.Detector det in speedDets)
{
//Display the PDC chart
Chart chart = GetNewSpeedChart(location, det);
AddSpeedDataToChart(chart, det, StartDate, EndDate, SelectedBinSize);
string chartName = CreateFileName();
//Save an image of the chart
chart.ImageLocation = MetricFileLocation + chartName;
chart.SaveImage(MetricFileLocation + chartName, System.Web.UI.DataVisualization.Charting.ChartImageFormat.Jpeg);
ReturnList.Add(MetricWebPath + chartName);
}
}
}
return(ReturnList);
}
private Chart GetNewSplitMonitorChart(DateTime graphStartDate, DateTime graphEndDate, string signalId, string location, int phase)
{
MOE.Common.Models.Repositories.ISignalsRepository repository =
MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
var signal = repository.GetSignalBySignalID(signalId);
List <MOE.Common.Models.Detector> detectors = signal.GetDetectorsForSignalByPhaseNumber(phase);
string detID = "";
if (detectors.Count() > 0)
{
detID = detectors.First().ToString();
}
else
{
detID = "0";
}
Chart chart = new Chart();
string extendedDirection = string.Empty;
TimeSpan reportTimespan = graphEndDate - graphStartDate;
//Set the chart properties
chart.ImageType = ChartImageType.Jpeg;
chart.Height = 500;
chart.Width = 740;
chart.ImageStorageMode = ImageStorageMode.UseImageLocation;
chart.BorderlineDashStyle = ChartDashStyle.Dot;
SetChartTitle(chart, phase);
//Create the chart area
ChartArea chartArea = new ChartArea();
chartArea.Name = "ChartArea1";
chartArea.AxisX.Title = "Time (Hour of Day)";
chartArea.AxisX.IntervalType = DateTimeIntervalType.Hours;
chartArea.AxisX.LabelStyle.Format = "HH";
chartArea.AxisX2.LabelStyle.Format = "HH";
chartArea.AxisX.LabelAutoFitStyle = LabelAutoFitStyles.None;
if (reportTimespan.Days < 1)
{
if (reportTimespan.Hours > 1)
{
chartArea.AxisX2.Interval = 1;
chartArea.AxisX.Interval = 1;
}
else
{
chartArea.AxisX.LabelStyle.Format = "HH:mm";
chartArea.AxisX2.LabelStyle.Format = "HH:mm";
}
}
chartArea.AxisX2.Enabled = AxisEnabled.True;
chartArea.AxisX2.MajorTickMark.Enabled = true;
chartArea.AxisX2.IntervalType = DateTimeIntervalType.Hours;
chartArea.AxisX2.LabelAutoFitStyle = LabelAutoFitStyles.None;
chartArea.AxisY.Title = "Phase Duration (Seconds)";
if (YAxisMax != null)
{
chartArea.AxisY.Maximum = YAxisMax.Value;
}
chartArea.AxisY.MajorGrid.LineDashStyle = ChartDashStyle.Dot;
chart.ChartAreas.Add(chartArea);
Series PedActivity = new Series();
PedActivity.ChartType = SeriesChartType.Point;
PedActivity.Color = Color.Transparent;
PedActivity.Name = "PedActivity";
PedActivity.MarkerStyle = MarkerStyle.Circle;
PedActivity.MarkerBorderColor = Color.Orange;
PedActivity.MarkerBorderWidth = 1;
PedActivity.MarkerSize = 3;
Series GapoutSeries = new Series();
GapoutSeries.ChartType = SeriesChartType.Point;
GapoutSeries.Color = Color.OliveDrab;
GapoutSeries.Name = "GapOut";
GapoutSeries.XValueType = ChartValueType.DateTime;
GapoutSeries.MarkerStyle = MarkerStyle.Circle;
GapoutSeries.MarkerSize = 3;
Series MaxOutSeries = new Series();
MaxOutSeries.ChartType = SeriesChartType.Point;
MaxOutSeries.Color = Color.Red;
MaxOutSeries.Name = "MaxOut";
MaxOutSeries.XValueType = ChartValueType.DateTime;
MaxOutSeries.MarkerStyle = MarkerStyle.Circle;
MaxOutSeries.MarkerSize = 3;
Series ForceOffSeries = new Series();
ForceOffSeries.ChartType = SeriesChartType.Point;
ForceOffSeries.Color = Color.MediumBlue;
ForceOffSeries.Name = "ForceOff";
ForceOffSeries.MarkerStyle = MarkerStyle.Circle;
ForceOffSeries.MarkerSize = 3;
Series UnknownSeries = new Series();
UnknownSeries.ChartType = SeriesChartType.Point;
UnknownSeries.Color = Color.Black;
UnknownSeries.Name = "Unknown";
UnknownSeries.MarkerStyle = MarkerStyle.Circle;
UnknownSeries.MarkerSize = 3;
Series ProgramedSplit = new Series();
ProgramedSplit.ChartType = SeriesChartType.StepLine;
ProgramedSplit.Color = Color.OrangeRed;
ProgramedSplit.Name = "Programed Split";
ProgramedSplit.BorderWidth = 1;
//Add the Posts series to ensure the chart is the size of the selected timespan
Series testSeries = new Series();
testSeries.IsVisibleInLegend = false;
testSeries.ChartType = SeriesChartType.Point;
testSeries.Color = Color.White;
testSeries.Name = "Posts";
testSeries.XValueType = ChartValueType.DateTime;
chart.Series.Add(ProgramedSplit);
chart.Series.Add(GapoutSeries);
chart.Series.Add(MaxOutSeries);
chart.Series.Add(ForceOffSeries);
chart.Series.Add(UnknownSeries);
chart.Series.Add(PedActivity);
chart.Series.Add(testSeries);
//Add points at the start and and of the x axis to ensure
//the graph covers the entire period selected by the user
//whether there is data or not
chart.Series["Posts"].Points.AddXY(graphStartDate, 0);
chart.Series["Posts"].Points.AddXY(graphEndDate.AddMinutes(5), 0);
return(chart);
}
private string SortAndAddToMessage(ConcurrentBag <MOE.Common.Models.SPMWatchDogErrorEvent> errors)
{
MOE.Common.Models.Repositories.ISPMWatchDogErrorEventRepository watchDogErrorEventRepository =
MOE.Common.Models.Repositories.SPMWatchDogErrorEventRepositoryFactory.Create();
List <MOE.Common.Models.SPMWatchDogErrorEvent> SortedErrors =
errors.OrderBy(x => x.SignalID).ThenBy(x => x.Phase).ToList();
string ErrorMessage = "";
foreach (MOE.Common.Models.SPMWatchDogErrorEvent error in SortedErrors)
{
//List<SPMWatchDogErrorEvent> RecordsFromTheDayBefore = new List<SPMWatchDogErrorEvent>();
//compare to error log to see if this was failing yesterday
if (Settings.WeekdayOnly && ScanDate.DayOfWeek == DayOfWeek.Monday)
{
RecordsFromTheDayBefore =
watchDogErrorEventRepository.GetSPMWatchDogErrorEventsBetweenDates(ScanDate.AddDays(-3), ScanDate.AddDays(-2).AddMinutes(-1));
}
else
{
RecordsFromTheDayBefore =
watchDogErrorEventRepository.GetSPMWatchDogErrorEventsBetweenDates(ScanDate.AddDays(-1), ScanDate.AddMinutes(-1));
}
if (FindMatchingErrorInErrorTable(error) == false)
{
MOE.Common.Models.Repositories.ISignalsRepository signalRepository =
MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
var signal = signalRepository.GetSignalBySignalID(error.SignalID);
// Add to email if it was not failing yesterday
ErrorMessage += error.SignalID.ToString();
ErrorMessage += " - ";
ErrorMessage += signal.PrimaryName;
ErrorMessage += " & ";
ErrorMessage += signal.SecondaryName;
if (error.Phase > 0)
{
ErrorMessage += " - Phase ";
ErrorMessage += error.Phase;
}
ErrorMessage += " (" + error.Message + ")";
ErrorMessage += "\n";
//}
}
}
try
{
watchDogErrorEventRepository.AddList(errors.ToList());
}
catch (DbEntityValidationException ex)
{
foreach (var entityValidationErrors in ex.EntityValidationErrors)
{
foreach (var validationError in entityValidationErrors.ValidationErrors)
{
Console.WriteLine("Property: " + validationError.PropertyName + " Error: " + validationError.ErrorMessage);
}
}
}
return(ErrorMessage);
}
public override List <string> CreateMetric()
{
base.CreateMetric();
List <string> returnList = new List <string>();
MetricInfoList = new List <ApproachVolume.MetricInfo>();
MOE.Common.Models.Repositories.ISignalsRepository signalsRepository =
MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
var signal = signalsRepository.GetSignalBySignalID(this.SignalID);
var NSAdvanceVolumeApproaches = new List <MOE.Common.Business.ApproachVolume.Approach>();
var NSTMCVolumeApproaches = new List <MOE.Common.Business.ApproachVolume.Approach>();
var EWAdvanceVolumeApproaches = new List <MOE.Common.Business.ApproachVolume.Approach>();
var EWTMCVolumeApproaches = new List <MOE.Common.Business.ApproachVolume.Approach>();
//Sort the approaches by metric type and direction
foreach (MOE.Common.Models.Approach a in signal.Approaches)
{
if (a.DirectionType.Description == "Northbound" && a.GetDetectorsForMetricType(6).Count > 0)
{
MOE.Common.Business.ApproachVolume.Approach av = new MOE.Common.Business.ApproachVolume.Approach(a);
NSAdvanceVolumeApproaches.Add(av);
}
if (a.DirectionType.Description == "Northbound" && a.GetDetectorsForMetricType(5).Count > 0)
{
MOE.Common.Business.ApproachVolume.Approach av = new MOE.Common.Business.ApproachVolume.Approach(a);
NSTMCVolumeApproaches.Add(av);
}
if (a.DirectionType.Description == "Southbound" && a.GetDetectorsForMetricType(6).Count > 0)
{
MOE.Common.Business.ApproachVolume.Approach av = new MOE.Common.Business.ApproachVolume.Approach(a);
NSAdvanceVolumeApproaches.Add(av);
}
if (a.DirectionType.Description == "Southbound" && a.GetDetectorsForMetricType(5).Count > 0)
{
MOE.Common.Business.ApproachVolume.Approach av = new MOE.Common.Business.ApproachVolume.Approach(a);
NSTMCVolumeApproaches.Add(av);
}
if (a.DirectionType.Description == "Eastbound" && a.GetDetectorsForMetricType(6).Count > 0)
{
MOE.Common.Business.ApproachVolume.Approach av = new MOE.Common.Business.ApproachVolume.Approach(a);
EWAdvanceVolumeApproaches.Add(av);
}
if (a.DirectionType.Description == "Eastbound" && a.GetDetectorsForMetricType(5).Count > 0)
{
MOE.Common.Business.ApproachVolume.Approach av = new MOE.Common.Business.ApproachVolume.Approach(a);
EWTMCVolumeApproaches.Add(av);
}
if (a.DirectionType.Description == "Westbound" && a.GetDetectorsForMetricType(6).Count > 0)
{
MOE.Common.Business.ApproachVolume.Approach av = new MOE.Common.Business.ApproachVolume.Approach(a);
EWAdvanceVolumeApproaches.Add(av);
}
if (a.DirectionType.Description == "Westbound" && a.GetDetectorsForMetricType(5).Count > 0)
{
MOE.Common.Business.ApproachVolume.Approach av = new MOE.Common.Business.ApproachVolume.Approach(a);
EWTMCVolumeApproaches.Add(av);
}
}
string location = GetSignalLocation();
//create the charts for each metric type and direction
if (ShowAdvanceDetection && NSAdvanceVolumeApproaches.Count > 0)
{
MOE.Common.Business.ApproachVolume.ApproachVolumeChart AVC =
new MOE.Common.Business.ApproachVolume.ApproachVolumeChart(
StartDate, EndDate, SignalID, location, "Northbound", "Southbound", this,
NSAdvanceVolumeApproaches, true);
string chartName = CreateFileName();
//Save an image of the chart
AVC.Chart.SaveImage(MetricFileLocation + chartName, System.Web.UI.DataVisualization.Charting.ChartImageFormat.Jpeg);
AVC.info.ImageLocation = (MetricWebPath + chartName);
MetricInfoList.Add(AVC.info);
}
if (ShowTMCDetection && NSTMCVolumeApproaches.Count > 0)
{
MOE.Common.Business.ApproachVolume.ApproachVolumeChart AVC =
new MOE.Common.Business.ApproachVolume.ApproachVolumeChart(StartDate, EndDate, SignalID,
location, "Northbound", "Southbound", this, NSTMCVolumeApproaches, false);
string chartName = CreateFileName();
//Save an image of the chart
AVC.Chart.SaveImage(MetricFileLocation + chartName, System.Web.UI.DataVisualization.Charting.ChartImageFormat.Jpeg);
AVC.info.ImageLocation = (MetricWebPath + chartName);
MetricInfoList.Add(AVC.info);
}
if (ShowAdvanceDetection && EWAdvanceVolumeApproaches.Count > 0)
{
MOE.Common.Business.ApproachVolume.ApproachVolumeChart AVC =
new MOE.Common.Business.ApproachVolume.ApproachVolumeChart(StartDate, EndDate,
SignalID, location, "Eastbound", "Westbound", this, EWAdvanceVolumeApproaches, true);
string chartName = CreateFileName();
//Save an image of the chart
AVC.Chart.SaveImage(MetricFileLocation + chartName, System.Web.UI.DataVisualization.Charting.ChartImageFormat.Jpeg);
AVC.info.ImageLocation = (MetricWebPath + chartName);
MetricInfoList.Add(AVC.info);
}
if (ShowTMCDetection && EWTMCVolumeApproaches.Count > 0)
{
MOE.Common.Business.ApproachVolume.ApproachVolumeChart AVC =
new MOE.Common.Business.ApproachVolume.ApproachVolumeChart(StartDate, EndDate,
SignalID, location, "Eastbound", "Westbound", this, EWTMCVolumeApproaches, false);
string chartName = CreateFileName();
//Save an image of the chart
AVC.Chart.SaveImage(MetricFileLocation + chartName, System.Web.UI.DataVisualization.Charting.ChartImageFormat.Jpeg);
AVC.info.ImageLocation = (MetricWebPath + chartName);
MetricInfoList.Add(AVC.info);
}
return(returnList);
}
