private async Task CheckVehiclesConnectivityAsync()
{
var vehicles = await _trackedVehicleRepository.GetAsync(_ => true)
.AnyContext();
var tasks = vehicles.Select(v => _pingSender.SendAsync(v.IPAddress, _options.Value.PingTimeout));
var results = await Task.WhenAll(tasks)
.AnyContext();
foreach (var r in results)
{
var vehicle = vehicles.FirstOrDefault(v => v.IPAddress == r.IPAddress);
if (vehicle == null) // vehicle is no longer tracked
{
_logger.LogInformation($"Vehicle with IP address '{r.IPAddress}' was not found");
continue;
}
var status = r.IPStatus == IPStatus.Success
? TrackedVehicleStatus.Connected
: TrackedVehicleStatus.Disconnected;
if (status == vehicle.Status)
{
continue;
}
var @event = new VehicleStatusChangedEvent(vehicle.Id, status);
await _busPublisher.PublishAsync(@event)
.AnyContext();
vehicle.SetConnectionStatus(status);
// Enhancement: use bulk update
await _trackedVehicleRepository.UpdateAsync(vehicle)
.AnyContext();
var history = new TrackingHistory(Guid.NewGuid().ToString(), vehicle.Id, status);
await _trackingHistoryRepository.AddAsync(history)
.AnyContext();
}
}
public async Task UpdateLocation(VehicleLocationRequest model)
{
var vehicle = _vehicleRepository.FindOneByCondition(x => x.VehicleNumber == model.VehicleNumber && x.IsActive);
if (vehicle == null)
{
throw new VehicleNotFoundException(ErrorCode.E102, model.VehicleNumber);
}
//Check session was created or not
var session = _trackingSessionRepository.FindOneByCondition(x =>
x.CreatedDate >= DateTime.UtcNow.Date &&
x.VehicleId == vehicle.Id);
if (session == null)
{
session = new TrackingSession()
{
VehicleId = vehicle.Id,
CreatedDate = DateTime.UtcNow,
TrackingRemark = DateTime.UtcNow.ToString("d")
};
_trackingSessionRepository.Create(session);
await _trackingSessionRepository.SaveAsync();
}
//Update Location with this session
var location = new TrackingHistory()
{
TrackingSessionId = session.Id,
CreatedDate = DateTime.UtcNow,
Lat = model.Latitude,
Lon = model.Longitude
};
_trackingHistoryRepository.Create(location);
await _trackingHistoryRepository.SaveAsync();
}
public async Task <TrackingHistory> AddTrackingHistory(TrackingHistory trackingHistory)
{
TrackingHistory addedHistory = null;
var parameters = new DynamicParameters();
parameters.Add("@ItemId", trackingHistory.ItemId);
parameters.Add("@Date", trackingHistory.Date);
parameters.Add("@Location", trackingHistory.Location);
using (var db = new SqlConnection(_dbConnection))
{
addedHistory = await db.QuerySingleAsync <TrackingHistory>(@"INSERT INTO [dbo].[TrackingHistory]
( [ItemId]
, [Date]
, [Location])
VALUES
( @ItemId
, @Date
, @Location )
SELECT [Id], [ItemId], [Date], [Location]
FROM [dbo].[TrackingHistory]
WHERE Id = SCOPE_IDENTITY()" , parameters);
}
return(addedHistory);
}
private PackageTracking GetDeliveryStatus()
{
return(TrackingHistory.FirstOrDefault(t => t.Status.Equals(DELIVERED_STATUS)));
}
public void AddTrackingInfo(PackageTracking tracking)
{
TrackingHistory.Add(tracking);
}
public async Task <ActionResult> AddTrackingHistory([FromBody] TrackingHistory trackingHistory)
{
return(Ok(await _gearTrackingProcessor.AddTrackingHistory(trackingHistory)));
}
public async Task CreateTrackingHistoryAsync(TrackingHistory trackingHistory)
{
await _trackingHistory.InsertOneAsync(trackingHistory);
}
private void AddTrackingInfo(PackageTracking tracking)
{
TrackingHistory.Add(tracking);
}
public async Task AddAsync(TrackingHistory history)
{
await _repository.AddAsync(history)
.AnyContext();
}
public async Task <List <PackageHistory> > TrackPackagesAsync(TrackingRequest trackingRequest, string authToken)
{
var packageHistory = new List <PackageHistory>();
var myCustomParameter = trackingRequest.Config["myCustomParameter"];
foreach (var package in trackingRequest.Packages)
{
var baseUrl = $"tracking-sandbox.getsandbox.com";
var parameters = $"/trackPackages?myCustomParameter={myCustomParameter}&tracking-number={package.TrackingNumber}&invoice-number={package.InvoiceNumber}";
var httpUrl = $"http://{baseUrl}{parameters}";
var httpsUrl = $"https://{baseUrl}{parameters}";
using (var request = new HttpRequestMessage
{
Method = HttpMethod.Get, //HttpMethod.Post if needed
RequestUri = new Uri(httpUrl)
})
{
request.Headers.Add("X-Vtex-Proxy-To", httpsUrl);
request.Headers.Add("Proxy-Authorization", authToken);
using (var response = await _httpClient.SendAsync(request))
{
var responseString = await response.Content.ReadAsStringAsync();
//Console.WriteLine(responseString);
var resultObject = JsonConvert.DeserializeObject <JToken>(responseString, _jsonSerializerSettings);
var trackingHistory = new TrackingHistory
{
Returned = false,
Delivered = false,
Events = new List <EventTrackingData>()
};
//Parse result and return correspondent tracking history
if (resultObject?["events"] is JArray eventsArray)
{
foreach (var item in eventsArray)
{
trackingHistory.Events.Add(new EventTrackingData
{
City = item["city"].ToString(),
State = item["state"].ToString(),
Description = item["description"].ToString(),
Date = DateTime.Parse(item["date"].ToString())
// DateTime.ParseExact(item["date"].ToString(), "dd-MM-yyyy HH:mm:ss", CultureInfo.InvariantCulture),
});
if (item["delivered"].ToObject <bool>())
{
trackingHistory.Delivered = true;
}
}
}
packageHistory.Add(new PackageHistory
{
Package = package,
TrackingHistory = trackingHistory
});
}
}
}
return(packageHistory);
}
public async Task <TrackingHistory> AddTrackingHistory(TrackingHistory trackingHistory)
{
return(await _gearTrackingRepository.AddTrackingHistory(trackingHistory));
}
