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) { }