// GET: Request
public ActionResult Index()
{
var RidesIdThisUserThroughRequests = unitOfWork.Rides.ListOfRidesID(User.Identity.GetUserId()); // ---------------Ok
if (User.IsInRole(RoleName.Driver))
{
var myRides = unitOfWork.Rides.GetRidesPerDriver(User.Identity.GetUserId());
var model = new RideViewModel()
{
// Oles oi diadromes tou ekastote odhgou
Rides = myRides,
// Fernw se lista tis arxikes diathesimes theseis ths kathe diadromhs
SeatsOffered = unitOfWork.Requests.ListOfSeatsOffered(myRides),
};
return(View("DriverRides", model));
}
else
{
var viewModel = new RequestViewModel()
{
Requests = unitOfWork.Requests
.ListOfRideIDThroughRequests(RidesIdThisUserThroughRequests, User.Identity.GetUserId())
.OrderBy(i => i.Ride.TimeRideStarted)
};
return(View(viewModel));
}
}
// Post
public ActionResult Save(RideViewModel model, int rideID)
{
if (rideID != 0) // Edit
{
if (!ModelState.IsValid)
{
model.RideID = rideID;
model.AvailableSeats = Ride.UpDateAvailableSeats(unitOfWork.Rides.NumberOfSeatsOffered(rideID));
return(View("UpDateRide", model));
}
unitOfWork.Rides.UpdateRide(model, rideID);
}
else
{
if (!ModelState.IsValid)
{
model.AvailableSeats = Ride.CreateAvailableSeatsForDrivers();
return(View("CreateRide", model));
}
var memberCarID = unitOfWork.MemberCar.GetMemberCarID(User.Identity.GetUserId());
var memberViewModel = unitOfWork.Rides.CreateRide(model, memberCarID);
// Prosthikh ths neas diadromhs
unitOfWork.Rides.Add(Ride.CreateNewRide(memberViewModel));
}
unitOfWork.Complete();
return(RedirectToAction("Index", "Request"));
}
public JsonResult CalculateTaxiFare(RideViewModel rideViewModel)
{
var totalPrice = _fareCalculatorService.Calculate(Mapper.Map <RideViewModel, RideHistory>(rideViewModel));
rideViewModel.TotalPrice = totalPrice;
return(BetterJson(rideViewModel));
}
public void PostTest()
{
RideController rideController = new RideController(_mockRideService.Object);
RideViewModel rideViewModel = new RideViewModel();
var result = rideController.Post(rideViewModel);
Assert.IsNotNull(result);
Assert.AreEqual(result.TotalPrice, 5);
}
public ActionResult Create()
{
var model = new RideViewModel()
{
AvailableSeats = Ride.CreateAvailableSeatsForDrivers()
};
return(View("CreateRide", model));
}
public FareSummary Post(RideViewModel rideViewModel)
{
Ride ride = new Ride();
rideViewModel.UpdateModel(ride);
var fareSummary = _rideService.GetFareSummary(ride);
return(fareSummary);
}
public async Task <IHttpActionResult> Register(RideBindingModel model)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
using (DunkeyContext ctx = new DunkeyContext())
{
if (ctx.Rider.Any(x => x.Email == model.Email))
{
return(Content(HttpStatusCode.OK, new CustomResponse <Error>
{
Message = "Conflict",
StatusCode = (int)HttpStatusCode.Conflict,
Result = new Error {
ErrorMessage = "Rider with email already exists"
}
}));
}
else
{
Rider rideModel = new Rider()
{
FullName = model.FullName,
BusinessName = model.BusinessName,
Email = model.Email,
BusinessType = model.BusinessType,
Status = (int)Global.StatusCode.NotVerified,
Phone = model.Phone,
ZipCode = model.ZipCode
};
ctx.Rider.Add(rideModel);
ctx.SaveChanges();
using (RideViewModel rideViewModel = new RideViewModel(rideModel))
{
//userViewModel.Token = await Utility.GenerateToken(userModel.Email, userModel.Password, Request);
CustomResponse <RideViewModel> response = new CustomResponse <RideViewModel> {
Message = "Success", StatusCode = (int)HttpStatusCode.OK, Result = rideViewModel
};
return(Ok(response));
//return Request.CreateResponse(HttpStatusCode.OK, response);
}
}
}
}
catch (Exception ex)
{
return(StatusCode(DunkeyDelivery.Utility.LogError(ex)));
}
}
// Get
public ActionResult UpDateRide(int rideID)
{
var model = new RideViewModel()
{
RideID = rideID,
AvailableSeats = Ride.UpDateAvailableSeats(unitOfWork.Rides.NumberOfSeatsOffered(rideID)),
};
return(View("UpDateRide", model));
}
public IActionResult Ride()
{
IEnumerable <Account> account = this._accountLogic.GetAllEmployees();
IEnumerable <PickOrder> pickOrders = this._pickOrderLogic.GetAllPickOrders();
IEnumerable <Vehicle> vehicles = this._vehicleLogic.GetAllVehicles();
RideViewModel model = new RideViewModel(account, pickOrders, vehicles);
return(View(model));
}
public RideViewModel CreateRide(string placeFrom, string placeTo, string dateFrom, string timeFrom, string timeDelay, string timeTravel, string timeBreak, string passengersNomber, bool isTotalPrice, float price, string userId)
{
RideViewModel viewModel = new RideViewModel();
try
{
using (DataContext db = new DataContext())
{
string[] placeFromArgs = placeFrom.Split(new string[] { " (" }, StringSplitOptions.None).Select(p => p.TrimEnd(new char[] { ')' })).ToArray();
string[] placeToArgs = placeTo.Split(new string[] { " (" }, StringSplitOptions.None).Select(p => p.TrimEnd(new char[] { ')' })).ToArray();
DateTime startTime = Convert.ToDateTime(dateFrom + " " + timeFrom);
int travelTimeMinutes = Convert.ToInt32(Math.Floor(new TimeSpan(Convert.ToDateTime(timeTravel).TimeOfDay.Ticks).TotalMinutes));
int delayTimeMinutes = !String.IsNullOrEmpty(timeDelay) ? Convert.ToInt32(Math.Floor(new TimeSpan(Convert.ToDateTime(timeDelay).TimeOfDay.Ticks).TotalMinutes)) : 0;
int breakTimeMinutes = !String.IsNullOrEmpty(timeBreak) ? Convert.ToInt32(Math.Floor(new TimeSpan(Convert.ToDateTime(timeBreak).TimeOfDay.Ticks).TotalMinutes)) : 0;
db.Rides.Add(new Ride()
{
FromCity = placeFromArgs[0],
FromCounty = placeFromArgs[1],
ToCity = placeToArgs[0],
ToCounty = placeToArgs[1],
StartTime = startTime,
DriverUserId = userId,
TravelTime = travelTimeMinutes,
DelayedStartTime = delayTimeMinutes,
BreakTime = breakTimeMinutes,
MaxPassengers = Int32.Parse(passengersNomber),
TotalPrice = isTotalPrice ? price : 0,
PricePerPassenger = !isTotalPrice ? price : 0,
EndTime = startTime.AddMinutes(travelTimeMinutes + delayTimeMinutes + breakTimeMinutes),
DateCreated = DateTime.Now
});
db.SaveChanges();
}
}
catch (System.Data.Entity.Validation.DbEntityValidationException dbEx)
{
Exception raise = dbEx;
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
string message = string.Format("{0}:{1}", validationErrors.Entry.Entity.ToString(), validationError.ErrorMessage); // todo
}
}
}
catch (Exception e)
{
// todo
}
return(viewModel);
}
// GET: Ride
public ActionResult Index()
{
var drivers = db.Drivers.ToList();
var viewModel = new RideViewModel
{
Ride = new Ride(),
DriverList = drivers
};
return(View(viewModel));
}
public void UpdateRide(RideViewModel model, int rideID)
{
var rideDB = GetRideInfo(rideID);
rideDB.SourceCity.CityName = model.Ride.SourceCity.CityName;
rideDB.SourceCity.CityCode = model.Ride.SourceCity.CityCode;
rideDB.DestinationCity.CityName = model.Ride.DestinationCity.CityName;
rideDB.DestinationCity.CityCode = model.Ride.DestinationCity.CityCode;
rideDB.TimeRideStarted = model.GetStartedDateTime();
rideDB.TimeRideArrives = model.GetArrivesDateTime();
rideDB.AvailableSeatsOffered += model.SelectNumberOfSeats;
}
public async Task <IActionResult> PostRideAsync(RideViewModel rideViewModel)
{
var ride = mapper.Map <Ride>(rideViewModel);
var result = await rideService.AddRideAsync(ride);
if (result.Success)
{
return(Ok(result.Message));
}
return(BadRequest(result.Message));
}
public MemberViewModel CreateRide(RideViewModel model, int memberCarID)
{
var memberViewModel = new MemberViewModel()
{
Ride = model.Ride,
StartedDate = model.StartedDate,
StartedTime = model.StartedTime,
ArivesDate = model.ArivesDate,
ArivesTime = model.ArivesTime,
SelectNumberOfSeats = model.SelectNumberOfSeats,
MemberCarID = memberCarID
};
return(memberViewModel);
}
//TODO: AutoMapper
private RideSharing MapRideVM(RideViewModel rideVm)
{
var ride = GetEntity();
ride.Id = rideVm.Id;
ride.StartLocation = rideVm.StartLocation;
ride.EndLocation = rideVm.EndLocation;
ride.StartDate = rideVm.StartDate;
ride.EndDate = rideVm.EndDate;
ride.CarId = Convert.ToInt64(rideVm.CarId.Value);
ride.EmployeeRides = rideVm.EmployeeIds.Select(x =>
{
return(new EmployeeRide
{
EmployeeId = Convert.ToInt64(x.Value),
RideId = rideVm.Id
});
}).ToList();
return(ride);
}
// GET: Ride/Create
public ActionResult Create()
{
var user = new User();
if (Session["loginUser"] == null)
{
TempData["error"] = "PleaseLogin first";
return(RedirectToAction("index", "Home"));
}
else
{
user = Session["loginUSer"] as User;
var userInDb = db.Users.First(u => u.Id == user.Id);
var drivers = db.Drivers.ToList();
var viewModel = new RideViewModel
{
Ride = new Ride(),
DriverList = drivers
};
return(View(viewModel));
}
}
// GET: History
public ActionResult Index(RequestViewModel requestViewModel) // OK -----------------------
{
if (User.IsInRole(RoleName.Driver))
{
var myRides = unitOfWork.Rides.GetRidesPerDriver(User.Identity.GetUserId());
var model = new RideViewModel()
{
Rides = myRides,
// Fernw se lista tis palies diadromes tou odhgou
Historyrides = myRides.FirstOrDefault().GetListOfLastRides(myRides),
SeatsOffered = unitOfWork.Requests.ListOfSeatsOffered(myRides)
};
return(View("DriverHistoryRides", model));
}
var listOfRequests = new List <Request>();
// Fernw ta RequestID tou sygkekrimenou Passenger
var ListOfRequestID = unitOfWork.Requests.GetRequestIDPerPassenger(User.Identity.GetUserId());
foreach (var requestID in ListOfRequestID)
{ // Fernw ta stoixeia tou sygkekrimenou Request
var requestDB = unitOfWork.Requests.GetInfoPerRequest(requestID);
if (requestDB.Ride.TimeRideStarted < DateTime.Now)
{
listOfRequests.Add(requestDB);
}
}
var viewModel = new RequestViewModel()
{
Requests = listOfRequests.OrderBy(i => i.Ride.TimeRideStarted).AsEnumerable(),
IsRated = requestViewModel.IsRated
};
return(View("HistoryView", viewModel));
}
public async Task DeleteAsync(RideViewModel rideVM)
{
var ride = MapRideVM(rideVM);
await DeleteAsync(ride);
}
public RidePage()
{
InitializeComponent();
BindingContext = vm = new RideViewModel();
}
public async Task CreateAsync(RideViewModel rideVM)
{
var ride = MapRideVM(rideVM);
await AddAsync(ride);
}
public async Task UpdateAsync(RideViewModel rideVM)
{
var ride = MapRideVM(rideVM);
await UpdateAsync(ride);
}
public ActionResult Index()
{
var model = new RideViewModel();
return(View("Index", model));
}
