package art.servers.etdserver.historical;
|
|
import art.library.interop.serialization.Serialization;
|
import art.library.model.devices.Device;
|
import art.library.model.devices.DevicePersistenceHistorical;
|
import art.library.model.devices.DeviceStatus;
|
import art.library.model.devices.etd.Etd;
|
import art.library.model.devices.etd.EtdStatus;
|
import art.library.model.devices.etd.status.EtdStatusAggregation;
|
import art.library.model.devices.etd.status.EtdStatusAggregationLane;
|
import art.library.model.devices.etd.status.EtdStatusLane;
|
import art.servers.ServerException;
|
import art.servers.Shared;
|
import java.sql.ResultSet;
|
import java.util.ArrayList;
|
import java.util.Calendar;
|
import java.util.HashMap;
|
|
|
|
public class HistoricalPeriods
|
{
|
private Etd etd = null;
|
private String identifier = null;
|
private int lane = -1;
|
private int section = -1;
|
private long timestamp1 = 0;
|
private long timestamp2 = 0;
|
private String name = null;
|
|
private String language = null;
|
private int aggregationPeriod = 0;
|
private int etdPeriod = 0;
|
private int numberOfPeriods = 0;
|
private Register register = null;
|
private EtdStatus[] lEtdStatus = new EtdStatus[0];
|
|
|
public HistoricalPeriods(String identifier, int lane, int section, long timestamp1, long timestamp2, int aggregationPeriod, String language)
|
{
|
Calendar calendar1 = Calendar.getInstance();
|
calendar1.setTimeInMillis(timestamp1);
|
calendar1.set(Calendar.SECOND,0);
|
calendar1.set(Calendar.MILLISECOND,0);
|
|
Calendar calendar2 = Calendar.getInstance();
|
calendar2.setTimeInMillis(timestamp2);
|
calendar2.set(Calendar.SECOND,0);
|
calendar2.set(Calendar.MILLISECOND,0);
|
|
this.identifier = identifier;
|
this.lane = lane;
|
this.section = section;
|
this.timestamp1 = calendar1.getTimeInMillis();
|
this.timestamp2 = calendar2.getTimeInMillis();
|
this.aggregationPeriod = aggregationPeriod;
|
this.language = language;
|
}
|
|
|
|
|
public EtdStatusAggregation generate() throws ServerException
|
{
|
ResultSet result = null;
|
|
|
try
|
{
|
long timestampStart = this.timestamp1 - (300000L);
|
long timestampEnd = this.timestamp2 + (600000L);
|
String command = "SELECT value FROM DEVICES WHERE identifier = '" + identifier + "' AND type = '" + Etd.class.getName() + "' AND timestamp >= " + timestampStart + " AND timestamp < " + timestampEnd + " ORDER BY timestamp ASC";
|
|
String message = "From " + Device.getDate(timestamp1) + " to " + Device.getDate(timestamp2);
|
Shared.println("Historical", message);
|
Shared.println("Historical", command);
|
|
result = Shared.controllerDatabase.getHistoricalPersistance().get(0).executeQuery(command);
|
|
while (result.next() == true)
|
{
|
String value = result.getString(1);
|
|
if (etd == null)
|
{
|
etd = (Etd)((DevicePersistenceHistorical)Serialization.deserialize(DevicePersistenceHistorical.class, value)).device;
|
if (etd != null)
|
{
|
initialise();
|
}
|
}
|
else
|
{
|
etd = (Etd)((DevicePersistenceHistorical)Serialization.deserialize(DevicePersistenceHistorical.class, value)).device;
|
if (etd != null)
|
{
|
if (etd.getDeviceInformation().period != etdPeriod) throw new ServerException(Shared.getMessage(language, "Selected time range has several integration periods"));
|
if (name == null) name = etd.getDeviceInformation().getName();
|
}
|
}
|
|
|
try
|
{
|
EtdStatus status = etd.getDeviceStatus();
|
|
int position = (int)((status.measurementTimestamp - timestamp1)/(aggregationPeriod * 1000));
|
if ((status.measurementTimestamp-timestamp1) < 0)
|
position = -1;
|
|
if ((position >= 0) && (position < numberOfPeriods)) // Podemos tener un registro con timestamp1 < measurementTimestamp por una alarma o algo
|
{
|
if (register == null)
|
{
|
register = new Register(position);
|
}
|
else
|
{
|
if (register.position != position)
|
{
|
register.aggregation();
|
register = new Register(position);
|
}
|
}
|
|
register.mstatus.put(status.measurementTimestamp, status);
|
}
|
}
|
catch (Exception e)
|
{
|
e.printStackTrace();
|
}
|
|
}
|
|
if (etd == null) throw new ServerException("No data available in selected time range");
|
if (register != null) register.aggregation();
|
EtdStatusAggregation response = new EtdStatusAggregation();
|
response.device = identifier;
|
response.name = name;
|
response.section = (section >= 0);
|
if (response.section == true)
|
response.number = section;
|
else
|
response.number = lane;
|
response.timestamp1 = timestamp1;
|
response.timestamp2 = timestamp2;
|
response.aggregationPeriod = aggregationPeriod;
|
|
for (EtdStatus status : lEtdStatus)
|
{
|
EtdStatusAggregationLane data = new EtdStatusAggregationLane();
|
data.timestamp = status.measurementTimestamp;
|
if (lane >=0) data.lane = status.getLane(lane); else data.lane = status.getSection(section);
|
response.ldata.add(data);
|
}
|
|
for (int i=0; i<response.ldata.size(); i++)
|
{
|
EtdStatusAggregationLane laneAggregation = response.ldata.get(i);
|
if (laneAggregation.lane == null)
|
{
|
laneAggregation.lane = new EtdStatusLane();
|
}
|
else
|
{
|
laneAggregation.lane.speed = Math.rint(laneAggregation.lane.speed);
|
}
|
}
|
return response;
|
|
}
|
catch (ServerException exception)
|
{
|
exception.printStackTrace();
|
throw exception;
|
}
|
catch (Exception exception)
|
{
|
exception.printStackTrace();
|
throw new ServerException(exception);
|
}
|
finally
|
{
|
try { result.close(); } catch (Exception e) {};
|
}
|
|
}
|
|
|
|
|
|
private void initialise() throws ServerException, Exception
|
{
|
etdPeriod = etd.getDeviceInformation().period;
|
|
if (aggregationPeriod == 0) aggregationPeriod = etdPeriod;
|
|
if ((aggregationPeriod % etdPeriod) != 0)
|
{
|
throw new ServerException(Shared.getMessage(language, "Selected period must be multiple of traffic counter period"));
|
}
|
|
if (timestamp1 > timestamp2)
|
{
|
throw new ServerException(Shared.getMessage(language, "From timestamp must be lower than to timestamp"));
|
}
|
|
timestamp1 = timestamp1 - (timestamp1 % (aggregationPeriod * 1000));
|
timestamp2 = timestamp2 - (timestamp2 % (aggregationPeriod * 1000));
|
numberOfPeriods = (int)((timestamp2 - timestamp1)/(aggregationPeriod * 1000));
|
if (numberOfPeriods > 133920) throw new ServerException(Shared.getMessage(language, "Result would produce too much registers. Select lower date range or higher period"));
|
|
lEtdStatus = new EtdStatus[numberOfPeriods];
|
long timestamp = timestamp1;
|
for (int i=0; i<numberOfPeriods; i++)
|
{
|
lEtdStatus[i] = new EtdStatus();
|
lEtdStatus[i].measurementTimestamp = timestamp;
|
lEtdStatus[i].status = DeviceStatus.STATUS_NULL;
|
lEtdStatus[i].period = aggregationPeriod;
|
timestamp = timestamp + (aggregationPeriod * 1000);
|
}
|
}
|
|
|
|
|
|
private class Register
|
{
|
public HashMap<Long, EtdStatus> mstatus = new HashMap<Long, EtdStatus>();
|
public int position;
|
|
public Register(int position)
|
{
|
this.position = position;
|
}
|
|
|
public void aggregation()
|
{
|
int totalMeasurements = aggregationPeriod / etd.getDeviceInformation().period;
|
int correctMeasurements = 0;
|
ArrayList<EtdStatus> lstatus = new ArrayList<EtdStatus>(mstatus.values());
|
|
EtdStatus etdStatus = lstatus.get(0);
|
|
// Lanes
|
|
for (int i=0; i<etdStatus.llane.size(); i++)
|
{
|
int totalMeasurementsLane = etdStatus.llane.get(i).totalMeasurements;
|
int correctMeasurementsLane = etdStatus.llane.get(i).correctMeasurements;
|
int apuntes =0 ;
|
|
for (int j=1; j<lstatus.size(); j++)
|
{
|
try
|
{
|
totalMeasurementsLane += lstatus.get(j).llane.get(i).totalMeasurements;
|
correctMeasurementsLane += lstatus.get(j).llane.get(i).correctMeasurements;
|
// totalMeasurementsLane += lstatus.get(j).llane.get(i).totalMeasurements;
|
// totalMeasurementsLane = totalMeasurements;
|
// correctMeasurementsLane += lstatus.get(j).llane.get(i).correctMeasurements;
|
// correctMeasurementsLane = lstatus.get(j).llane.get(i).correctMeasurements;
|
|
if (lstatus.get(j).llane.get(i).correctMeasurements > 0)
|
{
|
apuntes = apuntes + 1;
|
etdStatus.llane.get(i).counting += lstatus.get(j).llane.get(i).counting;
|
etdStatus.llane.get(i).unclassified += lstatus.get(j).llane.get(i).unclassified;
|
etdStatus.llane.get(i).speed += (lstatus.get(j).llane.get(i).counting) * (lstatus.get(j).llane.get(i).speed);
|
etdStatus.llane.get(i).occupancy += (lstatus.get(j).llane.get(i).counting) * (lstatus.get(j).llane.get(i).occupancy);
|
|
for (int k=0; k<etdStatus.llane.get(i).lengths.length; k++)
|
{
|
etdStatus.llane.get(i).lengths[k] += lstatus.get(j).llane.get(i).lengths[k];
|
}
|
|
for (int k=0; k<etdStatus.llane.get(i).speeds.length; k++)
|
{
|
etdStatus.llane.get(i).speeds[k] += lstatus.get(j).llane.get(i).speeds[k];
|
}
|
|
for (int k=0; k<etdStatus.llane.get(i).speedxlength.length; k++)
|
{
|
for (int l=0; l<etdStatus.llane.get(i).speedxlength[k].length; l++)
|
{
|
etdStatus.llane.get(i).speedxlength[k][l] += lstatus.get(j).llane.get(i).speedxlength[k][l];
|
}
|
}
|
}
|
}
|
catch (Exception e)
|
{
|
}
|
}
|
|
|
// totalMeasurements += totalMeasurementsLane;
|
correctMeasurements = Math.max(correctMeasurements, correctMeasurementsLane);
|
|
if (apuntes > 0)
|
{
|
if (etdStatus.llane.get(i).counting > 0)
|
{
|
// etdStatus.llane.get(i).speed /= apuntes;
|
// etdStatus.llane.get(i).occupancy /= apuntes;
|
etdStatus.llane.get(i).speed /= etdStatus.llane.get(i).counting;
|
etdStatus.llane.get(i).occupancy /= etdStatus.llane.get(i).counting;
|
}
|
|
etdStatus.llane.get(i).speed = (int)(etdStatus.llane.get(i).speed);
|
int occupancy = (int)(etdStatus.llane.get(i).occupancy*10);
|
etdStatus.llane.get(i).occupancy = (float)((float)occupancy / 10f);
|
}
|
|
int length = (int)(etdStatus.llane.get(i).length*10);
|
etdStatus.llane.get(i).length = (double)((double)length / 10d);
|
int distance = (int)(etdStatus.llane.get(i).distance*10);
|
etdStatus.llane.get(i).distance = (double)((double)distance / 10d);
|
|
// Write status lane
|
|
try
|
{
|
EtdStatusLane statusLane = etdStatus.llane.get(i);
|
statusLane.correctMeasurements = correctMeasurementsLane;
|
statusLane.totalMeasurements = totalMeasurementsLane;
|
lEtdStatus[position].llane.add(statusLane);
|
}
|
catch (Exception e)
|
{
|
}
|
}
|
|
|
|
|
// Sections
|
|
for (int i=0; i<etdStatus.lsection.size(); i++)
|
{
|
// int totalMeasurementsSection = etdStatus.lsection.get(i).totalMeasurements;
|
int totalMeasurementsSection = etdStatus.lsection.get(i).totalMeasurements;
|
int correctMeasurementsSection = etdStatus.lsection.get(i).correctMeasurements;
|
int apuntes = 0;
|
|
for (int j=1; j<lstatus.size(); j++)
|
{
|
try
|
{
|
totalMeasurementsSection += lstatus.get(j).lsection.get(i).totalMeasurements;
|
correctMeasurementsSection += lstatus.get(j).lsection.get(i).correctMeasurements;
|
|
if (lstatus.get(j).lsection.get(i).correctMeasurements > 0)
|
{
|
apuntes = apuntes + 1;
|
etdStatus.lsection.get(i).counting += lstatus.get(j).lsection.get(i).counting;
|
etdStatus.lsection.get(i).unclassified += lstatus.get(j).lsection.get(i).unclassified;
|
etdStatus.lsection.get(i).speed += (lstatus.get(j).lsection.get(i).counting) * (lstatus.get(j).lsection.get(i).speed);
|
etdStatus.lsection.get(i).occupancy += (lstatus.get(j).lsection.get(i).counting) * (lstatus.get(j).lsection.get(i).occupancy);
|
|
for (int k=0; k<etdStatus.lsection.get(i).lengths.length; k++)
|
{
|
etdStatus.lsection.get(i).lengths[k] += lstatus.get(j).lsection.get(i).lengths[k];
|
}
|
|
for (int k=0; k<etdStatus.lsection.get(i).speeds.length; k++)
|
{
|
etdStatus.lsection.get(i).speeds[k] += lstatus.get(j).lsection.get(i).speeds[k];
|
}
|
|
for (int k=0; k<etdStatus.lsection.get(i).speedxlength.length; k++)
|
{
|
for (int l=0; l<etdStatus.lsection.get(i).speedxlength[k].length; l++)
|
{
|
etdStatus.lsection.get(i).speedxlength[k][l] += lstatus.get(j).lsection.get(i).speedxlength[k][l];
|
}
|
}
|
}
|
}
|
catch (Exception e)
|
{
|
}
|
}
|
|
|
// totalMeasurements += totalMeasurementsSection;
|
correctMeasurements += correctMeasurementsSection;
|
|
if (apuntes > 0)
|
{
|
if (etdStatus.lsection.get(i).counting > 0)
|
{
|
etdStatus.lsection.get(i).speed /= etdStatus.lsection.get(i).counting;
|
etdStatus.lsection.get(i).occupancy /= etdStatus.lsection.get(i).counting;
|
}
|
|
etdStatus.lsection.get(i).speed = (int)(etdStatus.lsection.get(i).speed);
|
int occupancy = (int)(etdStatus.lsection.get(i).occupancy*10);
|
etdStatus.lsection.get(i).occupancy = (float)((float)occupancy / 10f);
|
}
|
|
int length = (int)(etdStatus.lsection.get(i).length*10);
|
etdStatus.lsection.get(i).length = (double)((double)length / 10d);
|
int distance = (int)(etdStatus.lsection.get(i).distance*10);
|
etdStatus.lsection.get(i).distance = (double)((double)distance / 10d);
|
|
// Write status section
|
|
try
|
{
|
EtdStatusLane statusSection = etdStatus.lsection.get(i);
|
statusSection.correctMeasurements = correctMeasurementsSection;
|
statusSection.totalMeasurements = totalMeasurementsSection;
|
lEtdStatus[position].lsection.add(statusSection);
|
}
|
catch (Exception e)
|
{
|
}
|
}
|
|
|
// Totals
|
|
{
|
|
int apuntes = 0;
|
|
for (int j=1; j<lstatus.size(); j++)
|
{
|
try
|
{
|
etdStatus.total.totalMeasurements += lstatus.get(j).total.totalMeasurements;
|
etdStatus.total.correctMeasurements += lstatus.get(j).total.correctMeasurements;
|
|
if (lstatus.get(j).total.correctMeasurements > 0)
|
{
|
apuntes = apuntes + 1;
|
etdStatus.total.counting += lstatus.get(j).total.counting;
|
etdStatus.total.unclassified += lstatus.get(j).total.unclassified;
|
etdStatus.total.speed += (lstatus.get(j).total.counting) * (lstatus.get(j).total.speed);
|
etdStatus.total.occupancy += (lstatus.get(j).total.counting) * (lstatus.get(j).total.occupancy);
|
|
for (int k=0; k<etdStatus.total.lengths.length; k++)
|
{
|
etdStatus.total.lengths[k] += lstatus.get(j).total.lengths[k];
|
}
|
|
for (int k=0; k<etdStatus.total.speeds.length; k++)
|
{
|
etdStatus.total.speeds[k] += lstatus.get(j).total.speeds[k];
|
}
|
|
for (int k=0; k<etdStatus.total.speedxlength.length; k++)
|
{
|
for (int l=0; l<etdStatus.total.speedxlength[k].length; l++)
|
{
|
etdStatus.total.speedxlength[k][l] += lstatus.get(j).total.speedxlength[k][l];
|
}
|
}
|
}
|
}
|
catch (Exception e)
|
{
|
}
|
}
|
|
|
// Write totals
|
|
if (etdStatus.total != null)
|
{
|
if (apuntes > 0)
|
{
|
if (etdStatus.total.counting > 0)
|
{
|
etdStatus.total.speed /= etdStatus.total.counting;
|
etdStatus.total.occupancy /= etdStatus.total.counting;
|
}
|
|
etdStatus.total.speed = (int)etdStatus.total.speed;
|
int occupancy = (int)(etdStatus.total.occupancy*10);
|
etdStatus.total.occupancy = (float)((float)occupancy / 10f);
|
}
|
|
int length = (int)(etdStatus.total.length*10);
|
etdStatus.total.length = (double)((double)length / 10d);
|
int distance = (int)(etdStatus.total.distance*10);
|
etdStatus.total.distance = (double)((double)distance / 10d);
|
|
try
|
{
|
lEtdStatus[position].total = etdStatus.total;
|
}
|
catch (Exception e)
|
{
|
}
|
}
|
}
|
|
}
|
}
|
|
}
|
