public string GetSignalLocation()
{
MOE.Common.Models.Repositories.ISignalsRepository signalRepository =
MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
return(signalRepository.GetSignalLocation(SignalID));
}
public ActionResult Edit(Signal signal)
{
try
{
ModelState.Clear();
signal = SetDetectionTypes(signal);
//var modelStateErrors = this.ModelState.Keys.SelectMany(key => this.ModelState[key].Errors);
if (TryValidateModel(signal))
{
MOE.Common.Models.Repositories.ISignalsRepository repository =
MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
repository.AddOrUpdate(signal);
AddSelectListsToViewBag(signal);
return(Content("Save Successful!" + DateTime.Now.ToString()));
}
return(Content("There was a validation error."));
}
catch (ValidationException ex)
{
return(Content(ex.Message));
}
catch (Exception ex)
{
return(Content(ex.Message));
}
}
public void SetPagedList()
{
MOE.Common.Models.Repositories.ISignalsRepository repository =
MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
//MOE.Common.Models.Repositories.SignalsRepositoryTest repository =
// new MOE.Common.Models.Repositories.SignalsRepositoryTest();
var queryable = repository.GetAllEnabledSignals().AsQueryable();
if (this.SelectedFilterID != null)
{
if (this.SelectedFilterID == 1)
{
queryable = queryable.Where(q => q.SignalID.Contains(this.FilterCriteria)).Select(q => q);
}
else if (this.SelectedFilterID == 2)
{
queryable = queryable.Where(q => q.PrimaryName.ToUpper().Contains(this.FilterCriteria.ToUpper())).Select(q => q);
}
else if (this.SelectedFilterID == 3)
{
queryable = queryable.Where(q => q.SecondaryName.ToUpper().Contains(this.FilterCriteria.ToUpper())).Select(q => q);
}
}
this.Signals = queryable.ToPagedList(this.Page, 5, this.OrderField, this.OrderDirection);
}
public SignalsController(
MOE.Common.Models.Repositories.IControllerTypeRepository controllerTypeRepository,
MOE.Common.Models.Repositories.IRegionsRepository regionRepository,
MOE.Common.Models.Repositories.IDirectionTypeRepository directionTypeRepository,
MOE.Common.Models.Repositories.IMovementTypeRepository movementTypeRepository,
MOE.Common.Models.Repositories.ILaneTypeRepository laneTypeRepository,
MOE.Common.Models.Repositories.IDetectionHardwareRepository detectionHardwareRepository,
MOE.Common.Models.Repositories.ISignalsRepository signalsRepository,
MOE.Common.Models.Repositories.IDetectorRepository detectorRepository,
MOE.Common.Models.Repositories.IDetectionTypeRepository detectionTypeRepository,
MOE.Common.Models.Repositories.IApproachRepository approachRepository,
MOE.Common.Models.Repositories.IMetricTypeRepository metricTypeRepository)
{
_signalsRepository = signalsRepository;
_detectorRepository = detectorRepository;
_detectionTypeRepository = detectionTypeRepository;
_approachRepository = approachRepository;
_controllerTypeRepository = controllerTypeRepository;
_regionRepository = regionRepository;
_directionTypeRepository = directionTypeRepository;
_movementTypeRepository = movementTypeRepository;
_laneTypeRepository = laneTypeRepository;
_detectionHardwareRepository = detectionHardwareRepository;
_metricTypeRepository = metricTypeRepository;
}
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));
}
}
}
}
private string GetSignalLcation(string SignalID)
{
MOE.Common.Models.Repositories.ISignalsRepository sr = MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
string location = sr.GetSignalLocation(SignalID);
return(location);
}
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);
}
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 GetSignalLocation(string signalID)
{
MOE.Common.Models.Repositories.ISignalsRepository repository =
MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
string signalLocation = repository.GetSignalLocation(signalID);
if (signalLocation == string.Empty)
{
signalLocation = "Signal Not Found";
}
return(Content(signalLocation));
}
static void Main(string[] args)
{
if (Properties.Settings.Default.forceNonParallel)
{
options = new ParallelOptions {
MaxDegreeOfParallelism = -1
};
}
else
{
if (Properties.Settings.Default.MaxThreads < 2)
{
options = new ParallelOptions {
MaxDegreeOfParallelism = 1
};
}
else
{
options = new ParallelOptions {
MaxDegreeOfParallelism = Properties.Settings.Default.MaxThreads
};
}
}
MOE.Common.Models.Repositories.ISignalsRepository sr =
MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
List <MOE.Common.Models.Signal> signalsDT = sr.GetLatestVerionOfAllSignalsByControllerType(4);
Parallel.ForEach(signalsDT, options, row =>
//foreach (var row in signalsDT )
{
if (TestIPAddress(row))
{
string signalId = row.SignalID;
Console.WriteLine("Starting signal" + signalId);
MOE.Common.Business.MaxTimeHDLogClient client = new MOE.Common.Business.MaxTimeHDLogClient();
XmlDocument xml = client.GetSince(row.IPAddress, GetMostRecentRecordTime(signalId));
SaveToDB(xml, signalId);
Console.WriteLine("Finished signal" + signalId);
}
}
);
}
/// <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 void StartScan()
{
if (!Settings.WeekdayOnly || (Settings.WeekdayOnly && ScanDate.DayOfWeek != DayOfWeek.Saturday && ScanDate.DayOfWeek != DayOfWeek.Sunday))
{
var watchDogErrorEventRepository = MOE.Common.Models.Repositories.SPMWatchDogErrorEventRepositoryFactory.Create();
MOE.Common.Models.Repositories.ISignalsRepository signalRepository =
MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
var signals = signalRepository.EagerLoadAllSignals();
CheckForRecords(signals);
CheckAllSignals(signals);
CheckSignalsWithData();
CreateAndSendEmail();
}
}
public SignalsController()
{
_signalsRepository = MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
_detectorRepository = MOE.Common.Models.Repositories.DetectorRepositoryFactory.Create();
_detectionTypeRepository = MOE.Common.Models.Repositories.DetectionTypeRepositoryFactory.Create();
_approachRepository = MOE.Common.Models.Repositories.ApproachRepositoryFactory.Create();
_metricTypeRepository = MOE.Common.Models.Repositories.MetricTypeRepositoryFactory.Create();
_controllerTypeRepository = MOE.Common.Models.Repositories.ControllerTypeRepositoryFactory.Create();
_regionRepository = MOE.Common.Models.Repositories.RegionsRepositoryFactory.Create();
_directionTypeRepository = MOE.Common.Models.Repositories.DirectionTypeRepositoryFactory.Create();
_movementTypeRepository = MOE.Common.Models.Repositories.MovementTypeRepositoryFactory.Create();
_laneTypeRepository = MOE.Common.Models.Repositories.LaneTypeRepositoryFactory.Create();
_detectionHardwareRepository = MOE.Common.Models.Repositories.DetectionHardwareRepositoryFactory.Create();
}
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);
}
/// <summary>
/// Alternate Constructor for PCD type data.
/// </summary>
/// <param name="signalid"></param>
/// <param name="approach"></param>
public DetectorCollection(MOE.Common.Models.Approach approach)
{
_signalId = approach.SignalID;
MOE.Common.Models.Repositories.ISignalsRepository repository =
MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
var PCDDetectors = approach.GetDetectorsForMetricType(6);
foreach (MOE.Common.Models.Detector row in PCDDetectors)
{
MOE.Common.Business.Detector Detector = new Detector(row);
Items.Add(Detector);
}
}
public void Initialize()
{
_db = new InMemoryMOEDatabase();
_db.ClearTables();
_mtr = new InMemoryMetricTypeRepository(_db);
MOE.Common.Models.Repositories.MetricTypeRepositoryFactory.SetMetricsRepository(_mtr);
_aer = new InMemoryApplicationEventRepository(_db);
MOE.Common.Models.Repositories.ApplicationEventRepositoryFactory.SetApplicationEventRepository(_aer);
_signalRepository = new InMemorySignalsRepository(_db);
MOE.Common.Models.Repositories.SignalsRepositoryFactory.SetSignalsRepository(_signalRepository);
_db.PopulateSignal();
}
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);
}
}
public ActionResult IndexByVersion(int versionId)
{
MOE.Common.Models.Repositories.ISignalsRepository sr =
MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
var signal = sr.GetSignalVersionByVersionId(versionId);
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 versionId)
{
MOE.Common.Models.Repositories.ISignalsRepository signalsRepository =
MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
Signal signal = signalsRepository.GetSignalVersionByVersionId(Convert.ToInt32(versionId));
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>
/// 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 ActionResult Edit(Signal signal)
{
try
{
ModelState.Clear();
signal = SetDetectionTypes(signal);
if (TryValidateModel(signal))
{
MOE.Common.Models.Repositories.ISignalsRepository repository =
MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
repository.AddOrUpdate(signal);
}
AddSelectListsToViewBag(signal);
return(Content("Save Successful!" + DateTime.Now.ToString()));
}
catch (Exception ex)
{
return(Content(ex.Message));
}
}
/// <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 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);
}
//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();
}
}
