public async Task Consume(ConsumeContext <CreateBoxCommand> context)
{
using (var contextFScope = _dbContextScopeFactory.Create())
{
_db = contextFScope.DbContexts.Get <SmartFleetObjectContext>();
var item = await _db.Boxes.FirstOrDefaultAsync(b => b.Imei == context.Message.Imei);
if (item != null)
{
return;
}
var box = new Box();
box.Id = Guid.NewGuid();
box.BoxStatus = BoxStatus.WaitPreparation;
box.CreationDate = DateTime.UtcNow;
box.Icci = String.Empty;
box.PhoneNumber = String.Empty;
box.Vehicle = null;
box.Imei = context.Message.Imei;
box.SerialNumber = String.Empty;
try
{
_db.Boxes.Add(box);
await contextFScope.SaveChangesAsync().ConfigureAwait(false);
}
catch (Exception e)
{
Trace.WriteLine(e);
throw;
}
}
}
public async Task <bool> AddNewVehicleAsync(Vehicle vehicle)
{
try
{
using (var contextFScope = _dbContextScopeFactory.Create())
{
_db = contextFScope.DbContexts.Get <SmartFleetObjectContext>();
vehicle.MileStoneUpdateUtc = DateTime.Now;
if (vehicle.Box_Id.HasValue)
{
vehicle.VehicleStatus = VehicleStatus.Active;
}
var boxId = vehicle.Box_Id;
var box = await _db.Boxes.FirstOrDefaultAsync(b => b.Id == boxId).ConfigureAwait(false);
if (box != null)
{
box.VehicleId = vehicle.Id;
box.BoxStatus = BoxStatus.Valid;
_db.Entry(box).State = EntityState.Modified;
}
_db.Vehicles.Add(vehicle);
await contextFScope.SaveChangesAsync().ConfigureAwait(false);
return(true);
}
}
catch (Exception e)
{
Debug.WriteLine(e.Message);
return(false);
}
}
public async Task <List <PositionViewModel> > GetLastVehiclePositionAsync(string userName)
{
using (var contextFScope = _dbContextScopeFactory.Create())
{
_objectContext = contextFScope.DbContexts.Get <SmartFleetObjectContext>();
var positions = new List <PositionViewModel>();
var query = await(from customer in _objectContext.Customers
join account in _objectContext.UserAccounts on customer.Id equals account.CustomerId
where account.UserName == userName
join vcl in _objectContext.Vehicles on customer.Id equals vcl.CustomerId into vehicleJoin
from vehicle in vehicleJoin
join box in _objectContext.Boxes on vehicle.Id equals box.VehicleId into boxesJoin
from box in boxesJoin
join position in _objectContext.Positions on box.Id equals position.Box_Id
group position by position.Box_Id into g
select new { boxId = g.Key, Position = g.OrderByDescending(x => x.Timestamp).Select(x => new PositionViewModel {
Address = x.Address, Latitude = x.Lat, Longitude = x.Long
}).FirstOrDefault() }).ToArrayAsync().ConfigureAwait(false);
foreach (var item in query)
{
var vehicle = await _objectContext.Boxes.Include(x => x.Vehicle).Where(x => x.Id == item.boxId).Select(x => new { x.Vehicle.VehicleType, x.Vehicle.VehicleName, x.Vehicle.CustomerId, x.VehicleId }).FirstOrDefaultAsync().ConfigureAwait(false);
var pos = new PositionViewModel(vehicle?.VehicleName, vehicle?.CustomerId.ToString(), vehicle.VehicleType, vehicle?.VehicleId.ToString());
pos.Address = item.Position.Address;
pos.Latitude = item.Position.Latitude;
pos.Longitude = item.Position.Longitude;
positions.Add(pos);
}
return(positions);
}
}
private async Task <Box> Item(TLGpsDataEvent context)
{
using (var contextFScope = _dbContextScopeFactory.Create())
{
_db = contextFScope.DbContexts.Get <SmartFleetObjectContext>();
return(await _db.Boxes.SingleOrDefaultAsync(b => b.Imei == context.Imei));
}
}
private async Task <Box> Getbox(CreateTeltonikaGps context)
{
using (var contextFScope = DbContextScopeFactory.Create())
{
_db = contextFScope.DbContexts.Get <SmartFleetObjectContext>();
return(await _db.Boxes.Include(x => x.Vehicle).SingleOrDefaultAsync(b => b.Imei == context.Imei));
}
}
public IEnumerable <FuelConsumption> GetFuelConsumptionList(DateTime start, DateTime end, Guid vehicleId)
{
using (var contextFScope = _dbContextScopeFactory.Create())
{
_db = contextFScope.DbContexts.Get <SmartFleetObjectContext>();
return(FuelConsumptions(start, end, vehicleId));
}
}
public async Task <Vehicle[]> GetVehiclesFromCustomerAsync(Guid customerId)
{
using (var contextFScope = _dbContextScopeFactory.Create())
{
_db = contextFScope.DbContexts.Get <SmartFleetObjectContext>();
return(await _db.Vehicles.Where(x => x.CustomerId == customerId).ToArrayAsync().ConfigureAwait(false));
}
}
public async Task <Vehicle> GetVehicleByIdAsync(Guid id)
{
using (var contextFScope = _dbContextScopeFactory.Create())
{
_db = contextFScope.DbContexts.Get <SmartFleetObjectContext>();
return(await _db.Vehicles.FindAsync(id).ConfigureAwait(false));
}
}
public async Task Consume(ConsumeContext <CreateTk103Gps> context)
{
using (var contextFScope = _dbContextScopeFactory.Create())
{
_db = contextFScope.DbContexts.Get <SmartFleetObjectContext>();
var box = await _db.Boxes.FirstOrDefaultAsync(x => x.SerialNumber == context.Message.SerialNumber)
.ConfigureAwait(false);
if (box == null)
{
box = new Box();
box.Id = Guid.NewGuid();
box.BoxStatus = BoxStatus.Prepared;
box.CreationDate = DateTime.UtcNow;
box.LastGpsInfoTime = context.Message.TimeStampUtc;
box.Icci = String.Empty;
box.PhoneNumber = String.Empty;
box.Vehicle = null;
box.Imei = context.Message.IMEI;
box.SerialNumber = context.Message.SerialNumber;
try
{
_db.Boxes.Add(box);
}
catch (Exception e)
{
Trace.WriteLine(e);
}
}
if (box.BoxStatus == BoxStatus.WaitInstallation)
{
box.BoxStatus = BoxStatus.Prepared;
}
box.LastGpsInfoTime = context.Message.TimeStampUtc;
var address = await _geoCodingService.ExecuteQuery(context.Message.Latitude, context.Message.Longitude);
Position position = new Position
{
Box_Id = box.Id,
Altitude = 0,
Direction = 0,
Lat = context.Message.Latitude,
Long = context.Message.Longitude,
Speed = context.Message.Speed,
Id = Guid.NewGuid(),
Priority = 0,
Satellite = 0,
Timestamp = context.Message.TimeStampUtc,
Address = address.display_name,
MotionStatus = (int)context.Message.Speed > 2? MotionStatus.Moving: MotionStatus.Stopped
};
_db.Positions.Add(position);
await contextFScope.SaveChangesAsync().ConfigureAwait(false);
}
}
public IQueryable <Vehicle> GetVehiclesOfCustomer(Guid customerId)
{
var contextFScope = _dbContextScopeFactory.Create();
_db = contextFScope.DbContexts.Get <SmartFleetObjectContext>();
return(_db.Vehicles.Where(v => v.CustomerId == customerId)
.Include("Brand")
.Include("Model"));
}
public IQueryable <Vehicle> GetAllVehicles()
{
var contextFScope = _dbContextScopeFactory.Create();
_db = contextFScope.DbContexts.Get <SmartFleetObjectContext>();
return(_db.Vehicles
.Include("Brand")
.Include("Model"));
}
public async Task <Vehicle> GetVehicleByIdWithDetailAsync(Guid id)
{
using (var contextFScope = _dbContextScopeFactory.Create())
{
_db = contextFScope.DbContexts.Get <SmartFleetObjectContext>();
return(await _db.Vehicles.Include(x => x.Brand).Include(x => x.Customer).Include(x => x.Model)
.Include(x => x.Boxes).FirstOrDefaultAsync(v => v.Id == id).ConfigureAwait(false));
}
}
public async Task <List <Vehicle> > GetAllVehiclesOfCustomerAsync(Guid customerId)
{
using (var contextFScope = _dbContextScopeFactory.Create())
{
_db = contextFScope.DbContexts.Get <SmartFleetObjectContext>();
return(await _db.Vehicles
.Where(v => v.CustomerId == customerId)
.ToListAsync().ConfigureAwait(false));
}
}
private async Task <PositionQuery> GetLastPostion(Guid boxId)
{
using (var contextFScope = DbContextScopeFactory.Create())
{
_db = contextFScope.DbContexts.Get <SmartFleetObjectContext>();
return(await _db.Positions.OrderByDescending(x => x.Timestamp).Where(x => x.Box_Id == boxId).Select(p => new PositionQuery()
{
VehicleId = p.Box.VehicleId, Lat = p.Lat, Long = p.Long
}).FirstOrDefaultAsync());
}
}
public AddVehicleViewModel(SmartFleetObjectContext context)
{
_context = context;
_context.Configuration.ProxyCreationEnabled = false;
// Brand_Id = null;
VehicleTypes = new List <KeyValuePair <int, string> >();
foreach (var vehicleType in Enum.GetValues(typeof(VehicleType)).Cast <VehicleType>())
{
VehicleTypes.Add(new KeyValuePair <int, string>((int)vehicleType, vehicleType.ToString()));
}
}
private async Task <Box> GetBoxAsync(CreateTeltonikaGps context)
{
using (var contextFScope = DbContextScopeFactory.Create())
{
_db = contextFScope.DbContexts.Get <SmartFleetObjectContext>();
var box = await _db.Boxes.Include(x => x.Vehicle).FirstOrDefaultAsync(b => b.Imei == context.Imei)
.ConfigureAwait(false);
return(box);
}
}
/// <summary>
///
/// </summary>
/// <param name="objectContext"></param>
/// <param name="mapper"></param>
/// <param name="positionService"></param>
/// <param name="customerService"></param>
/// <param name="vehicleService"></param>
/// <param name="pdfService"></param>
public VehicleReportController(SmartFleetObjectContext objectContext,
IMapper mapper,
IPositionService positionService,
ICustomerService customerService,
IVehicleService vehicleService,
IPdfService pdfService) : base(objectContext, mapper)
{
_positionService = positionService;
_customerService = customerService;
_vehicleService = vehicleService;
_pdfService = pdfService;
}
/// <summary>
///
/// </summary>
/// <param name="positionRepository"></param>
/// <param name="geoCodingService"></param>
/// <param name="objectContext"></param>
/// <param name="gpsDeviceRepository"></param>
/// <param name="vehicleRepository"></param>
public PositionService(IRepository <Position> positionRepository,
ReverseGeoCodingService geoCodingService,
SmartFleetObjectContext objectContext,
IRepository <Box> gpsDeviceRepository,
IRepository <Vehicle> vehicleRepository)
{
_positionRepository = positionRepository;
_geoCodingService = geoCodingService;
_objectContext = objectContext;
_gpsDeviceRepository = gpsDeviceRepository;
_vehicleRepository = vehicleRepository;
}
public async Task <List <Vehicle> > GetAllvehiclesQuery()
{
using (var contextFScope = _dbContextScopeFactory.Create())
{
_db = contextFScope.DbContexts.Get <SmartFleetObjectContext>();
return(await _db.Vehicles
.Include("Brand")
.Include("Model")
.Include("Customer")
.ToListAsync());
}
}
public async Task <List <Position> > GetLastVehiclPosition(string userName)
{
using (var contextFScope = _dbContextScopeFactory.Create())
{
_objectContext = contextFScope.DbContexts.Get <SmartFleetObjectContext>();
var positions = new List <Position>();
// ReSharper disable once ComplexConditionExpression
var vehicles = await _objectContext.UserAccounts
.Include(x => x.Customer)
.Include(x => x.Customer.Vehicles)
.Where(x => x.UserName == userName)
.SelectMany(x => x.Customer.Vehicles.Where(v => v.VehicleStatus == VehicleStatus.Active).Select(v => v))
.ToArrayAsync();
if (!vehicles.Any())
{
return(positions);
}
foreach (var vehicle in vehicles)
{
var boxes = await _objectContext
.Boxes
.Where(b => b.VehicleId == vehicle.Id &&
b.BoxStatus == BoxStatus.Valid)
.Select(x => x.Id)
.ToArrayAsync();
if (!boxes.Any())
{
continue;
}
foreach (var geDevice in boxes)
{
var position = await _objectContext
.Positions
.OrderByDescending(x => x.Timestamp)
.FirstOrDefaultAsync(p => p.Box_Id == geDevice);
if (position == null)
{
continue;
}
position.Vehicle = vehicle;
await _geoCodingService.ReverseGeoCoding(position);
positions.Add(position);
}
}
return(positions);
}
}
public PositionViewModel(CreateTeltonikaGps tk103Gps, Vehicle vehicle, SmartFleetObjectContext db, Guid boxId)
{
// var dir = GetDirection(tk103Gps, db, boxId);
Latitude = tk103Gps.Lat;
Longitude = tk103Gps.Long;
Address = tk103Gps.Address;
IMEI = tk103Gps.Imei;
// SerialNumber = tk103Gps.s;
//Direction = tk103Gps.Address
Speed = tk103Gps.Speed;
VehicleName = vehicle.VehicleName;
VehicleId = vehicle.Id.ToString();
CustomerName = vehicle.Customer?.Name;
TimeStampUtc = tk103Gps.Timestamp;
//SetVehicleImage(vehicle ,dir);
}
public async Task Consume(ConsumeContext <TLExcessSpeedEvent> context)
{
//throw new NotImplementedException();
using (var contextFScope = _dbContextScopeFactory.Create())
{
_db = contextFScope.DbContexts.Get <SmartFleetObjectContext>();
_db.VehicleAlerts.Add(new VehicleAlert
{
Id = Guid.NewGuid(),
VehicleEvent = context.Message.VehicleEventType,
Speed = Convert.ToInt32(context.Message.Speed),
EventUtc = context.Message.EventUtc,
CustomerId = (Guid)context.Message.CustomerId,
VehicleId = context.Message.VehicleId
});
await contextFScope.SaveChangesAsync().ConfigureAwait(false);
}
}
public async Task Consume(ConsumeContext <CreateTeltonikaGps> context)
{
try
{
var item = await Item(context.Message).ConfigureAwait(false);
if (item != null)
{
using (var contextFScope = _dbContextScopeFactory.Create())
{
_db = contextFScope.DbContexts.Get <SmartFleetObjectContext>();
var position = new Position();
position.Box_Id = item?.Id;
position.Altitude = context.Message.Altitude;
position.Direction = context.Message.Direction;
position.Lat = context.Message.Lat;
position.Long = context.Message.Long;
position.Speed = context.Message.Speed;
position.Id = Guid.NewGuid();
position.Priority = context.Message.Priority;
position.Satellite = context.Message.Satellite;
position.Timestamp = context.Message.DateTimeUtc;
Semaphore.WaitOne();
var address = await _geoCodingService.ExecuteQueryAsync(context.Message.Lat, context.Message.Long).ConfigureAwait(false);
position.Address = address.display_name;
Semaphore.Release();
position.MotionStatus = !context.Message.IsStop ? MotionStatus.Moving : MotionStatus.Stopped;
_db.Positions.Add(position);
await contextFScope.SaveChangesAsync().ConfigureAwait(false);
}
}
}
catch (Exception e)
{
Trace.WriteLine(e);
//throw;
}
// return Task.FromResult(false);
}
public async Task <List <Position> > GetVehiclePositionsByPeriodAsync(Guid vehicleId, DateTime startPeriod, DateTime endPeriod, string timeZoneInfo = null)
{
using (var contextFScope = _dbContextScopeFactory.Create())
{
_objectContext = contextFScope.DbContexts.Get <SmartFleetObjectContext>();
var box = await _objectContext
.Boxes
.Select(x => new { x.Id, x.VehicleId })
.FirstOrDefaultAsync(v => v.VehicleId == vehicleId)
.ConfigureAwait(false);
if (box == null)
{
return(new List <Position>());
}
if (box.Id == Guid.Empty)
{
return(new List <Position>());
}
var positions = await
_objectContext
.Positions
.Where(p => p.Box_Id == box.Id && p.Timestamp >= startPeriod && p.Timestamp <= endPeriod)
.ToListAsync()
.ConfigureAwait(false);
if (!string.IsNullOrEmpty(timeZoneInfo))
{
foreach (var position in positions)
{
position.Timestamp = position.Timestamp.ConvertToCurrentTimeZone(timeZoneInfo);
}
}
return(positions);
}
}
public async Task Consume(ConsumeContext <TlFuelEevents> context)
{
//await _semaphore.WaitAsync();
using (var contextFScope = _dbContextScopeFactory.Create())
{
_db = contextFScope.DbContexts.Get <SmartFleetObjectContext>();
var fuelRecordMsg = context.Message.Events.OrderBy(x => x.DateTimeUtc).Last();
var lastRecord = await _db.FuelConsumptions.OrderByDescending(x => x.DateTimeUtc)
// ReSharper disable once TooManyChainedReferences
.FirstOrDefaultAsync(x => x.VehicleId == fuelRecordMsg.VehicleId);
var entity = SetFuelConsumptionobject(fuelRecordMsg);
// ReSharper disable once ComplexConditionExpression
if (lastRecord != null && fuelRecordMsg.MileStoneCalculated || lastRecord == null)
{
if (lastRecord != null)
{
var firstPos = context.Message.TlGpsDataEvents.First();
foreach (var p in context.Message.TlGpsDataEvents.Skip(1))
{
entity.Milestone +=
Math.Round(GeofenceHelper.CalculateDistance(firstPos.Lat, firstPos.Long, p.Lat,
p.Long));
firstPos = p;
}
}
}
else if (!fuelRecordMsg.MileStoneCalculated)
{
entity.TotalFuelConsumed = fuelRecordMsg.FuelConsumption;
}
_db.FuelConsumptions.Add(entity);
await contextFScope.SaveChangesAsync().ConfigureAwait(false);
// _semaphore.Release();
}
}
public async Task Consume(ConsumeContext <TLGpsDataEvent> context)
{
try
{
var item = await Item(context.Message);
if (item != null)
{
using (var contextFScope = _dbContextScopeFactory.Create())
{
_db = contextFScope.DbContexts.Get <SmartFleetObjectContext>();
var position = new Position();
position.Box_Id = item?.Id;
position.Altitude = context.Message.Altitude;
position.Direction = context.Message.Direction;
position.Lat = context.Message.Lat;
position.Long = context.Message.Long;
position.Speed = context.Message.Speed;
position.Address = context.Message.Address;
position.Id = Guid.NewGuid();
position.Priority = context.Message.Priority;
position.Satellite = context.Message.Satellite;
position.Timestamp = context.Message.DateTimeUtc;
position.MotionStatus = context.Message.Speed > 0.0 ? MotionStatus.Moving : MotionStatus.Stopped;
item.LastGpsInfoTime = context.Message.DateTimeUtc;
_db.Positions.Add(position);
await contextFScope.SaveChangesAsync().ConfigureAwait(false);
}
}
}
catch (Exception e)
{
Trace.WriteLine(e);
//throw;
}
}
public async Task <List <Position> > GetVehiclePositionsByPeriod(Guid vehivleId, DateTime startPeriod, DateTime endPeriod)
{
using (var contextFScope = _dbContextScopeFactory.Create())
{
_objectContext = contextFScope.DbContexts.Get <SmartFleetObjectContext>();
var vehicle = await _objectContext.Vehicles.Include(v => v.Boxes).FirstOrDefaultAsync(v => v.Id == vehivleId).ConfigureAwait(false);
if (vehicle == null)
{
return(new List <Position>());
}
var box = vehicle.Boxes.FirstOrDefault();
if (box == null)
{
return(new List <Position>());
}
var positions =
_objectContext
.Positions
.Where(p => p.Box_Id == box.Id && p.Timestamp >= startPeriod && p.Timestamp <= endPeriod)
.ToList();
return(positions);
}
}
public double GetFuelConsumptionByPeriod(DateTime start, DateTime end, Guid vehicleId, double totalDistance)
{
var contextFScope = _dbContextScopeFactory.Create();
_db = contextFScope.DbContexts.Get <SmartFleetObjectContext>();
var l100Fuel = default(double);
var fuelRecords = FuelConsumptions(start, end, vehicleId);
if (fuelRecords.Count <= 0)
{
return(l100Fuel);
}
var nextRecord = GetNextFuelConsumption(end, vehicleId);
if (nextRecord != null)
{
fuelRecords.Add(nextRecord);
}
//Gestion du nombre de litres consommés qui revient à 0 à chaque ignition OFF
var vehicleFuelZeroDetected = false;
var vehicleFuelConsumedReset = false;
var previousValidFuelConsumed = default(Int32);
var previousFuelConsumed = fuelRecords.First().FuelUsed;
var fuel = 0;
foreach (var record in fuelRecords)
{
//Si on détecté un retour à zéro et qu'une nouvelle valeure positif arrive
if (vehicleFuelZeroDetected && record.FuelUsed > 0)
{
//Détection d'un véhicule dont le nombre de litres de consommés revient à zéro à chaque ignition off
if (record.FuelUsed < previousValidFuelConsumed)
{
vehicleFuelConsumedReset = true;
}
//Sinon il ne s'agissait que d'un pic négatif à zéro mais le nombre de litres consommés évolue normalement
else
{
fuel -= previousValidFuelConsumed;
}
vehicleFuelZeroDetected = false;
}
//Si le nombre de litres consommés diminue
else if (previousFuelConsumed - 5 > record.FuelUsed)
{
vehicleFuelZeroDetected = true;
previousValidFuelConsumed = previousFuelConsumed;
fuel += previousFuelConsumed;
}
previousFuelConsumed = record.FuelUsed;
}
//S'il s'agit un véhicule dont le nombre total de litres consommés revient à zéro à chque ignition OFF
if (vehicleFuelConsumedReset)
{
fuel += fuelRecords.Last().FuelUsed - fuelRecords.First().FuelUsed;
}
else
{
fuel = fuelRecords.Last(p => p.FuelUsed > 0).FuelUsed -
fuelRecords.First(p => p.FuelUsed > 0).FuelUsed;
}
// ReSharper disable once ComplexConditionExpression
l100Fuel = Math.Round(fuel * 100 / totalDistance, 1);
return(l100Fuel);
}
public CustomerController(SmartFleetObjectContext objectContext, IMapper mapper, ICustomerService customerService, DataTablesLinqQueryBulider queryBuilder) : base(objectContext, mapper)
{
_customerService = customerService;
_queryBuilder = queryBuilder;
}
public GpsDeviceController(SmartFleetObjectContext objectContext, IMediator mediator) : base(objectContext, mediator)
{
}
