public async Task <TripDocument> CreateTrip(TripRequest tripRequest, RiderClaim riderClaims)
{
var tripContainer = _cosmosClient.GetContainer(Constants.ScootersDataBaseId, Constants.TripCollection);
var trip = new TripDocument
{
Id = Guid.NewGuid().ToString(),
DocumentType = Constants.TripDocumentType,
Rider = new TripRider
{
UserId = riderClaims.UserId,
FirstName = riderClaims.FirstName,
LastName = riderClaims.LastName,
Email = riderClaims.EmailAddress
},
Source = tripRequest.Source,
RequestDateTime = tripRequest.RequestDateTime,
Duration = 0,
ScooterCode = tripRequest.ScooterCode,
TripIsEnded = false,
Destination = null,
StartDateTime = null,
EndDateTime = null
};
await tripContainer.UpsertItemAsync(trip, new PartitionKey(trip.ScooterCode));
return(trip);
}
public async Task <IActionResult> PostTrip([FromBody] TripRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var traveler = await _context.Travelers.FindAsync(request.TravelerId);
if (traveler == null)
{
return(BadRequest("Not valid traveler."));
}
var trip = new Trip
{
City = request.City,
Budget = request.Budget,
Date = request.Date.ToUniversalTime(),
EndDate = request.EndDate.ToUniversalTime(),
Traveler = traveler
};
_context.Trips.Add(trip);
await _context.SaveChangesAsync();
return(Ok(_converterHelper.ToTripResponse(trip)));
}
public IEnumerable <TripResponse> GetActiveTripsByEmail(TripRequest datosTrip)
{
var user = _context.User.SingleOrDefault(c => c.Email == datosTrip.Email);
List <TripResponse> respuesta = new List <TripResponse>();
DateTime fechaHoy = DateTime.Now;
IList <Trip> Trips = (from i in _context.Trip
where i.UserId == user.Id && i.FechaHasta > fechaHoy
select i).ToList <Trip>();
foreach (Trip viaje in Trips)
{
TripResponse item = new TripResponse();
item.Ida = viaje.Ida.ToString("dd/MM/yyyy");
item.Vuelta = viaje.Vuelta.ToString("dd/MM/yyyy");
item.FechaDesde = viaje.FechaDesde.ToString("dd/MM/yyyy");
item.FechaHasta = viaje.FechaHasta.ToString("dd/MM/yyyy");
item.NotasImportantes = viaje.NotasImportantes;
item.Estado = viaje.Status.Nombre;
item.Reserva = viaje.CodigoReserva;
item.Aerolinea = viaje.Airline.Nombre;
item.ViajeId = viaje.Id;
item.NombreViajero = viaje.User.Nombre;
respuesta.Add(item);
}
return(respuesta);
}
static void Main(string[] args)
{
var request = new TripRequest()
{
Airline = "Reflection Airways"
};
var window = new Window();
var stackPanel = new StackPanel();
window.Content = stackPanel;
foreach (var property in request.GetType().GetProperties())
{
Console.WriteLine("Property named {0} has type {1}", property.Name, property.PropertyType);
if (property.PropertyType == typeof(string))
{
var textBox = new TextBox();
var binding = new Binding();
binding.Source = request;
binding.Path = new PropertyPath(property.Name);
BindingOperations.SetBinding(textBox, TextBox.TextProperty, binding);
stackPanel.Children.Add(textBox);
}
// etc for other types you care about
}
window.ShowDialog();
Console.WriteLine("Airline is now {0}", request.Airline);
Console.WriteLine("Finished");
}
public void CanelRequestTrip(int TripRequestId)
{
TripRequest TripRequestObj = _context.TripRequest.Where(request => request.Id == TripRequestId).FirstOrDefault();
_context.Remove(TripRequestObj);
_context.SaveChanges();
}
public async Task <IActionResult> PutTrip([FromRoute] int id, [FromBody] TripRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != request.Id)
{
return(BadRequest());
}
var oldTrip = await _context.Trips.FindAsync(request.Id);
if (oldTrip == null)
{
return(BadRequest("Trip doesn't exists."));
}
oldTrip.City = request.City;
oldTrip.Budget = request.Budget;
oldTrip.Date = request.Date.ToUniversalTime();
oldTrip.EndDate = request.EndDate.ToUniversalTime();
_context.Trips.Update(oldTrip);
await _context.SaveChangesAsync();
return(Ok(_converterHelper.ToTripResponse(oldTrip)));
}
public async Task <IActionResult> AddTrip([FromBody] TripRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_dataContext.Add(await _converterHelper.ToTripEntity(request));
await _dataContext.SaveChangesAsync();
UserEntity userEntity = await _userHelper.GetUserAsync(request.UserEmail);
MyTripsRequest myTripsRequest = new MyTripsRequest
{
UserId = userEntity.Id,
StartDate = DateTime.Parse("2020-01-01"),
EndDate = DateTime.Parse("2021-01-01")
};
List <TripEntity> trips = await _dataContext.Trips
.Include(t => t.Expenses)
.ThenInclude(t => t.ExpenseType)
.Include(t => t.User)
.Where(t => t.User.Id == myTripsRequest.UserId &&
t.StartDate >= myTripsRequest.StartDate &&
t.StartDate <= myTripsRequest.EndDate)
.ToListAsync();
return(Ok(_converterHelper.ToTripResponse(trips)));
}
public async Task <IActionResult> NewRequest([FromBody] TripRequest NewTripRequest, int tripid)
{
NewTripRequest.RequestDate = DateTime.Today.Date;
NewTripRequest.TripId = tripid;
List <TripRequest> list = _context.TripRequest.Where(request => request.TripId == NewTripRequest.TripId).ToList().ToList();
Trip TripObj = _context.Trip.Where(trip => trip.Id == NewTripRequest.TripId).FirstOrDefault();
if (TripObj.StartTime < DateTime.Now)
{
return(BadRequest("This trip is expired!"));
}
else if (list.Where(x => x.PassengerId == NewTripRequest.PassengerId).Count() > 0)
{
return(BadRequest("Passenger exist in this trip!"));
}
else if (list.Where(x => x.Status == (int)TripRequestStatus.Approved).Count() >= TripObj.SeatsNo)
{
return(BadRequest("Trip is full board!"));
}
else
{
NewTripRequest.Status = (int)TripRequestStatus.New;
await _context.TripRequest.AddAsync(NewTripRequest);
await _context.SaveChangesAsync();
string passengerName = _context.User.Find(NewTripRequest.PassengerId).Username;
string notificationText = ReplaceNotificationBody(passengerName, NotificationsTemplates.newRequest);
PushNotification(notificationText, NewTripRequest.TripId, NewTripRequest.Trip.DriverId);
}
return(CreatedAtAction("GetTripRequest", new { id = NewTripRequest.Id }, NewTripRequest));
}
public async Task <ActionResult <TripRequest> > PostTriprequest(TripRequest item)
{
var updatedEntry = _context.TripRequests.Add(item);
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(GetTripRequest), updatedEntry));
}
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 static bool TestMethod(string trip)
{
TripRequest tr = new TripRequest();
tr.TripNumber = trip;
var response = bridgeApiClient.GetTrip(tr);
return(true);
}
public AddTripPageViewModel(INavigationService navegationService, IApiService apiService)
: base(navegationService)
{
_navigationService = navegationService;
_apiService = apiService;
Title = Languages.AddTrip;
User = new UserRequest();
Trip = new TripRequest();
}
public NewTripPageViewModel(INavigationService navigationService, IApiService apiService) : base(navigationService)
{
_navigationService = navigationService;
_apiService = apiService;
_trip = new TripRequest();
Title = "Add New Trip";
StartDateTrip = DateTime.Now;
EndDateTrip = DateTime.Now;
}
public void TripRequest_Defaults()
{
var r = new TripRequest();
Assert.AreEqual <bool>(false, r.Annotate);
Assert.AreEqual <bool>(false, r.Steps);
Assert.AreEqual <string>("polyline", r.Geometries);
Assert.AreEqual <string>("simplified", r.Overview);
}
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
}));
}
public async Task <bool> DoTrip(TripRequest order)
{
await MoveLift(order.From);
await OpenCloseDoor();
await MoveLift(order.To);
await OpenCloseDoor();
Status = LiftStatus.Iddle;
return(true);
}
public TripEntity tripRequestToEntity(TripRequest tripRequest)
{
return(new TripEntity
{
Name = tripRequest.Name,
StartDate = tripRequest.StartDate,
EndDate = tripRequest.EndDate,
Description = tripRequest.Description
});
}
public void BaseRequest_Defaults()
{
var r = new TripRequest();
// test common base request items
Assert.AreEqual <bool>(false, r.SendCoordinatesAsPolyline);
Assert.IsNotNull(r.Coordinates);
Assert.IsNotNull(r.Bearings);
Assert.IsNotNull(r.Radiuses);
Assert.IsNotNull(r.Hints);
}
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 NewTripPageViewModel(INavigationService navigationService, IApiService apiService) : base(navigationService)
{
_navigationService = navigationService;
_apiService = apiService;
Title = Languages.NewTripPage;
IsEnabled = true;
Trip = new TripRequest();
LoadCitiesAsync();
LoadUser();
todayDate = DateTime.Now;
}
public void AddOrder(TripRequest order)
{
Orders.Add(order);
if (Status == LiftStatus.Iddle &&
Orders.Any())
{
TripRequest currentOrder = Orders.First();
Orders.RemoveAt(0);
DoTrip(currentOrder); //TODO: Check if there is a better way than "skipping" await.
}
}
public async Task <TripEntity> ToTripEntity(TripRequest tripRequest)
{
UserEntity userEntity = await _userHelper.GetUserAsync(tripRequest.UserEmail);
return(new TripEntity
{
CityVisited = tripRequest.CityVisited,
StartDate = tripRequest.StartDate,
EndDate = tripRequest.EndDate,
User = userEntity
});
}
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)));
}
public IHttpActionResult EndTripRequest(TripRequest model)
{
try
{
//var res = _routemanager.EndTrip(int.Parse(User.Identity.GetUserId()), model.TripId);
//return Json(_responseProvider.GenerateRouteResponse(res, "TripInfo"));
}
catch (Exception e)
{
_logmanager.Log(Tag, "SendUserTripLocation", e.Message);
}
return(Json(_responseProvider.GenerateUnknownErrorResponse()));
}
public ActionResult <int> ScheduleTrip(TripRequest trip)
{
_logger.LogInformation("scheduleTrip request: {request}", JsonSerializer.Serialize(trip));
if (_schedulingSrv == null)
{
return(StatusCode(503, "Service temporarily down. Please try again later."));
}
int elevatorId = _schedulingSrv.ScheduleTrip(trip.origin, trip.destination);
return(Ok(elevatorId));
}
public AddTripPageViewModel(INavigationService navigationService,
IApiService apiService,
IRegexHelper regexHelper) : base(navigationService)
{
Title = Languages.AddTrip;
_navigationService = navigationService;
_apiService = apiService;
_regexHelper = regexHelper;
Trip = new TripRequest
{
StartDate = DateTime.UtcNow.ToLocalTime(),
EndDate = DateTime.UtcNow.AddDays(1)
};
}
public async Task <ActionResult> CallElevator(TripRequest trip)
{
try
{
int response = await _callPanelService.CallElevator(trip);
return(Ok(response));
}
catch (Exception e)
{
_logger.LogError(e, $"Error from CallPanelService.CallElevator - origin: {trip.origin} \tdestination: {trip.destination}");
return(StatusCode(503));
}
}
public async Task <Response> GetTrips <T>(
string urlBase,
string servicePrefix,
string controller,
TripRequest request,
string token)
{
try
{
var client = new HttpClient
{
BaseAddress = new Uri(urlBase),
};
var url = $"{servicePrefix}{controller}";
string rq = JsonConvert.SerializeObject(request);
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
StringContent content = new StringContent(rq, Encoding.UTF8, "application/json");
HttpResponseMessage response = await client.PostAsync(url, content);
var result = await response.Content.ReadAsStringAsync();
if (!response.IsSuccessStatusCode)
{
return(new Response
{
IsSuccess = false,
Message = result,
});
}
var list = JsonConvert.DeserializeObject <List <T> >(result);
return(new Response
{
IsSuccess = true,
Result = list
});
}
catch (Exception ex)
{
return(new Response
{
IsSuccess = false,
Message = ex.Message
});
}
}
public TripRequest ApproveOrRejectRequest([FromBody] TripRequest NewTripRequest)
{
int RequestsCount = _context.TripRequest.Where(request => request.TripId == NewTripRequest.TripId).ToList().Count();
Trip TripObj = _context.Trip.Where(trip => trip.Id == NewTripRequest.Id).FirstOrDefault();
if (RequestsCount <= TripObj.SeatsNo)
{
NewTripRequest = InsertNewTripRequest(NewTripRequest);
}
else
{
TripObj.Status = TripStatus.FullBoard.ToString();
_context.SaveChanges();
}
return(NewTripRequest);
}
public HttpResponseMessage UpdateLocation(TripRequest tripRequest)
{
var responseMessage = new HttpResponseMessage();
try
{
EzMoveIdentity ezMoveIdentity = (EzMoveIdentity)HttpContext.Current.User.Identity;
TripService.UpdateLocation(tripRequest.TripID, tripRequest.location, ezMoveIdentity.loginResponse.UserID);
responseMessage = Request.CreateResponse(HttpStatusCode.OK);
}
catch (Exception ex)
{
responseMessage = Request.CreateResponse(HttpStatusCode.InternalServerError, new ResultMessage(ex));
}
return(responseMessage);
}