public async Task <TravelPlan> PublishTravelPlanAsync(int userId, TravelPlan travelPlan)
{
var user = GetUser(userId);
if (user == null)
{
return(null);
}
TravelPlan _travelPlan;
travelPlan.UserTravelPlans.Add(new UserTravelPlan
{
IsUserOwner = true,
TravelPlan = travelPlan,
UserId = userId,
});
using (var scope = _provider.CreateScope())
{
var travelPlanService = scope.ServiceProvider.GetService <TravelPlanService>();
_travelPlan = await travelPlanService.CreateTravelPlanAsync(travelPlan);
}
return(_travelPlan);
}
public IActionResult CreateTravelPlan(TravelPlanDTO travelPlanDTO)
{
bool isCarOnRide = _travelPlanService.IsCarAlreadyOnTheRide(travelPlanDTO.SelectedCarPlates, travelPlanDTO.StartDate, travelPlanDTO.EndDate);
if (isCarOnRide)
{
ModelState.AddModelError("CarOnTheRide", "");
}
if (ModelState.IsValid)
{
TravelPlan travelPlan = _travelPlanService.MapDTOToTravelPlan(travelPlanDTO, _carService);
List <TravelPlan> travelPlans = _travelPlanService.GetTravelPlans();
travelPlans.Add(travelPlan);
travelPlanDTO.Id = travelPlan.Id;
return(RedirectToAction("PickPassengers", travelPlanDTO));
}
else
{
travelPlanDTO.ListOfCars = _carService.Cars.ToList();
return(View(travelPlanDTO));
}
}
public string GetAvailableCars(TravelPlan.NewTravelPlan x)
{
try {
List <NewCar> xx = LoadData(mainSql);
TravelPlan TP = new TravelPlan();
List <TravelPlan.NewTravelPlan> tPlans = TP.LoadData(TP.mainSql);
foreach (var c in xx)
{
if (tPlans.Where(a => (a.car.id == c.id) &&
((DateTime.Compare(a.startDate, x.startDate) >= 0 && DateTime.Compare(a.startDate, x.endDate) < 0) ||
(DateTime.Compare(a.endDate, x.startDate) >= 0 && DateTime.Compare(a.endDate, x.endDate) <= 0))).Count() > 0)
{
c.isAvailable = false;
}
else
{
c.isAvailable = true;
}
}
List <NewCar> availableCars = xx.Where(a => a.isAvailable).ToList();
return(JsonConvert.SerializeObject(availableCars, Formatting.None));
} catch (Exception e) {
return(JsonConvert.SerializeObject(e.Message, Formatting.None));
}
}
public IActionResult EditTravelPlan(TravelPlanDTO travelPlan)
{
TravelPlan travelPlanForEdit = _travelPlanService.GetTravelPlans().Where(p => p.Id == travelPlan.Id).FirstOrDefault();
bool canFitIntoACar = _carService.CanFitIntoACar(travelPlan.SelectedCarPlates, travelPlanForEdit.SelectedEmployees);
if (!canFitIntoACar)
{
ModelState.AddModelError("CarIsFull", "");
}
if (ModelState.IsValid)
{
travelPlan.SelectedEmployees = _travelPlanService.GetSelectedEmployees(travelPlan.Id);
travelPlan.SelectedCar = _carService.GetCar(travelPlan.SelectedCarPlates);
_travelPlanService.SaveTravelPlan(travelPlan);
return(RedirectToAction("Carpools"));
}
else
{
travelPlan.ListOfCars = _carService.Cars.ToList();
travelPlan.SelectedCar = _carService.GetCar(travelPlan.SelectedCarPlates);
return(View(travelPlan));
}
}
public void Remove(int id)
{
TravelPlan travelPlan = context.TravelPlans.Find(id);
context.TravelPlans.Remove(travelPlan);
context.SaveChanges();
}
// PUT api/TravelPlans/5
public async Task <IHttpActionResult> PutTravelPlan(int id, TravelPlan travelplan)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != travelplan.TravelPlanId)
{
return(BadRequest());
}
db.Entry(travelplan).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TravelPlanExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public HttpResponseMessage PostMessage(Message message)
{
string token = Request.Headers.Authorization.Parameter;
JwtAuthUtil jwtAuthUtil = new JwtAuthUtil();
int Mid = Convert.ToInt32(jwtAuthUtil.GetId(token));
if (message.TravelPlanId == 0)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest,
new { success = false, message = "no such plan exists" }));
}
TravelPlan travelPlan = new TravelPlan();
message.CreateOn = DateTime.Now;
var planner = db.TravelPlans.Find(message.TravelPlanId);
message.PlannerId = planner.MemberId;
message.MemberId = Mid;
db.Messages.Add(message);
db.SaveChanges();
var result = db.Messages.Where(x => x.TravelPlanId == planner.id).Select(x => new
{
x.id,
x.TravelPlanId,
x.Body,
x.CreateOn,
buyer = message.MemberId,
seller = message.PlannerId
});
return(Request.CreateResponse(HttpStatusCode.OK, new { success = true, message = "訊息傳送成功", result }));
}
public async Task GetAvailableCars_WhenCarNotAtLocation_DoesntReturnCar()
{
// Arrange
var cars = SeedData.GenerateCars(1);
await DbContext.AddRangeAsync(cars);
var car1 = cars[0];
var locations = SeedData.GenerateLocations(2);
await DbContext.AddRangeAsync(locations);
var locationA = locations[0].LocationId;
var locationB = locations[1].LocationId;
// Car available at location B
var previousTravelPlan = new TravelPlan()
{
StartLocationId = locationB,
EndLocationId = locationB,
CarId = car1.CarId,
StartTimeUtc = new DateTime(2021, 2, 3),
EndTimeUtc = new DateTime(2021, 2, 10)
};
// Car needs to be at location B at this date
var travelPlanInTheFuture = new TravelPlan()
{
CarId = car1.CarId,
StartLocationId = locationB,
EndLocationId = locationB,
StartTimeUtc = new DateTime(2021, 2, 20),
EndTimeUtc = new DateTime(2021, 3, 1)
};
await DbContext.TravelPlans.AddRangeAsync(previousTravelPlan, travelPlanInTheFuture);
await DbContext.SaveChangesAsync();
var carService = CarServiceFactory();
var timeWhenCarShouldBeAvailable = new DateTime(2021, 2, 11);
// Find cars for location B
var carOptions = new AvailableCarsOptions()
{
StartLocationId = locationB,
EndLocationId = locationA,
StartDateUtc = timeWhenCarShouldBeAvailable,
EndDateUtc = timeWhenCarShouldBeAvailable.AddDays(7),
};
// Act
var(success, resultCars) = await carService.GetAvailableCarsAsync(carOptions);
// Assert
success.Should().BeFalse();
resultCars.Should().BeEmpty();
}
public IActionResult EditTravelPlan(int id)
{
TravelPlan travelPlan = _travelPlanService.GetTravelPlan(id);
TravelPlanDTO travelPlanDTO = _travelPlanService.MapTravelPlanToDTO(travelPlan, _carService);
return(View(travelPlanDTO));
}
public ActionResult DeleteConfirmed(int id)
{
TravelPlan travelPlan = db.Plans.Find(id);
db.Plans.Remove(travelPlan);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ItemFrameViewModel(NavViewNavigationEventArgs e)
{
UserName = e.Username;
TravelPlan = e.TravelPlan;
IsLoading = false;
ResetMessage();
ShowNewItemFields = false;
}
public void MapTo(TravelPlan travelPlan)
{
Id = travelPlan.Id;
StartLocation = travelPlan.StartLocation;
EndLocation = travelPlan.EndLocation;
StartDate = travelPlan.StartDate;
EndDate = travelPlan.EndDate;
CarId = travelPlan.CarId;
}
public void DeleteTravelPlan(int travelPlanId)
{
TravelPlan travelPlanForDelete = TravelPlans.Where(tp => tp.Id == travelPlanId).FirstOrDefault();
if (travelPlanForDelete != null)
{
TravelPlans.Remove(travelPlanForDelete);
}
}
public ActionResult AddTravelPlan(TravelPlan travelPlan)
{
if (ModelState.IsValid)
{
_travelPlanManager.Add(travelPlan);
return(StatusCode(201));
}
return(BadRequest());
}
public TaskFrameViewModel(NavViewNavigationEventArgs e)
{
UserName = e.Username;
TravelPlan = e.TravelPlan;
IsLoading = false;
ResetMessage();
ShowNewTaskFields = false;
SelectedBoxValue = "Nothing";
}
public TravelPlanDto(TravelPlan travelPlan)
{
this.Id = travelPlan.TravelPlanId;
this.Name = travelPlan.Name;
this.StartDate = DateTime.SpecifyKind(travelPlan.StartDate, DateTimeKind.Utc);
this.EndDate = DateTime.SpecifyKind(travelPlan.EndDate, DateTimeKind.Utc);
this.Description = travelPlan.Description;
this.CreatedById = travelPlan.CreatedById;
}
public async void OnNewTravelPlan(string newName, DateTime newStartDate, DateTime newEndDate, string newDestination)
{
ResetMessage();
if (ShowNewTravelPlanFields)
{
if (string.IsNullOrEmpty(newName))
{
Message = "A name is required, try again.";
return;
}
IsLoading = true;
Message = "Processing, please wait.";
DateTime newStartDateRef = newStartDate.Date == new DateTime(1601, 1, 1).Date ? new DateTime() : newStartDate;
DateTime newEndDateRef = newEndDate.Date == new DateTime(1601, 1, 1).Date ? new DateTime() : newEndDate;
string newDestinationRef = string.IsNullOrEmpty(newDestination) ? "-" : newDestination;
TravelPlan newTravelPlan = new TravelPlan(newName, newStartDateRef, newEndDateRef, newDestinationRef);
//Restcall
try
{
HttpClient httpClient = new HttpClient();
Uri uri = new Uri(BASE_URL + "User/addTravelPlan/" + UserName);
HttpStringContent content = new HttpStringContent(
JsonConvert.SerializeObject(newTravelPlan),
UnicodeEncoding.Utf8,
"application/json");
HttpResponseMessage httpResponseMessage = await httpClient.PostAsync(
uri,
content);
httpResponseMessage.EnsureSuccessStatusCode();
var httpResponseBody = await httpResponseMessage.Content.ReadAsStringAsync();
Message = httpResponseBody;
if (httpResponseBody.Split(" ")[0] != "Error:")
{
_user.AddTravelPlan(newTravelPlan);
RaisePropertyChanged("TravelPlans");
}
}
catch (Exception ex)
{
Message = ex.Message;
}
ShowNewTravelPlanFields = false;
IsLoading = false;
}
else
{
ShowNewTravelPlanFields = true;
}
}
public void Add(TravelPlan travelPlan)
{
//if (FindConflictingTravelPlans(travelPlan.StartDate, travelPlan.EndDate).Count() != 0)
//{
// throw new Exception("There are conflicting travel plans for this period.");
//}
context.TravelPlans.Add(travelPlan);
context.SaveChanges();
}
public ActionResult Edit([Bind(Include = "ID,price,startDate,endDate,detail,TravelID")] TravelPlan travelPlan)
{
if (ModelState.IsValid)
{
db.Entry(travelPlan).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(travelPlan));
}
public TravelPlanResult(TravelPlan model)
{
TravelPlanId = model.TravelPlanId;
StartLocation = model.StartLocation;
EndLocation = model.EndLocation;
StartDate = model.StartDate;
EndDate = model.EndDate;
Car = new CarResult(model.Car);
Employees = model.EmployeeTravelPlanMappings.Select(mapping => new EmployeeResult(mapping.Employee));
}
public void startStateMachine(TravelPlan travelPlan)
{
/*static*/
int i = 0;
while (true)
{
switch (state)
{
case State.moving:
if (travelPlan.vDepartureTime[i] == clockOBJ.GetTime())
{
try
{
sCurrentlyAt = travelPlan.getStationAt(i).m_sName; // Each Cycle moves the train along one station, destination path stored in vector
Thread.Sleep(2000);
//pitagoras(travelPlan.getStationAt(i).x, travelPlan.getStationAt(i).y, travelPlan.getStationAt(i+1)x, travelPlan.getStationAt(i+1)y); // |
//// set pixel from mid from pitagoras // | Find inbetween keyframe
//std::this_thread::sleep_for(std::chrono::milliseconds(2000)); // |
i++;
Console.WriteLine("Left " + sCurrentlyAt);
SetPixel(travelPlan.getStationAt(i).X, travelPlan.getStationAt(i).Y, m_cSymbol);
SetPixel(travelPlan.getStationAt(i - 1).X, travelPlan.getStationAt(i - 1).Y, 'S'); // clean up last place
m_iLocationX = travelPlan.getStationAt(i).X;
m_iLocationY = travelPlan.getStationAt(i).Y;
}
catch (Exception)
{
Console.WriteLine("End Of The Line");
return;
throw;
}
break;
}
break;
case State.stationary:
break;
}
if (travelPlan.vDepartureTime[i] == "END")
{
Console.WriteLine("End Of The Line");
break;
}
}
}
public async void OnEditButton(DateTime newStartDate, DateTime newEndDate, string newDestination)
{
ResetMessage();
IsLoading = true;
Message = "Processing, please wait.";
DateTime newStartDateRef = newStartDate.Date == new DateTime(1601, 1, 1).Date ? TravelPlan.StartDate : newStartDate;
DateTime newEndDateRef = newEndDate.Date == new DateTime(1601, 1, 1).Date ? TravelPlan.EndDate : newEndDate;
string newDestinationRef = string.IsNullOrEmpty(newDestination) ? TravelPlan.Destination : newDestination;
TravelPlan editTravelPlan = new TravelPlan(TravelPlan.Name, newStartDateRef, newEndDateRef, newDestinationRef);
//REST
try
{
HttpClient httpClient = new HttpClient();
Uri uri = new Uri(BASE_URL + "User/editTravelPlan/" + UserName);
HttpStringContent content = new HttpStringContent(
JsonConvert.SerializeObject(editTravelPlan),
UnicodeEncoding.Utf8,
"application/json");
HttpResponseMessage httpResponseMessage = await httpClient.PutAsync(
uri,
content);
httpResponseMessage.EnsureSuccessStatusCode();
var httpResponseBody = await httpResponseMessage.Content.ReadAsStringAsync();
Message = httpResponseBody;
if (httpResponseBody.Split(" ")[0] != "Error:")
{
if (TravelPlan.StartDate.Date != editTravelPlan.StartDate.Date)
{
TravelPlan.StartDate = editTravelPlan.StartDate;
}
if (TravelPlan.EndDate.Date != editTravelPlan.EndDate.Date)
{
TravelPlan.EndDate = editTravelPlan.EndDate;
}
if (TravelPlan.Destination != editTravelPlan.Destination)
{
TravelPlan.Destination = editTravelPlan.Destination;
}
RaisePropertyChanged("TravelPlan");
}
}
catch (Exception ex)
{
Message = ex.Message;
}
IsLoading = false;
}
public void SaveTravelPlan(TravelPlanDTO travelPlanDTO)
{
TravelPlan updatedTravelPlan = TravelPlans.Where(tp => tp.Id == travelPlanDTO.Id).FirstOrDefault();
updatedTravelPlan.StartDate = travelPlanDTO.StartDate;
updatedTravelPlan.EndDate = travelPlanDTO.EndDate;
updatedTravelPlan.StartLocation = travelPlanDTO.StartLocation;
updatedTravelPlan.EndLocation = travelPlanDTO.EndLocation;
updatedTravelPlan.SelectedCar = travelPlanDTO.SelectedCar;
updatedTravelPlan.SelectedEmployees = travelPlanDTO.SelectedEmployees;
}
public async Task AreEmployeesAvailable_WhenEmployeesHaveNoTripsAtTheSameTime_ReturnsAvailable(
string tripStartString, string tripEndString)
{
// Arrange
var cars = SeedData.GenerateCars(1);
await DbContext.AddRangeAsync(cars);
var car1 = cars[0];
var locations = SeedData.GenerateLocations(2);
var locationA = locations[0].LocationId;
var locationB = locations[1].LocationId;
await DbContext.AddRangeAsync(locations);
var employees = SeedData.GenerateEmployees(3);
employees.First().HasDriverLicence = true; // at least one needs to have driversLicence
var trip = new TravelPlan()
{
CarId = car1.CarId,
StartLocationId = locationA,
EndLocationId = locationB,
StartTimeUtc = new DateTime(2021, 2, 3),
EndTimeUtc = new DateTime(2021, 2, 10),
TravelPlanEmployees = new List <TravelPlanEmployees>()
};
var addEmployees = employees.Select(e => new TravelPlanEmployees()
{
EmployeeId = e.EmployeeId,
});
addEmployees.ForEach(trip.TravelPlanEmployees.Add);
await DbContext.Employees.AddRangeAsync(employees);
await DbContext.TravelPlans.AddRangeAsync(trip);
await DbContext.SaveChangesAsync();
var employeeService = EmployeeServiceFactory();
// Act
var employeeIds = employees.Select(e => e.EmployeeId);
var startDate = DateTime.Parse(tripStartString);
var endDate = DateTime.Parse(tripEndString);
var(success, errorMessage) = await employeeService.AreEmployeesAvailable(employeeIds,
startDate, endDate);
// Assert
success.Should().BeTrue();
}
public ActionResult Create([Bind(Include = "ID,price,startDate,endDate,detail,TravelID")] TravelPlan travelPlan)
{
if (ModelState.IsValid)
{
db.Plans.Add(travelPlan);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(travelPlan));
}
public IActionResult PutPlanDisable(int id)
{
TravelPlan plan = _travelplan.GetById(id);
if (plan != null)
{
_travelplan.SetInValid(plan);
return(Ok());
}
return(NotFound("Plan bulunamadı."));
}
public async Task <IHttpActionResult> PostTravelPlan(TravelPlan travelplan)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.TravelPlans.Add(travelplan);
await db.SaveChangesAsync();
return(CreatedAtRoute("DefaultApi", new { id = travelplan.TravelPlanId }, travelplan));
}
public async Task GetAvailableEmployees_WhenNoEmployees_ReturnsSuccessFalse()
{
// Arrange
var cars = SeedData.GenerateCars(1);
await DbContext.AddRangeAsync(cars);
var car1 = cars[0];
var locations = SeedData.GenerateLocations(2);
var locationA = locations[0].LocationId;
var locationB = locations[1].LocationId;
await DbContext.AddRangeAsync(locations);
var employees = SeedData.GenerateEmployees(3);
employees.ForEach(e => e.HasDriverLicence = true);
var trip = new TravelPlan()
{
CarId = car1.CarId,
StartLocationId = locationA,
EndLocationId = locationB,
StartTimeUtc = new DateTime(2021, 2, 3),
EndTimeUtc = new DateTime(2021, 2, 10),
TravelPlanEmployees = new List <TravelPlanEmployees>()
};
var addEmployees = employees.Select(e => new TravelPlanEmployees()
{
EmployeeId = e.EmployeeId,
});
addEmployees.ForEach(trip.TravelPlanEmployees.Add);
await DbContext.Employees.AddRangeAsync(employees);
await DbContext.TravelPlans.AddRangeAsync(trip);
await DbContext.SaveChangesAsync();
var employeeService = EmployeeServiceFactory();
// Act
var startDate = DateTime.Parse("2021-02-01");
var endDate = DateTime.Parse("2021-02-11");
var(success, employeeResults) = await employeeService.GetAvailableEmployees(startDate, endDate);
// Assert
success.Should().BeFalse();
employeeResults.Should().BeEmpty();
}
public void Update(TravelPlan travelPlan)
{
var _travelPlan = GetByID(travelPlan.Id);
if (_travelPlan != null)
{
_travelPlanRepository.Update(travelPlan);
}
else
{
throw new Exception("There is no travel plan");
}
}
public ActionResult AddNewPlan(TravelPlan plan)
{
if (!ModelState.IsValid)
{
return(View(plan));
}
plan.UserId = User.Identity.GetUserId();
_context.TravelPlan.Add(plan);
_context.SaveChanges();
return(RedirectToAction("Details", new { id = plan.TravelPlanId }));
}
