using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Data;
using System.Data.OleDb;
using System.Globalization;
using System.Text;
using ThinkGeo.MapSuite.Core;
namespace ThinkGeo.MapSuite.VehicleTracking
{
public class TrackingAccessProvider : TrackingDataProvider
{
private OleDbConnection dataConnection;
public TrackingAccessProvider(string databaseFilePath)
{
string connectionString = string.Format(CultureInfo.InvariantCulture, "Provider=Microsoft.Jet.OLEDB.4.0; Data Source='{0}'", databaseFilePath);
dataConnection = new OleDbConnection(connectionString);
}
public override Dictionary GetCurrentVehicles(DateTime currentTime)
{
Dictionary vehiclesList = new Dictionary();
DataSet vehiclesDataSet = ExecuteQuery("Select * from Vehicle");
TimeSpan trackHistoryVehicleTimeSpan = TimeSpan.FromHours(8);
foreach (DataRow row in vehiclesDataSet.Tables[0].Rows)
{
int vehicleId = Convert.ToInt32(row["VehicleId"], CultureInfo.InvariantCulture);
Vehicle vehicle = GetCurrentVehicle(vehicleId, currentTime, trackHistoryVehicleTimeSpan);
vehiclesList.Add(vehicle.Id, vehicle);
}
return vehiclesList;
}
private Vehicle GetCurrentVehicle(int vehicleId, DateTime currentTime, TimeSpan trackHistoryVehicleTimeSpan)
{
string sql = "SELECT A.VehicleName, A.VehicleID, A.VehicleIconVirtualPath, B.Longitude, B.Latitude, B.[Date], B.Speed FROM (Vehicle A LEFT OUTER JOIN Location B ON A.VehicleID = B.VehicleID) WHERE (A.VehicleID = {0}) AND (B.[Date] <= #{1}# and B.[Date]>=#{2}#) ORDER BY A.VehicleID, B.[Date] DESC";
DateTime trackStartTime = currentTime.AddTicks(-trackHistoryVehicleTimeSpan.Ticks);
sql = String.Format(CultureInfo.InvariantCulture, sql, vehicleId, currentTime.ToString(CultureInfo.InvariantCulture), trackStartTime.ToString(CultureInfo.InvariantCulture));
Vehicle currentVechicle = new Vehicle(vehicleId);
DataSet currentLocations = null;
try
{
// Get the locations from current time back to the passed time span
currentLocations = ExecuteQuery(sql);
Collection historySpeeds = new Collection();
for (int rowIndex = 0; rowIndex < currentLocations.Tables[0].Rows.Count; rowIndex++)
{
DataRow dataRow = currentLocations.Tables[0].Rows[rowIndex];
currentVechicle.VehicleIconVirtualPath = "Images/" + dataRow["VehicleIconVirtualPath"].ToString();
double latitude = Convert.ToDouble(dataRow["Latitude"], CultureInfo.InvariantCulture);
double longitude = Convert.ToDouble(dataRow["Longitude"], CultureInfo.InvariantCulture);
double speed = Convert.ToDouble(dataRow["Speed"], CultureInfo.InvariantCulture);
DateTime dateTime = Convert.ToDateTime(dataRow["Date"], CultureInfo.InvariantCulture);
Location currentLocation = new Location(longitude, latitude, speed, dateTime);
historySpeeds.Add(speed);
if (rowIndex == 0)
{
string vehicleName = dataRow["VehicleName"].ToString();
currentVechicle.Location = currentLocation;
currentVechicle.Id = vehicleId;
currentVechicle.VehicleName = vehicleName;
}
else
{
currentVechicle.HistoryLocations.Add(currentLocation);
}
}
}
finally
{
if (currentLocations != null)
{
currentLocations.Dispose();
}
}
return currentVechicle;
}
public override Collection GetSpatialFences()
{
Collection spatialFences = new Collection();
DataSet dataSet = ExecuteQuery("Select * from SpatialFence");
foreach (DataRow row in dataSet.Tables[0].Rows)
{
string wkt = row["FenceGeometry"].ToString();
string id = row["FeatureID"].ToString();
spatialFences.Add(new Feature(wkt, id));
}
return spatialFences;
}
public override void DeleteSpatialFences(IEnumerable features)
{
StringBuilder deleteFeatureIds = new StringBuilder();
foreach (Feature deleteFeature in features)
{
deleteFeatureIds.AppendFormat(CultureInfo.InvariantCulture, "'{0}',", deleteFeature.Id);
}
string sql = String.Format(CultureInfo.InvariantCulture, "DELETE FROM SpatialFence WHERE (FeatureID IN ({0}))", deleteFeatureIds.ToString().TrimEnd(','));
ExecuteNonQuery(sql);
}
public override int UpdateSpatialFenceByFeature(Feature feature)
{
int updatedSpatialFenceCount = ExecuteNonQuery(String.Format(CultureInfo.InvariantCulture, "UPDATE SpatialFence SET FenceGeometry = '{0}' WHERE (FeatureID = '{1}')", feature.GetWellKnownText(), feature.Id));
return updatedSpatialFenceCount;
}
public override void InsertSpatialFence(Feature feature)
{
ExecuteNonQuery(String.Format(CultureInfo.InvariantCulture, "Insert into SpatialFence(FenceGeometry,FeatureID) values('{0}','{1}')", feature.GetWellKnownText(), feature.Id));
}
private DataSet ExecuteQuery(string selectCommandText)
{
OleDbDataAdapter dataAdapter = null;
try
{
dataAdapter = new OleDbDataAdapter(selectCommandText, dataConnection);
dataConnection.Open();
DataSet dataSet = new DataSet();
dataSet.Locale = CultureInfo.InvariantCulture;
dataAdapter.Fill(dataSet);
return dataSet;
}
finally
{
if (dataAdapter != null) { dataAdapter.Dispose(); }
if (dataConnection != null) { dataConnection.Close(); }
}
}
private int ExecuteNonQuery(string cmdText)
{
OleDbCommand dataCommand = null;
int affectedRowNumber = 0;
try
{
dataCommand = new OleDbCommand(cmdText, dataConnection);
dataConnection.Open();
affectedRowNumber = dataCommand.ExecuteNonQuery();
}
finally
{
if (dataCommand != null) { dataCommand.Dispose(); }
if (dataConnection != null) { dataConnection.Close(); }
}
return affectedRowNumber;
}
~TrackingAccessProvider()
{
Dispose(false);
}
public override void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
private void Dispose(bool flag)
{
if (flag)
{
if (dataConnection != null)
{
dataConnection.Close();
dataConnection.Dispose();
dataConnection = null;
}
}
}
}
}
====TrackingDataProvider.cs====
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using ThinkGeo.MapSuite.Core;
namespace ThinkGeo.MapSuite.VehicleTracking
{
public abstract class TrackingDataProvider : IDisposable
{
public abstract Dictionary GetCurrentVehicles(DateTime currentTime);
public abstract Collection GetSpatialFences();
public abstract void DeleteSpatialFences(IEnumerable excludeFeatures);
public abstract int UpdateSpatialFenceByFeature(Feature feature);
public abstract void InsertSpatialFence(Feature feature);
public abstract void Dispose();
}
}
====Location.cs====
using System;
using ThinkGeo.MapSuite.Core;
namespace ThinkGeo.MapSuite.VehicleTracking
{
///
/// This class specify the basic information for a location.
///
public class Location
{
public Location()
: this(0, 0, 0, DateTime.Now)
{ }
public Location(double longitude, double latitude, double speed, DateTime dateTime)
{
this.Longitude = longitude;
this.Latitude = latitude;
this.Speed = speed;
this.DateTime = dateTime;
}
public double Longitude { get; set; }
public double Latitude { get; set; }
public double Speed { get; set; }
public DateTime DateTime { get; set; }
public PointShape GetLocationPointShape()
{
return new PointShape(Longitude, Latitude);
}
}
}
====Vehicle.cs====
using System.Collections.ObjectModel;
namespace ThinkGeo.MapSuite.VehicleTracking
{
///
/// This class stands for a vehicle.
///
public class Vehicle
{
private int id;
private Location location;
private string vehicleName;
private string vehicleIconVirtualPath;
private bool isInFence;
private string motionStateIconVirtualPath;
private Collection historyLocations;
private Vehicle()
: this(0)
{ }
public Vehicle(int id)
{
this.Id = id;
this.VehicleName = string.Empty;
this.Location = new Location();
this.historyLocations = new Collection();
}
public int Id
{
get { return id; }
set { id = value; }
}
public Location Location
{
get { return location; }
set { location = value; }
}
public Collection HistoryLocations
{
get { return historyLocations; }
}
public string VehicleName
{
get { return vehicleName; }
set { vehicleName = value; }
}
public string VehicleIconVirtualPath
{
get { return vehicleIconVirtualPath; }
set { vehicleIconVirtualPath = value; }
}
public bool IsInFence
{
get { return isInFence; }
set { isInFence = value; }
}
public int SpeedDuration
{
get
{
int speedDuration = 0;
double lastSpeed = Location.Speed;
foreach (Location location in HistoryLocations)
{
if (location.Speed == lastSpeed)
{
speedDuration++;
}
else
{
break;
}
}
return speedDuration;
}
}
public string MotionStateIconVirtualPath
{
get
{
if (MotionState == VehicleMotionState.Idle)
{
motionStateIconVirtualPath = "Images/ball_gray.png";
}
else
{
motionStateIconVirtualPath = "Images/ball_green.png";
}
return motionStateIconVirtualPath;
}
}
///
/// If the Vehicle's speed is not 0 in the passed 4 minutes, we say it is in Motion.
///
/// State of current vehicle.
public VehicleMotionState MotionState
{
get
{
VehicleMotionState vehicleState = VehicleMotionState.Idle;
if (Location.Speed != 0)
{
vehicleState = VehicleMotionState.Motion;
}
else
{
int locationIndex = 0;
foreach (Location historyLocation in HistoryLocations)
{
if (locationIndex > 3)
{
break;
}
else if (historyLocation.Speed != 0)
{
vehicleState = VehicleMotionState.Motion;
break;
}
else
{
locationIndex++;
}
}
}
return vehicleState;
}
}
}
}
====VehicleMotionState.cs====
namespace ThinkGeo.MapSuite.VehicleTracking
{
///
/// This enumeration specifies the Possible states for Vehicles.
///
public enum VehicleMotionState
{
Motion = 0,
Idle = 1,
}
}
====JsonFeature.cs====
using System.Runtime.Serialization;
namespace ThinkGeo.MapSuite.VehicleTracking
{
[DataContract]
public class JsonFeature
{
private string id;
private string wkt;
public JsonFeature(string id, string wkt)
{
this.id = id;
this.wkt = wkt;
}
[DataMember(Name|= "id")]
public string Id
{
get { return id; }
set { id = value; }
}
[DataMember(Name|= "wkt")]
public string Wkt
{
get { return wkt; }
set { wkt = value; }
}
}
}