public async Task <IActionResult> CompleteTrip([FromBody] CompleteTripRequest completeTripRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
TripEntity trip = await _context.Trips
.Include(t => t.TripDetails)
.FirstOrDefaultAsync(t => t.Id == completeTripRequest.TripId);
if (trip == null)
{
return(BadRequest("Trip not found."));
}
trip.EndDate = DateTime.UtcNow;
trip.Qualification = completeTripRequest.Qualification;
trip.Remarks = completeTripRequest.Remarks;
trip.Target = completeTripRequest.Target;
trip.TargetLatitude = completeTripRequest.TargetLatitude;
trip.TargetLongitude = completeTripRequest.TargetLongitude;
trip.TripDetails.Add(new TripDetailEntity
{
Date = DateTime.UtcNow,
Latitude = completeTripRequest.TargetLatitude,
Longitude = completeTripRequest.TargetLongitude
});
_context.Trips.Update(trip);
await _context.SaveChangesAsync();
return(NoContent());
}
public async Task <IActionResult> PutTripEntity([FromRoute] int id, [FromBody] TripEntity tripEntity)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != tripEntity.Id)
{
return(BadRequest());
}
_context.Entry(tripEntity).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TripEntityExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public bool DeleteTripEntity(long id)
{
try
{
using (LocalTravelAppMSSQLDBContext localTravelAppMSSQLDBContext = new LocalTravelAppMSSQLDBContext())
{
bool removedPerUser = CurrentUserEntity.UserEntity.TripEntities.
Remove(CurrentUserEntity.UserEntity.TripEntities.ToList().Where(t => t.Id == id).FirstOrDefault());
TripEntity removedFromTrips = localTravelAppMSSQLDBContext.TripEntities.Remove(localTravelAppMSSQLDBContext.TripEntities.ToList().Where(t => t.Id == id).FirstOrDefault());
localTravelAppMSSQLDBContext.SaveChanges();
if (removedPerUser && removedFromTrips != null)
{
return(true);
}
else
{
return(false);
}
}
}
catch (Exception e)
{
return(false);
}
}
public async Task <IActionResult> Create([Bind("Id,Name,StartDate,EndDate")] TripEntity tripEntity)
{
if (ModelState.IsValid)
{
_context.Add(tripEntity);
try
{
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
catch (Exception ex)
{
if (ex.InnerException.Message.Contains("duplicate"))
{
ModelState.AddModelError(string.Empty, $"Already exists type: {tripEntity.Name}.");
}
else
{
ModelState.AddModelError(string.Empty, ex.InnerException.Message);
}
}
}
return(View(tripEntity));
}
public TripResponse ToTripResponse(TripEntity tripEntity)
{
return(new TripResponse
{
Id = tripEntity.Id,
IdTrip = tripEntity.IdTrip,
DestinyCity = tripEntity.DestinyCity,
StartDateTrip = tripEntity.StartDateTrip,
EndDateTrip = tripEntity.EndDateTrip,
TripDetails = tripEntity.TripDetails?.Select(t => new TripDetailsResponse
{
Id = t.Id,
Origin = t.Origin,
Description = t.Description,
Expenses = t.Expenses?.Select(ex => new ExpensesResponse
{
Id = ex.Id,
Value = ex.Value,
ExpensesType = ex.ExpenseType
}).ToList(),
}).ToList(),
User = ToUserResponse(tripEntity.User)
});
}
public TripResponse ToTripResponse(TripEntity tripEntity)
{
return(new TripResponse
{
EndDate = tripEntity.EndDate,
Id = tripEntity.Id,
Qualification = tripEntity.Qualification,
Remarks = tripEntity.Remarks,
Source = tripEntity.Source,
SourceLatitude = tripEntity.SourceLatitude,
SourceLongitude = tripEntity.SourceLongitude,
StartDate = tripEntity.StartDate,
Target = tripEntity.Target,
TargetLatitude = tripEntity.TargetLatitude,
TargetLongitude = tripEntity.TargetLongitude,
TripDetails = tripEntity.TripDetails?.Select(td => new TripDetailResponse
{
Date = td.Date,
Id = td.Id,
Latitude = td.Latitude,
Longitude = td.Longitude
}).ToList(),
User = ToUserResponse(tripEntity.User)
});
}
public async Task <IActionResult> Edit(int id, TripEntity tripEntity)
{
if (id != tripEntity.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(tripEntity);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TripEntityExists(tripEntity.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(tripEntity));
}
public async Task <IActionResult> ModifyTrip([FromBody] TripRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
TripEntity tripEntity = await _tripHelper.GetTripAsync(request.Id);
if (tripEntity == null)
{
return(BadRequest("Trip doesn't exist"));
}
tripEntity.CityVisited = request.CityVisited;
tripEntity.StartDate = request.StartDate;
tripEntity.EndDate = request.EndDate;
_dataContext.Trips.Update(tripEntity);
await _dataContext.SaveChangesAsync();
TripEntity updatedTrip = await _tripHelper.GetTripAsync(request.Id);
return(Ok(_converterHelper.ToTripResponse(updatedTrip)));
}
public TripResponse ToTripResponse(TripEntity tripEntity)
{
return(new TripResponse
{
Id = tripEntity.Id,
DestinyCity = tripEntity.DestinyCity,
StartDate = tripEntity.StartDateTrip,
EndDate = tripEntity.EndDateTrip,
TripDetails = tripEntity.TripDetails?.Select(t => new TripDetailResponse
{
Id = t.Id,
Origin = t.Origin,
Description = t.Description,
PicturePath = t.PicturePath,
Costs = t.Costs?.Select(td => new CostResponse
{
Id = td.Id,
Value = td.Value,
Category = td.Category,
CreatedDate = td.CreatedDate
}).ToList(),
}).ToList(),
User = ToUserResponse(tripEntity.User)
});
}
public async Task <IActionResult> GetTripEntity([FromRoute] string idtrip)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
idtrip = idtrip.ToUpper();
TripEntity tripEntity = await _context.Trips
.Include(t => t.User)
.Include(t => t.TripDetails)
.ThenInclude(t => t.Expenses)
.ThenInclude(t => t.TripDetails)
.ThenInclude(t => t.Trip)
.Include(t => t.User)
.FirstOrDefaultAsync(t => t.IdTrip == idtrip);
if (tripEntity == null)
{
return(NotFound());
}
return(Ok(_converterHelper.ToTripResponse(tripEntity)));
}
private void Update(TripEntity trip)
{
var tripToUpdate = this.GetById(trip.Id);
if (tripToUpdate != null)
{
tripToUpdate.DriverId = trip.DriverId;
tripToUpdate.Price = trip.Price;
tripToUpdate.Seats = trip.Seats;
tripToUpdate.StaticMapUrl = trip.StaticMapUrl;
tripToUpdate.StartDateTime = trip.StartDateTime;
if (tripToUpdate.Vehicle != null)
{
tripToUpdate.Vehicle.Color = trip.Vehicle.Color;
tripToUpdate.Vehicle.Manufacturer = trip.Vehicle.Manufacturer;
tripToUpdate.Vehicle.Model = trip.Vehicle.Model;
tripToUpdate.Vehicle.Year = trip.Vehicle.Year;
}
CatchMeContext.MapPoints.RemoveRange(tripToUpdate.MapPoints);
CatchMeContext.SaveChanges();
AddMapPoints(trip);
}
}
private async Task ExecuteUpdateTrips(int assetId)
{
using IUnitOfWork unitOfWork = repository.CreateUnitOfWork();
TripEntity lastTrip = await unitOfWork.GetEntities <TripEntity>()
.Include(x => x.EndLocation)
.Where(x => x.AssetId == assetId)
.OrderByDescending(x => x.Id)
.FirstOrDefaultAsync();
List <LocationEntity> locations;
List <TripEntity> trips = InitTripsList(lastTrip);
do
{
DateTime lastLocationDate = GetLastLocationDate(trips);
locations = await unitOfWork.GetEntities <LocationEntity>()
.Where(x => x.AssetId == assetId && x.DateTime > lastLocationDate)
.OrderBy(x => x.DateTime)
.Take(1000)
.ToListAsync();
foreach (LocationEntity location in locations)
{
AddLocationToTrip(trips, location);
}
} while (locations.Count > 0);
await SaveTrips(assetId, trips, unitOfWork);
}
private static void AddLocationToTrip(List <TripEntity> trips, LocationEntity location)
{
TripEntity tripEntity = trips.LastOrDefault();
if (tripEntity == null)
{
trips.Add(CreateTrip(location, 1));
}
else
{
TimeSpan timeSpan = location.DateTime - tripEntity.EndLocation.DateTime;
if (timeSpan.TotalMinutes > 10)
{
trips.Add(CreateTrip(location, tripEntity.Number + 1));
}
else
{
tripEntity.Distance += DistanceCalculator.CalculateDistance((tripEntity.EndLocation.Latitude,
tripEntity.EndLocation.Longitude, tripEntity.EndLocation.Odometer),
(location.Latitude, location.Longitude, location.Odometer));
tripEntity.EndLocation = location;
tripEntity.EndLocationId = location.Id;
}
}
}
public async Task <IActionResult> Edit(int id, TripEntity tripEntity)
{
if (id != tripEntity.Id)
{
return(NotFound());
}
_context.Add(tripEntity);
try
{
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
catch (Exception ex)
{
if (ex.InnerException.Message.Contains("duplicate"))
{
ModelState.AddModelError(string.Empty, $"Already exists type: {tripEntity.Name}.");
}
else
{
ModelState.AddModelError(string.Empty, ex.InnerException.Message);
}
}
return(View(tripEntity));
}
public async Task <IActionResult> DeleteConfirmed(int id)
{
TripEntity tripEntity = await _context.Trips.FindAsync(id);
_context.Trips.Remove(tripEntity);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
private void Add(TripEntity trip)
{
CatchMeContext.Vehicles.Add(trip.Vehicle);
CatchMeContext.Trips.Add(trip);
CatchMeContext.SaveChanges();
AddMapPoints(trip);
}
public async Task <IActionResult> PostTravel([FromBody] TripRequest TripRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(new Response
{
IsSuccess = false,
Message = "Bad request",
Result = ModelState
}));
}
CultureInfo cultureInfo = new CultureInfo(TripRequest.CultureInfo);
Resource.Culture = cultureInfo;
UserEntity userEntity = await _userHelper.GetUserAsync(TripRequest.User);
if (userEntity == null)
{
return(BadRequest(new Response
{
IsSuccess = false,
Message = Resource.UserDoesntExists
}));
}
var TripTypeEntity = await _context.TripTypes.FindAsync(TripRequest.TripType);
if (TripTypeEntity == null)
{
return(BadRequest(new Response
{
IsSuccess = false,
Message = Resource.TheTripTypeWasNotFound
}));
}
TripEntity Trip = new TripEntity
{
TripType = await _context.TripTypes.FirstOrDefaultAsync(tt => tt.Id == TripRequest.TripType),
StartDate = TripRequest.StartDate,
EndDate = TripRequest.EndDate,
User = await _context.Users.FirstOrDefaultAsync(u => u.Id == TripRequest.User.ToString()),
VisitedCity = TripRequest.VisitedCity
};
_context.Trips.Add(Trip);
await _context.SaveChangesAsync();
return(Ok(new Response
{
IsSuccess = true,
Message = Resource.TheTripHasBeenSavedCorrectly
}));
}
private void PopulateTripMapPoints(TripEntity trip)
{
var mapPoints = trip.MapPoints.OrderBy(mp => mp.Sequence).ToList();
trip.Origin = mapPoints.FirstOrDefault();
trip.Destination = mapPoints.LastOrDefault();
trip.WayPoints = mapPoints.Count > 2
? mapPoints.Skip(1).Take(mapPoints.Count - 2).ToList()
: new List <MapPoint>();
}
public void Add(TripEntity entity)
{
var context = new DataContext();
context.Configuration.AutoDetectChangesEnabled = false;
context.Configuration.LazyLoadingEnabled = true;
context.Trips.Add(entity);
context.Dispose();
}
public async Task <TripEntity> GetTripAsync(int?id)
{
TripEntity tripEntity = await _dataContext.Trips
.Include(t => t.User)
.Include(t => t.Expenses)
.ThenInclude(e => e.ExpenseType)
.FirstOrDefaultAsync(t => t.Id == id);
return(tripEntity);
}
public void Save(TripEntity trip)
{
if (trip.Id == 0)
{
Add(trip);
}
else
{
Update(trip);
}
}
public async Task <IActionResult> Create([Bind("Id,StartDate,EndDate,Description")] TripEntity tripEntity)
{
if (ModelState.IsValid)
{
_context.Add(tripEntity);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(tripEntity));
}
public async Task <IActionResult> PostTripEntity([FromBody] TripRequest tripRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
UserEntity userEntity = await _userHelper.GetUserAsync(tripRequest.UserId);
if (userEntity == null)
{
return(BadRequest("User doesn't exists."));
}
string picturePath = string.Empty;
byte[] PictureArray;
PictureArray = tripRequest.PicturePath;
if (PictureArray != null && PictureArray.Length > 0)
{
picturePath = _imageHelper.UploadImage(PictureArray, "Users");
}
TripEntity TripEntity = new TripEntity
{
StartDateTrip = tripRequest.StartDateTrip,
EndDateTrip = tripRequest.EndDateTrip,
DestinyCity = tripRequest.DestinyCity,
TripDetails = new List <TripDetailEntity>
{
new TripDetailEntity
{
Origin = tripRequest.Origin,
Description = tripRequest.Description,
PicturePath = picturePath,
Costs = new List <CostEntity>
{
new CostEntity
{
Value = tripRequest.Value,
Category = tripRequest.Category,
CreatedDate = DateTime.UtcNow
}
}
}
},
User = userEntity,
};
_context.Trips.Add(TripEntity);
await _context.SaveChangesAsync();
return(Ok(_converterHelper.ToTripResponse(TripEntity)));
}
public async Task <IActionResult> Create(TripEntity tripEntity)
{
if (ModelState.IsValid)
{
;
_context.Add(tripEntity);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(tripEntity));
}
private TripResponse ToTripResponseInTripDetails(TripEntity Trip)
{
if (Trip == null)
{
return(null);
}
return(new TripResponse
{
Id = Trip.Id
});
}
private TripResponse ToTripResponse2(TripEntity trips)
{
return(new TripResponse
{
Id = trips.Id,
StartDate = trips.StartDateTrip,
EndDate = trips.EndDateTrip,
DestinyCity = trips.DestinyCity,
User = ToUserResponse(trips.User)
});
}
public TripResponse ToTripResponse(TripEntity tripEntity)
{
return(new TripResponse
{
Id = tripEntity.Id,
Date = tripEntity.Date,
Amount = tripEntity.Amount,
Description = tripEntity.Description,
PicturePath = tripEntity.PicturePath,
ExpenseType = ToExpenseTypeResponse(tripEntity.ExpenseType),
});
}
public TripViewModel ToTripViewModel(TripEntity tripEntity)
{
return(new TripViewModel
{
Id = tripEntity.Id,
PicturePath = tripEntity.PicturePath,
Date = tripEntity.Date,
Amount = tripEntity.Amount,
Description = tripEntity.Description,
ExpenseType = tripEntity.ExpenseType,
});
}
public async Task <IActionResult> PostTripEntity([FromBody] TripRequest tripRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
UserEntity userEntity = await _userHelper.GetUserAsync(tripRequest.UserId);
if (userEntity == null)
{
return(BadRequest("User doesn't exists."));
}
TaxiEntity taxEntity = await _context.Taxis.FirstOrDefaultAsync(t => t.Plaque == tripRequest.Plaque);
if (taxEntity == null)
{
_context.Taxis.Add(new TaxiEntity
{
Plaque = tripRequest.Plaque.ToUpper(),
});
await _context.SaveChangesAsync();
taxEntity = await _context.Taxis.FirstOrDefaultAsync(t => t.Plaque == tripRequest.Plaque);
}
TripEntity tripEntity = new TripEntity
{
Source = tripRequest.Address,
SourceLatitude = tripRequest.Latitude,
SourceLongitude = tripRequest.Longitude,
StartDate = DateTime.UtcNow,
Taxi = taxEntity,
TripDetails = new List <TripDetailEntity>
{
new TripDetailEntity
{
Date = DateTime.UtcNow,
Latitude = tripRequest.Latitude,
Longitude = tripRequest.Longitude
}
},
UserEntity = userEntity,
};
_context.Trips.Add(tripEntity);
await _context.SaveChangesAsync();
return(Ok(_converterHelper.ToTripResponse(tripEntity)));
}
private void AddMapPoints(TripEntity trip)
{
int sequence = 0;
this.AddMapPoint(trip.Id, trip.Origin, sequence++);
foreach (var point in trip.WayPoints)
{
this.AddMapPoint(trip.Id, point, sequence++);
}
this.AddMapPoint(trip.Id, trip.Destination, sequence);
}
